使用Spring的Aop拦截请求参数,请求头信息,响应结果,响应时间

红太狼 2022-12-02 12:27 379阅读 0赞

参考文章：[使用Spring的Aop拦截请求参数,请求头信息,响应结果,响应时间][Spring_Aop]

在Web应用中线上请求的监控非常重要,在大部分的应用中对于请求参数返回参数，响应时间，请求头信息都是非常重要的，对于线上问题排查是非常重要的。

这里使用Spring aop来实现对每个请求监控，打印请求参数,返回参数等等。在实际应用中随着线上应用的稳定需要对uri做监控管理，哪些需要监控，哪些不需要等等设置，如果稳定的请求监控会消耗大量的性能。

最好能够对每个请求实体返回实体实现系列化接口，重写toString方法，这样就打印参数时避免系列化，系列化会消耗请求响应时间。

关于http请求头信息：  
每个HTTP请求和响应都会带有相应的头部信息。默认情况下，在发送XHR请求的同时，还会发送下列头部信息：

>  *  Accept:浏览器能够处理的内容类型
>  *  Accept-Charset:浏览器能够显示的字符集
>  *  Accept-Encoding：浏览器能够处理的压缩编码
>  *  Accept-Language：浏览器当前设置的语言
>  *  Connection：浏览器与服务器之间连接的类型
>  *  Cookie：当前页面设置的任何Cookie
>  *  Host：发出请求的页面所在的域
>  *  Referer：发出请求的页面的URL
>  *  User-Agent：浏览器的用户代理字符串

**监控url请求代码：**

package com.xfl.boot.interceptor;
    
    import com.fasterxml.jackson.core.JsonProcessingException;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.xfl.boot.common.utils.URLEncodedUtils;
    import org.apache.commons.lang.StringUtils;
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.AfterReturning;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.http.HttpMethod;
    import org.springframework.stereotype.Component;
    import org.springframework.web.context.request.RequestAttributes;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpSession;
    import java.io.Serializable;
    import java.util.Enumeration;
    import java.util.UUID;
    
    /**
     * Created by XFL
     * time on 2018/5/28 23:07
     * description:
     */
    @Aspect
    @Component
    public class ControllerInterceptor {
        private static final Logger log = LoggerFactory.getLogger(ControllerInterceptor.class);
        private static ThreadLocal<Long> startTime = new ThreadLocal<Long>();
        private static ThreadLocal<String> key = new ThreadLocal<String>();
        private static  ObjectMapper objectMapper = new ObjectMapper();
        /**
         * 定义拦截规则：拦截com.xfl.boot.controller..*(..))包下面的所有类中，有@RequestMapping注解的方法
         */
        @Pointcut("@annotation(org.springframework.web.bind.annotation.RequestMapping)")
        public void controllerMethodPointcut() {
        }
    
        /**
         * 请求方法前打印内容
         *
         * @param joinPoint
         */
        @Before("controllerMethodPointcut()")
        public void doBefore(JoinPoint joinPoint) {
            // 请求开始时间
            startTime.set(System.currentTimeMillis());
            RequestAttributes ra = RequestContextHolder.getRequestAttributes();
            ServletRequestAttributes sra = (ServletRequestAttributes) ra;
            HttpServletRequest request = sra.getRequest();
            // 如果有session则返回session如果没有则返回null(避免创建过多的session浪费内存)
            HttpSession session = request.getSession(false);
            // 获取请求头
            Enumeration<String> enumeration = request.getHeaderNames();
            StringBuffer headers = new StringBuffer();
            while (enumeration.hasMoreElements()) {
                String name = enumeration.nextElement();
                String value = request.getHeader(name);
                headers.append(name + ":" + value).append(",");
            }
            String uri = UUID.randomUUID() + "|" + request.getRequestURI();
    
            String method = request.getMethod();
            StringBuffer params = new StringBuffer();
            if (HttpMethod.GET.toString().equals(method)) {// get请求
                String queryString = request.getQueryString();
                if (StringUtils.isNotBlank(queryString)) {
                    params.append(URLEncodedUtils.encode(queryString, "UTF-8"));
                }
            } else {//其他请求
                Object[] paramsArray = joinPoint.getArgs();
                if (paramsArray != null && paramsArray.length > 0) {
                    for (int i = 0; i < paramsArray.length; i++) {
                        if (paramsArray[i] instanceof Serializable) {
                            params.append(paramsArray[i].toString()).append(",");
                        } else {
                            //使用json系列化 反射等等方法 反系列化会影响请求性能建议重写tostring方法实现系列化接口
                            try {
                                String param= objectMapper.writeValueAsString(paramsArray[i]);
                                if(StringUtils.isNotBlank(param))
                                params.append(param).append(",");
                            } catch (JsonProcessingException e) {
                                log.error("doBefore obj to json exception obj={},msg={}",paramsArray[i],e);
                            }
                        }
                    }
                }
            }
            key.set(uri);
            log.info("request params>>>>>>uri={},method={},params={},headers={}", uri, method, params, headers);
        }
    
        /**
         * 在方法执行后打印返回内容
         *
         * @param obj
         */
        @AfterReturning(returning = "obj", pointcut = "controllerMethodPointcut()")
        public void doAfterReturing(Object obj) {
            long costTime = System.currentTimeMillis() - startTime.get();
            String uri = key.get();
            startTime.remove();
            key.remove();
            String result= null;
            if(obj instanceof Serializable){
                result =  obj.toString();
            }else {
                if(obj != null) {
                    try {
                        result = objectMapper.writeValueAsString(obj);
                    } catch (JsonProcessingException e) {
                        log.error("doAfterReturing obj to json exception obj={},msg={}",obj,e);
                    }
                }
            }
            log.info("response result<<<<<<uri={},result={},costTime={}ms", uri, result, costTime);
        }
    }

[Spring_Aop]: https://blog.csdn.net/u010180738/article/details/80490704