日志切面

最近项目进入联调阶段,服务层的接口需要和协议层进行交互,协议层需要将入参[json字符串]组装成服务层所需的json字符串,组装的过程中很容易出错。入参出错导致接口调试失败问题在联调中出现很多次,因此就想写一个请求日志切面把入参信息打印一下,同时协议层调用服务层接口名称对不上也出现了几次,通过请求日志切面就可以知道上层是否有没有发起调用,方便前后端甩锅还能拿出证据

写在前面

本篇文章是实战性的,对于切面的原理不会讲解,只会简单介绍一下切面的知识点

切面介绍

面向切面编程是一种编程范式,它作为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

  • 完整切面代码

    @Component
    @Aspect
    public class RequestLogAspect {
        private final static Logger LOGGER = LoggerFactory.getLogger(RequestLogAspect.class);
    
        @Pointcut("execution(* your_package.controller..*(..))")
        public void requestServer() {
        }
    
        @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());
        }
    
    
        @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;
        }
    
        @After("requestServer()")
        public void doAfter(JoinPoint joinPoint) {
            LOGGER.info("===============================End========================");
        }
    
        /**
         * 获取入参
         * @param proceedingJoinPoint
         *
         * @return
         * */
        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;
        }
    }
    
    

高并发下请求日志切面

 

果然还有继续优化的地方 每个信息都打印一行,在高并发请求下确实会出现请求之间打印日志串行的问题,因为测试阶段请求数量较少没有出现串行的情况,果然生产环境才是第一发展力,能够遇到更多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对象,再序列化打印对象 打印序列化对象结果而不是直接打印对象是因为序列化有更直观、更清晰,同时可以借助在线解析工具对结果进行解析

是不是还不错 在解决高并发下请求串行问题的同时添加了对异常请求信息的打印,通过使用 @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;
    }
}

 

关于traceId 跟踪定位【地藏Kelvin的评论】,可以根据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>
    
    
  • 执行效果

    日志跟踪更方便

DMC是配置logback和log4j使用的,使用方式和ThreadContext差不多,将ThreadContext.put替换为MDC.put即可,同时修改日志配置文件。推荐使用log4j2,为什么推荐使用log4j2可以看下这篇文章:日志框架,选择Logback Or Log4j2?

 log4j2也是可以配合MDC一起使用的

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

<think>好的,用户的问题是关于在单元测试中实现日志切面的最佳实践和示例。首先,我需要回忆一下AOP和日志切面的相关知识。日志切面通常使用面向切面编程来实现,比如在Spring框架中,可以通过@Aspect注解定义切面,然后在切点表达式指定的方法前后添加日志记录。 用户提到的是单元测试中的实现,可能需要考虑如何在测试环境中正确地加载切面配置,确保日志记录功能被触发。同时,单元测试需要隔离外部依赖,所以可能需要使用模拟框架,比如Mockito,来避免日志记录影响测试结果。 接下来,我需要参考提供的引用内容。引用[1]提到使用自定义注解来存储日志描述,引用[2]和[3]讨论了如何在Java中使用AOP实现日志记录,特别是Spring Boot中的自定义starter。这些信息可以帮助构建一个具体的示例,展示如何在单元测试中配置日志切面。 然后,思考用户可能的实际需求。他们可能在开发中遇到了日志在测试中不生效的问题,或者想验证日志输出是否符合预期。因此,最佳实践应包括如何正确配置测试上下文,以及如何断言日志内容。 还需要考虑单元测试的独立性,可能需要使用内存数据库或模拟对象来确保测试的纯粹性。例如,使用Spring Boot的@SpringBootTest注解加载最小配置,或者使用@WebMvcTest只加载相关的MVC组件。 另外,关于日志记录的测试,可以使用如Logback的测试框架或者捕获日志输出,然后通过断言来验证日志信息是否正确生成。例如,使用JUnit的扩展或者第三方库如Awaitility来检查日志文件。 最后,整理步骤:定义日志切面,编写单元测试配置,模拟或真实调用业务方法,捕获并验证日志输出。同时,需要注意测试环境的隔离和依赖管理,确保测试的可靠性和重复性。</think>### 如何在单元测试中实现日志切面功能? #### 一、核心思路 1. **分离关注点**:通过AOP将日志记录逻辑与业务代码解耦,确保单元测试仅验证业务逻辑[^2]。 2. **轻量级配置**:在测试中仅加载与日志切面相关的模块,避免启动完整Spring上下文。 3. **日志内容验证**:使用内存日志框架或日志捕获工具(如`Logback`的`MemoryAppender`)验证切面行为。 --- #### 二、实现步骤与示例(Spring Boot + JUnit 5) ##### 1. 定义日志切面 ```java @Aspect @Component public class LogAspect { private static final Logger logger = LoggerFactory.getLogger(LogAspect.class); @Around("@annotation(com.example.LogExecution)") // 自定义注解标记需要记录的方法 public Object logMethodExecution(ProceedingJoinPoint joinPoint) throws Throwable { String methodName = joinPoint.getSignature().getName(); logger.info("方法执行开始: {}", methodName); long startTime = System.currentTimeMillis(); Object result = joinPoint.proceed(); long duration = System.currentTimeMillis() - startTime; logger.info("方法执行结束: {},耗时: {}ms", methodName, duration); return result; } } ``` ##### 2. 单元测试配置 ```java @ExtendWith(SpringExtension.class) @ContextConfiguration(classes = { LogAspect.class, // 加载切面 TestService.class // 被测试的业务类 }) @EnableAspectJAutoProxy // 启用AOP代理 public class LogAspectTest { @Autowired private TestService testService; @MockBean private DependencyComponent dependency; // 模拟外部依赖 @TestConfiguration static class Config { @Bean public Logger logger() { return LoggerFactory.getLogger("TEST_LOGGER"); } } } ``` ##### 3. 验证日志输出 ```java @Test public void testLogAspectOutput() { // 配置内存日志捕获 MemoryAppender memoryAppender = new MemoryAppender(); memoryAppender.start(); // 执行被切面包裹的方法 testService.doSomething(); // 验证日志内容 List<ILoggingEvent> logs = memoryAppender.getLoggedEvents(); assertThat(logs) .extracting(ILoggingEvent::getFormattedMessage) .containsExactly( "方法执行开始: doSomething", "方法执行结束: doSomething,耗时: [0-9]+ms" ); } ``` --- #### 三、最佳实践 1. **最小化上下文加载** 使用`@WebMvcTest`或`@DataJpaTest`等切片测试注解,而非完整的`@SpringBootTest`。 2. **模拟依赖行为** 通过`@MockBean`隔离外部系统调用: ```java @MockBean private DatabaseService databaseService; @Test public void testServiceWithMock() { when(databaseService.query()).thenReturn(mockData); testService.process(); verify(databaseService).query(); } ``` 3. **异步日志处理** 若使用异步日志(如Logback的`AsyncAppender`),需在测试中强制刷新: ```java @AfterEach void flushAsyncLoggers() { LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory(); context.getScheduledExecutorService().shutdownNow(); } ``` --- #### 四、常见问题解决方案 | 问题场景 | 解决方案 | |---------|----------| | 切面未生效 | 检查`@EnableAspectJAutoProxy`是否启用,确保切面类被Spring扫描 | | 日志内容缺失 | 确认测试使用的Logger名称与切面中一致,检查日志级别设置 | | 多线程日志丢失 | 使用同步Appender或增加测试等待时间 | ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值