Springboot通過過濾器記錄一切請求及返回信息併入庫

沒廢話，直接上代碼

LoggerEntity：記錄請求信息，做入庫用

import java.util.Date;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

import lombok.Data;

@Entity(name="t_logger_info")
@Data
public class LoggerEntity {
	@Id
	@GeneratedValue
	private Integer id;
	
	private String clientIp;
	
	private String url;
	
	private String type;
	
	private String method;
	
	private String paramdata;
	
	private String sessionid;
	
	private Date time;
	
	private String returntime;
	
	private String returndata;
	
	//請求時httpStatusCode代碼，如：200,400,404等
    private String httpStatusCode;
    //請求耗時秒單位
    private int timeConsuming;
}

LoggerUtils 獲取請求ip

在這裏插入代碼片

import javax.servlet.http.HttpServletRequest;

public class LoggerUtils {
    public static final String LOGGER_RETURN = "_logger_return";

    private LoggerUtils() {}

    /**
     * 獲取客戶端ip地址
     * @param request
     * @return
     */
    public static String getCliectIp(HttpServletRequest request)
    {
        String ip = request.getHeader("x-forwarded-for");
        if (ip == null || ip.trim() == "" || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.trim() == "" || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.trim() == "" || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }

        // 多個路由時，取第一個非unknown的ip
        final String[] arr = ip.split(",");
        for (final String str : arr) {
            if (!"unknown".equalsIgnoreCase(str)) {
                ip = str;
                break;
            }
        }
        return ip;
    }

    /**
     * 判斷是否爲ajax請求
     * @param request
     * @return
     */
    public static String getRequestType(HttpServletRequest request) {
        return request.getHeader("X-Requested-With");
    }
}

SessionInterceptor 主要做攔截的業務類

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.web.context.support.WebApplicationContextUtils;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;

import eureka.manager.loggerinfo.LoggerEntity;
import eureka.manager.loggerinfo.LoggerUtils;
import eureka.manager.service.LoggerServiceRepository;

public class SessionInterceptor  implements HandlerInterceptor{
	
	 //請求開始時間標識
    private static final String LOGGER_SEND_TIME = "_send_time";
    //請求日誌實體標識
    private static final String LOGGER_ENTITY = "_logger_entity";
    
    //在進入  controller進行記錄
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object o) throws Exception {
        System.out.println(request.getRequestURI());
        //保存日誌對象
        LoggerEntity logger=new LoggerEntity();
        //獲取請求sessionId
        String sessionId = request.getRequestedSessionId();
        //請求路徑
        String url = request.getRequestURI();
        //獲取請求參數信息
        String paramData = JSON.toJSONString(request.getParameterMap(),
                SerializerFeature.DisableCircularReferenceDetect,
                SerializerFeature.WriteMapNullValue);
        //設置客戶端ip
        logger.setClientIp(LoggerUtils.getCliectIp(request));
        //設置請求方法
        logger.setMethod(request.getMethod());
        //設置請求類型（json|普通請求）
        logger.setType(LoggerUtils.getRequestType(request));
        //設置請求參數內容json字符串
        logger.setParamdata(paramData);
        //設置請求地址
        logger.setUrl(url);
        //設置sessionId
        logger.setSessionid(sessionId);
        //設置請求開始時間
        request.setAttribute(LOGGER_SEND_TIME,System.currentTimeMillis());
        //設置請求實體到request內，方面afterCompletion方法調用
        request.setAttribute(LOGGER_ENTITY,logger);
        
        
        //登錄不做攔截
        if(request.getRequestURI().equals("/user/login") || request.getRequestURI().equals("/user/login_view"))
        {
            return true;
        }
        //驗證session是否存在
        Object obj = request.getSession().getAttribute("_session_user");
        if(obj == null)
        {
            return false;
        }
        return true;
    }

    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {

    }
    
    //在進離開 controller進行記錄
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object o, Exception e) throws Exception {
    	  //獲取請求錯誤碼
        int status = response.getStatus();
        //當前時間
        long currentTime = System.currentTimeMillis();
        //請求開始時間
        long time = Long.valueOf(request.getAttribute(LOGGER_SEND_TIME).toString());
        //獲取本次請求日誌實體
        LoggerEntity loggerEntity = (LoggerEntity) request.getAttribute(LOGGER_ENTITY);
        //設置請求時間差
        loggerEntity.setTimeConsuming(Integer.valueOf((currentTime - time)+""));
        //設置返回時間
        loggerEntity.setReturntime(currentTime + "");
        //設置返回錯誤碼
        loggerEntity.setHttpStatusCode(status+"");
        //設置返回值
        loggerEntity.setReturndata(JSON.toJSONString(request.getAttribute(LoggerUtils.LOGGER_RETURN),
                SerializerFeature.DisableCircularReferenceDetect,
                SerializerFeature.WriteMapNullValue));
        //執行將日誌寫入數據庫
        LoggerServiceRepository loggerDAO = getDAO(LoggerServiceRepository.class,request);
        loggerDAO.save(loggerEntity);
    }
    /**
     * 根據傳入的類型獲取spring管理的對應dao
     * @param clazz 類型
     * @param request 請求對象
     * @param <T>
     * @return
     */

    private <T> T getDAO(Class<T> clazz,HttpServletRequest request)
    {
    	BeanFactory  factory  =  WebApplicationContextUtils.getRequiredWebApplicationContext(request.getServletContext());
        return factory.getBean(clazz);
    }
}

SessionConfiguration ：業務都好了，然後就是將過濾器配置到容器

mport org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@Configuration
public class SessionConfiguration extends WebMvcConfigurerAdapter
{
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new SessionInterceptor()).addPathPatterns("/**");
    }
}

裏面有點東西挺有用的就是在過濾器，攔截器，監聽裏面獲取容器對象的方法

    private <T> T getDAO(Class<T> clazz,HttpServletRequest request)
    {
    	BeanFactory  factory  =  WebApplicationContextUtils.
    	getRequiredWebApplicationContext(request.getServletContext());
        return factory.getBean(clazz);
    }