为了甩锅，我写了个牛逼的日志切面！

àì夳堔傛蜴生んèń 2022-12-26 11:15 142阅读 0赞

关注微信公众号 “java大数据修炼之道”,选择“设为星标”  优质文章和精品资源, 第一时间送达

![format_png][]

关注公众号后台回复**资源**获取实战教学资料+视频

哈喽，各位新来的小伙伴们，大家好！由于公众号做了改版，为了保证公众号的资源能准时推送到你手里，大家记得将咱们的公众号 **加星标置顶** ，在此真诚的表示感谢

![format_png 1][]

最近项目进入联调阶段，服务层的接口需要和协议层进行交互，协议层需要将入参\[json字符串\]组装成服务层所需的json字符串，组装的过程中很容易出错。

入参出错导致接口调试失败问题在联调中出现很多次，因此就想写一个请求日志切面把入参信息打印一下，同时协议层调用服务层接口名称对不上也出现了几次。

通过请求日志切面就可以知道上层是否有没有发起调用，方便前后端甩锅还能拿出证据![format_png 2][]

**切面介绍**

面向切面编程是一种编程范式，它作为OOP面向对象编程的一种补充，用于处理系统中分布于各个模块的横切关注点，比如事务管理、权限控制、缓存控制、日志打印等等。

AOP把软件的功能模块分为两个部分：核心关注点和横切关注点。业务处理的主要功能为核心关注点，而非核心、需要拓展的功能为横切关注点。AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点进行分离，使用切面有以下好处：

*  集中处理某一关注点/横切逻辑
 *  可以很方便的添加/删除关注点
 *  侵入性少，增强代码可读性及可维护性 因此当想打印请求日志时很容易想到切面，对控制层代码0侵入

## **切面的使用【基于注解】** ##

@Aspect => 声明该类为一个注解类

### **切点注解：** ###

@Pointcut => 定义一个切点，可以简化代码

### **通知注解：** ###

*  @Before => 在切点之前执行代码
 *  @After => 在切点之后执行代码
 *  @AfterReturning => 切点返回内容后执行代码，可以对切点的返回值进行封装
 *  @AfterThrowing => 切点抛出异常后执行
 *  @Around => 环绕，在切点前后执行代码

## **动手写一个请求日志切面** ##

*  使用@Pointcut定义切点

@Pointcut("execution(* your_package.controller..*(..))")
    public void requestServer() {
    }

@Pointcut定义了一个切点，因为是请求日志切边，因此切点定义的是Controller包下的所有类下的方法。定义切点以后在通知注解中直接使用requestServer方法名就可以了

*  使用@Before再切点前执行

@Before("requestServer()")
    public void doBefore(JoinPoint joinPoint) {
        ServletRequestAttributes attributes = (ServletRequestAttributes)
    RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
    
        LOGGER.info("===============================Start========================");
        LOGGER.info("IP                 : {}", request.getRemoteAddr());
        LOGGER.info("URL                : {}", request.getRequestURL().toString());
        LOGGER.info("HTTP Method        : {}", request.getMethod());
        LOGGER.info("Class Method       : {}.{}", joinPoint.getSignature().getDeclaringTypeName(), joinPoint.getSignature().getName());
    }

在进入Controller方法前，打印出调用方IP、请求URL、HTTP请求类型、调用的方法名

*  使用@Around打印进入控制层的入参

@Around("requestServer()")
    public Object doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = proceedingJoinPoint.proceed();
        LOGGER.info("Request Params       : {}", getRequestParams(proceedingJoinPoint));
        LOGGER.info("Result               : {}", result);
        LOGGER.info("Time Cost            : {} ms", System.currentTimeMillis() - start);
    
        return result;
    }

打印了入参、结果以及耗时

getRquestParams方法

private Map<String, Object> getRequestParams(ProceedingJoinPoint proceedingJoinPoint) {
         Map<String, Object> requestParams = new HashMap<>();
    
          //参数名
         String[] paramNames = ((MethodSignature)proceedingJoinPoint.getSignature()).getParameterNames();
         //参数值
         Object[] paramValues = proceedingJoinPoint.getArgs();
    
         for (int i = 0; i < paramNames.length; i++) {
             Object value = paramValues[i];
    
             //如果是文件对象
             if (value instanceof MultipartFile) {
                 MultipartFile file = (MultipartFile) value;
                 value = file.getOriginalFilename();  //获取文件名
             }
    
             requestParams.put(paramNames[i], value);
         }
    
         return requestParams;
     }

通过 @PathVariable以及@RequestParam注解传递的参数无法打印出参数名，因此需要手动拼接一下参数名，同时对文件对象进行了特殊处理，只需获取文件名即可

*  @After方法调用后执行

