使用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 startTime = new ThreadLocal();
    private static ThreadLocal key = new ThreadLocal();
    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 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<<<<<

//需要使用到spring-starter-aop架包

         
            org.springframework.boot
            spring-boot-starter-aop
        

结果:
使用Spring的Aop拦截请求参数,请求头信息,响应结果,响应时间_第1张图片

建议使用apache-common重写toString方法,避免增加字段时需要更新toString方法

toString方法
return ToStringBuilder.reflectionToString(this, ToStringStyle.SHORT_PREFIX_STYLE);
org.apache.commons.lang.builder.ReflectionToStringBuilder是commons-lang里的一个类

你可能感兴趣的:(java)