Springboot通过拦截器记录一切请求及返回信息并入库

原创已于 2023-10-09 16:46:21 修改 · 5.5k 阅读

17 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#过滤器 #请求信息拦截 #返回信息拦截 #Springboot #java

于 2019-04-29 19:51:02 首次发布

项目设计同时被 2 个专栏收录

42 篇文章

订阅专栏

springBoot

15 篇文章

订阅专栏

本文介绍了一种用于记录和管理HTTP请求日志的方法，包括使用Java实体类LoggerEntity来存储请求信息，通过LoggerUtils类获取客户端IP和请求类型，以及SessionInterceptor类实现请求的拦截和日志记录。此外，还介绍了如何通过Spring MVC配置拦截器，并利用切面（AOP）技术获取请求参数和结果。

没废话，直接上代码

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);
    }

通过切面获取请求值和结果，埋点MDC


@Aspect
@Component
public class FeignMdcAcpect {
    protected static final Logger logger = LoggerFactory.getLogger(FeignMdcAcpect.class);
    /**
     * 定义切入点
     * */
    @Pointcut("execution(* com.iot.feign.controller..*.*(..))")
    public void mdcAcpect(){}

    /**
     * 前置通知
     * */
    @Before("mdcAcpect()")
    public void doBefore(JoinPoint joinPoint)  {
        HttpServletRequest request = ((ServletRequestAttributes)RequestContextHolder.getRequestAttributes()).getRequest();
        String traceId = request.getHeader(Constant.TRACE_ID);
        if (traceId == null) {
            traceId = IdUtil.fastSimpleUUID();
        }
        MDC.put(Constant.TRACE_ID, traceId);

        try {
            Object[] args = joinPoint.getArgs();
            Object[] arguments = new Object[args.length];
            for (int i = 0; i < args.length; i++) {
                if (args[i] instanceof ServletRequest || args[i] instanceof ServletResponse || args[i] instanceof MultipartFile) {
                    continue;
                }
                arguments[i] = args[i];
            }
            String paramter = "";
            if (arguments != null) {
                try {
                    paramter = JSONObject.toJSONString(arguments);
                } catch (Exception e) {
                    paramter = arguments.toString();
                }
            }
            logger.info("feign 请求接口名:{}    请求参数:{}", request.getRequestURI(),paramter);

        }catch (Exception e){

        }
    }

    @AfterReturning(returning="ret",pointcut = "mdcAcpect()")
    public void doAfterReturning(Object ret)throws Exception{
        ServletRequestAttributes attributes =(ServletRequestAttributes)RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        //接收到响应,打印请求内容
        logger.info("feign 请求接口:{}    响应为:{}",request.getRequestURI(),JSON.toJSONString(ret));
    }

}