@After("requestServer()")
    public void doAfter(JoinPoint joinPoint) {
        LOGGER.info("===============================End========================");
    }

没有业务逻辑只是打印了End

*  完整切面代码

## **高并发下请求日志切面** ##

写完以后对自己的代码很满意，但是想着可能还有完善的地方就和朋友交流了一下。emmmm

![format_png 3][]

果然还有继续优化的地方 每个信息都打印一行，在高并发请求下确实会出现请求之间打印日志串行的问题，因为测试阶段请求数量较少没有出现串行的情况，果然生产环境才是第一发展力，能够遇到更多bug，写更健壮的代码 解决日志串行的问题只要将多行打印信息合并为一行就可以了，因此构造一个对象

*  RequestInfo.java

@Data
    public class RequestInfo {
        private String ip;
        private String url;
        private String httpMethod;
        private String classMethod;
        private Object requestParams;
        private Object result;
        private Long timeCost;
    }

*  环绕通知方法体

@Around("requestServer()")
    public Object doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        Object result = proceedingJoinPoint.proceed();
        RequestInfo requestInfo = new RequestInfo();
                requestInfo.setIp(request.getRemoteAddr());
        requestInfo.setUrl(request.getRequestURL().toString());
        requestInfo.setHttpMethod(request.getMethod());
        requestInfo.setClassMethod(String.format("%s.%s", proceedingJoinPoint.getSignature().getDeclaringTypeName(),
                proceedingJoinPoint.getSignature().getName()));
        requestInfo.setRequestParams(getRequestParamsByProceedingJoinPoint(proceedingJoinPoint));
        requestInfo.setResult(result);
        requestInfo.setTimeCost(System.currentTimeMillis() - start);
        LOGGER.info("Request Info      : {}", JSON.toJSONString(requestInfo));
    
        return result;
    }

将url、http request这些信息组装成RequestInfo对象，再序列化打印对象 打印序列化对象结果而不是直接打印对象是因为序列化有更直观、更清晰，同时可以借助在线解析工具对结果进行解析

![format_png 4][]

是不是还不错 在解决高并发下请求串行问题的同时添加了对异常请求信息的打印，通过使用 @AfterThrowing注解对抛出异常的方法进行处理

*  RequestErrorInfo.java

@Data
    public class RequestErrorInfo {
        private String ip;
        private String url;
        private String httpMethod;
        private String classMethod;
        private Object requestParams;
        private RuntimeException exception;
    }

异常通知环绕体

@AfterThrowing(pointcut = "requestServer()", throwing = "e")
    public void doAfterThrow(JoinPoint joinPoint, RuntimeException e) {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        RequestErrorInfo requestErrorInfo = new RequestErrorInfo();
        requestErrorInfo.setIp(request.getRemoteAddr());
        requestErrorInfo.setUrl(request.getRequestURL().toString());
        requestErrorInfo.setHttpMethod(request.getMethod());
        requestErrorInfo.setClassMethod(String.format("%s.%s", joinPoint.getSignature().getDeclaringTypeName(),
                joinPoint.getSignature().getName()));
        requestErrorInfo.setRequestParams(getRequestParamsByJoinPoint(joinPoint));
        requestErrorInfo.setException(e);
        LOGGER.info("Error Request Info      : {}", JSON.toJSONString(requestErrorInfo));
    }

对于异常，耗时是没有意义的，因此不统计耗时，而是添加了异常的打印

最后放一下完整日志请求切面代码：

@Component
    @Aspect
    public class RequestLogAspect {
        private final static Logger LOGGER = LoggerFactory.getLogger(RequestLogAspect.class);
    
        @Pointcut("execution(* your_package.controller..*(..))")
        public void requestServer() {
        }
    
        @Around("requestServer()")
        public Object doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
            long start = System.currentTimeMillis();
            ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
            HttpServletRequest request = attributes.getRequest();
            Object result = proceedingJoinPoint.proceed();
            RequestInfo requestInfo = new RequestInfo();
                    requestInfo.setIp(request.getRemoteAddr());
            requestInfo.setUrl(request.getRequestURL().toString());
            requestInfo.setHttpMethod(request.getMethod());
            requestInfo.setClassMethod(String.format("%s.%s", proceedingJoinPoint.getSignature().getDeclaringTypeName(),
                    proceedingJoinPoint.getSignature().getName()));
            requestInfo.setRequestParams(getRequestParamsByProceedingJoinPoint(proceedingJoinPoint));
            requestInfo.setResult(result);
            requestInfo.setTimeCost(System.currentTimeMillis() - start);
            LOGGER.info("Request Info      : {}", JSON.toJSONString(requestInfo));
    
            return result;
        }
    
    
        @AfterThrowing(pointcut = "requestServer()", throwing = "e")
        public void doAfterThrow(JoinPoint joinPoint, RuntimeException e) {
            ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
            HttpServletRequest request = attributes.getRequest();
            RequestErrorInfo requestErrorInfo = new RequestErrorInfo();
            requestErrorInfo.setIp(request.getRemoteAddr());
            requestErrorInfo.setUrl(request.getRequestURL().toString());
            requestErrorInfo.setHttpMethod(request.getMethod());
            requestErrorInfo.setClassMethod(String.format("%s.%s", joinPoint.getSignature().getDeclaringTypeName(),
                    joinPoint.getSignature().getName()));
            requestErrorInfo.setRequestParams(getRequestParamsByJoinPoint(joinPoint));
            requestErrorInfo.setException(e);
            LOGGER.info("Error Request Info      : {}", JSON.toJSONString(requestErrorInfo));
        }
    
        /**
         * 获取入参
         * @param proceedingJoinPoint
         *
         * @return
         * */
        private Map<String, Object> getRequestParamsByProceedingJoinPoint(ProceedingJoinPoint proceedingJoinPoint) {
            //参数名
            String[] paramNames = ((MethodSignature)proceedingJoinPoint.getSignature()).getParameterNames();
            //参数值
            Object[] paramValues = proceedingJoinPoint.getArgs();
    
            return buildRequestParam(paramNames, paramValues);
        }
    
        private Map<String, Object> getRequestParamsByJoinPoint(JoinPoint joinPoint) {
            //参数名
            String[] paramNames = ((MethodSignature)joinPoint.getSignature()).getParameterNames();
            //参数值
            Object[] paramValues = joinPoint.getArgs();
    
            return buildRequestParam(paramNames, paramValues);
        }
    
        private Map<String, Object> buildRequestParam(String[] paramNames, Object[] paramValues) {
            Map<String, Object> requestParams = new HashMap<>();
            for (int i = 0; i < paramNames.length; i++) {
                Object value = paramValues[i];
    
                //如果是文件对象
                if (value instanceof MultipartFile) {
                    MultipartFile file = (MultipartFile) value;
                    value = file.getOriginalFilename();  //获取文件名
                }
    
                requestParams.put(paramNames[i], value);
            }
    
            return requestParams;
        }
    
        @Data
        public class RequestInfo {
            private String ip;
            private String url;
            private String httpMethod;
            private String classMethod;
            private Object requestParams;
            private Object result;
            private Long timeCost;
        }
    
        @Data
        public class RequestErrorInfo {
            private String ip;
            private String url;
            private String httpMethod;
            private String classMethod;
            private Object requestParams;
            private RuntimeException exception;
        }
    }

赶紧给你们的应用加上吧【如果没加的话】，没有日志的话，总怀疑上层出错，但是却拿不出证据

我把 面试 相关的文章整理成了 PDF，关注微信公众号 Java大数据修炼之道，回复  PDF 下载吧。

![format_png 5][]

关于traceId 跟踪定位，可以根据traceId跟踪整条调用链，以log4j2为例介绍如何加入traceId

*  添加拦截器

public class LogInterceptor implements HandlerInterceptor {
        private final static String TRACE_ID = "traceId";
    
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            String traceId = java.util.UUID.randomUUID().toString().replaceAll("-", "").toUpperCase();
            ThreadContext.put("traceId", traceId);
    
            return true;
        }
    
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)
                throws Exception {
        }
    
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
                throws Exception {
            ThreadContext. remove(TRACE_ID);
        }
    }

在调用前通过ThreadContext加入traceId，调用完成后移除

*  修改日志配置文件 在原来的日志格式中 添加traceId的占位符

<property name="pattern">[TRACEID:%X{traceId}] %d{HH:mm:ss.SSS} %-5level %class{-1}.%M()/%L - %msg%xEx%n</property>

*  执行效果

![format_png 6][]

日志跟踪更方便 DMC是配置logback和log4j使用的，使用方式和ThreadContext差不多，将ThreadContext.put替换为MDC.put即可，同时修改日志配置文件。

![format_png 7][]

MDC是slf4j包下的，其具体使用哪个日志框架与我们的依赖有关。

来源：r6d.cn/2Zrc

![06db1ba5ea516dc14d91e9e942677c0e.gif][]

**推荐阅读：**

1、[SQL 优化极简法则][SQL]

[2][][、][2][项目中常用的19条MySQL优化][2]

3、[最新SQL数据库面试题以及答案！][SQL 1]

[4、][4][Redis的 8大数据类型，写得非常好！][Redis_ 8]

5、[面试官：来说说单点登录的三种实现方式][Link 1]

[6、][6][这5个能挣钱的 SpringBoot 项目，真TMD香！][5_ SpringBoot _TMD]

7、[单怼60道][60][多线程][60][面试题，你能答上几个?(附答案)][60]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1NjYxMTcx_size_16_color_FFFFFF_t_70][]

[format_png]: /images/20221120/2ab5f42711e34d96b0a51b486fc308b3.png
[format_png 1]: /images/20221120/12f43bddb619417dae9697a519bdb92a.png
[format_png 2]: /images/20221120/684aeb1b93734527813f5f6ec6a6d875.png
[format_png 3]: /images/20221120/89af0d2cdc0c404c8b47447157ea7178.png
[format_png 4]: /images/20221120/71f1c93d28a94c00b32688ec208fabe4.png
[format_png 5]: /images/20221120/1eb53cd61d5f4ccfba3bed70600afc25.png
[format_png 6]: /images/20221120/e623136b36eb459093c0075369f32b15.png
[format_png 7]: /images/20221120/00a8d259ace94cf288cd0182477ce645.png
[06db1ba5ea516dc14d91e9e942677c0e.gif]: /images/20221120/e0917633398d4ad1b4d393536b5f60e1.png
[SQL]: http://mp.weixin.qq.com/s?__biz=MzU1NjczNTM5NQ==&mid=2247494475&idx=1&sn=7e646baf02607ca5bcdbbba811e5d1f1&chksm=fbc22587ccb5ac91516740577ab3387127c9b083285055c0fdbe7f54b4fbbcb9cd86ec1ec4dc&scene=21#wechat_redirect
[2]: http://mp.weixin.qq.com/s?__biz=MzU1NjczNTM5NQ==&mid=2247492315&idx=1&sn=37c6888e30892c7fae56d0769c35a571&chksm=fbc22c17ccb5a501df41ddeaecf0f7e85e292b45d6c7522e4d6a4d9c4a93a389338ee175eae8&scene=21#wechat_redirect
[SQL 1]: http://mp.weixin.qq.com/s?__biz=MzU1NjczNTM5NQ==&mid=2247493386&idx=1&sn=6014e7fb6c2a43ca8df3b011754fa4e1&chksm=fbc229c6ccb5a0d068fdce76d8e457510c9c43e866952a917ae63ee0f1da8c5c25bd5d3879a2&scene=21#wechat_redirect
[4]: http://mp.weixin.qq.com/s?__biz=MzU1NjczNTM5NQ==&mid=2247492363&idx=1&sn=6975a1a5de92dc49d04654f21ffa7c21&chksm=fbc22dc7ccb5a4d1b94f2a9bbce26082c9f845fbbf7d588a5540d072bcef39b2281d0b705f91&scene=21#wechat_redirect
[Redis_ 8]: http://mp.weixin.qq.com/s?__biz=MzU1NjczNTM5NQ==&mid=2247494511&idx=1&sn=bddc2a964cc7ecc77201f6fe19ac53ed&chksm=fbc225a3ccb5acb5d67e4ac6f7e5be3ab32de92a9521a08696020d01a324a3a016568ff6158f&scene=21#wechat_redirect
[Link 1]: http://mp.weixin.qq.com/s?__biz=MzU1NjczNTM5NQ==&mid=2247493492&idx=1&sn=cd0a9b65387d5107fe9d0e1ded268d22&chksm=fbc229b8ccb5a0ae5f433e40aeb031d462bc825b837ca9e09720b6b58439dada694eeb54bbaf&scene=21#wechat_redirect
[6]: http://mp.weixin.qq.com/s?__biz=MzU1NjczNTM5NQ==&mid=2247492809&idx=1&sn=47c50b227f8063129ed09edc91449100&chksm=fbc22a05ccb5a31383ee13bb6c58f8c12dada691c16624e028f23f24c32d1e4201b4ebd1a354&scene=21#wechat_redirect
[5_ SpringBoot _TMD]: http://mp.weixin.qq.com/s?__biz=MzU1NjczNTM5NQ==&mid=2247494522&idx=1&sn=98eb0cfc5d325f7f06582ad4cdf844cd&chksm=fbc225b6ccb5aca0a42bc26c5b7a9cecc3222a5e1e8517b243a8882c1baf2b24a9cfb449bfc8&scene=21#wechat_redirect
[60]: http://mp.weixin.qq.com/s?__biz=MzU1NjczNTM5NQ==&mid=2247490459&idx=1&sn=66bc23ae41a8abcb9a6f00be754b2e47&chksm=fbc1d557ccb65c41ec5d3b7dedd6c7a22949ddcb5de1406de482c3b702a1a4768c66b730b219&scene=21#wechat_redirect
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1NjYxMTcx_size_16_color_FFFFFF_t_70]: /images/20221120/3bd1711c38804dfab594490440e2b466.png