首页 > 软件编程 > java > Spring AOP日志自动打印

基于Spring AOP实现日志自动打印功能

2025-01-06 09:52:05 作者：程序员谷美

这篇文章主要介绍了基于Spring AOP实现日志自动打印功能,文中通过代码示例讲解的非常详细,对大家的学习或工作有一定的帮助,需要的朋友可以参考下

概述

日志记录是现代应用程序开发中的重要组成部分。然而，在实际开发中，我们经常面临一些痛点：

重复打印出入参：在开发中经常需要在每个方法中手动编写日志代码，这样的工作不仅重复，而且使代码显得冗余和杂乱。
统一的追踪标识： 在排查问题时，我们经常通过接口请求信息去查日志，这个时候我们一般需要一个traceId将所有请求串起来，这几乎是每个方法都必须实现的功能：打印traceId。
接口requestId的返回： 为了方便上下游查问题，一般在接口设计时，响应体都包含一个requestId字段，这个 requestId 字段，一般就是我们打印的traceId。如果我们每次都手动设置，需要对各种返回情况(如204、500)等进行判断，显得代码杂乱和臃肿。
接口耗时打印：我们需要记录每个功能耗时的情况，方便性能问题排查。

使用 Spring AOP和Logback来封装日志打印组件

1. 引入相关依赖

<dependency>     
    <groupId>org.springframework.boot</groupId>     
    <artifactId>spring-boot-starter-aop</artifactId> 
</dependency> 
<dependency>     
    <groupId>ch.qos.logback</groupId>    
  <artifactId>logback-classic</artifactId> 
</dependency>

2. 创建Aop切面

  
import com.fasterxml.jackson.databind.ObjectMapper;  
import com.gis.components.dto.Response;  
import com.gis.components.dto.StatusCode;  
import com.gis.components.exception.BizException;  
import com.gis.components.exception.SysException;  
import lombok.extern.slf4j.Slf4j;  
import org.aspectj.lang.ProceedingJoinPoint;  
import org.aspectj.lang.annotation.Around;  
import org.aspectj.lang.annotation.Aspect;  
import org.aspectj.lang.annotation.Pointcut;  
import org.aspectj.lang.reflect.MethodSignature;  
import org.slf4j.MDC;  
import org.springframework.core.annotation.AnnotationUtils;  
  
import java.lang.reflect.Method;  
import java.util.Arrays;  
import java.util.UUID;  
import java.util.function.Function;  
  
@Slf4j  
@Aspect  
public class LogAspect {  
  
    private static ObjectMapper objectMapper = new ObjectMapper();  
  
    public static final String REQUEST_TRACE_ID = "REQUEST_TRACE_ID";  
  
  
    /**  
     * @LogTag 注解拦截器  
     * 在方法执行前后记录日志，并在出现异常时抛出RuntimeException。  
     * @param proceedingJoinPoint 切入点对象，提供了对目标方法的控制权。  
     * @return 目标方法的执行结果。  
     */  
    @Pointcut("execution(* com.yourpackage..*(..))")  
    public Object logExecution(ProceedingJoinPoint proceedingJoinPoint)  {  
        return logExecutionInner(proceedingJoinPoint,e -> {  
            throw new RuntimeException(e);  
        });  
    }  
  
    /**  
     * 记录方法执行日志和处理异常。  
     * @param proceedingJoinPoint 切入点对象，用于获取方法信息和执行方法。  
     * @param exceptionHandler 异常处理函数，当方法执行过程中出现异常时交由异常处理函数处理  
     * @return 方法执行的结果。  
     */  
    private Object logExecutionInner(ProceedingJoinPoint proceedingJoinPoint, Function<Throwable,Object> exceptionHandler) {  
        long start = System.currentTimeMillis();  
        String traceId = null;  
        String currentTrace = MDC.get(REQUEST_TRACE_ID);  
        if(currentTrace == null || currentTrace.isEmpty()){  
            traceId = UUID.randomUUID().toString().replaceAll("-", "");  
        }else {  
            traceId = currentTrace;  
        }  
        MDC.put(REQUEST_TRACE_ID, traceId);  
        // 获取方法声明  
        MethodSignature signature = (MethodSignature) proceedingJoinPoint.getSignature();  
        Method method = signature.getMethod();  
  
        String s = proceedingJoinPoint.getSignature().toString();  
        log.info("START PROCESSING: {}",s);  
        // 方法入参  
        Object[] args = proceedingJoinPoint.getArgs();  
        try {  
            log.info("method[{}] request:{}",method.getName(), objectMapper.writeValueAsString(args));  
            // 执行方法  
            Object result = proceedingJoinPoint.proceed();  
            Class returnType = signature.getReturnType();  
            if(returnType == Response.class || returnType.getGenericSuperclass() == Response.class){  
                ((Response<?>) result).setRequestId(traceId);  
            }  
            log.info("method[{}] response:{}",method.getName(),objectMapper.writeValueAsString(result));  
            return result;  
        } catch (Throwable e){  
            log.info("method[{}] 执行异常",method.getName(),e);  
            return exceptionHandler.apply(e);  
        }finally {  
            // 方法执行时间  
            long executionTime = System.currentTimeMillis() - start;  
            log.info("END PROCESSING,cost:{} ms",executionTime);  
            MDC.remove(REQUEST_TRACE_ID);  
        }  
    }  
}

通过上述代码，你就能够实现切入点的方法的日志自动化打印、traceId自动打印、requestId自动填充的功能了。但还不够通用，如果你想将上述功能封装为一个包，提供给别人使用，该如何去做呢？请看下文。

使用自动装配以及注解进行扩展

1. 取消LogAspect类上的@Component注解，通过配置类进行创建bean对象。

import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;  
import org.springframework.context.annotation.Bean;  
import org.springframework.context.annotation.Configuration;  
import org.springframework.context.annotation.EnableAspectJAutoProxy;  
  
@Configuration  
@EnableAspectJAutoProxy  
public class LogAutoConfiguration {  
  
    @Bean  
    @ConditionalOnMissingBean(LogAspect.class)  
    public LogAspect catchLogAspect() {  
        return new LogAspect();  
    }  
}

2. 创建注解

import java.lang.annotation.ElementType;  
import java.lang.annotation.Retention;  
import java.lang.annotation.RetentionPolicy;  
import java.lang.annotation.Target;  
  
/**  
 * 日志注解，用于打印日志出入参等功能  
 */  
@Target({ElementType.METHOD,ElementType.TYPE})  
@Retention(RetentionPolicy.RUNTIME)  
public @interface LogTag {  
  
    /**  
     * 日志前缀  
     * @return  
     */    
     String prefix() default "";  
  
    /**  
     * 是否将出入参对象JSON化打印  
     * @return true 表示转化为JSON，false 表示打印原始入参。  
     */  
    boolean printToJson() default true;  
}

3.修改Aop切面代码，改为拦截注解

import com.fasterxml.jackson.databind.ObjectMapper;  
import com.gis.components.dto.Response;  
import com.gis.components.dto.StatusCode;  
import com.gis.components.exception.BizException;  
import com.gis.components.exception.SysException;  
import lombok.extern.slf4j.Slf4j;  
import org.aspectj.lang.ProceedingJoinPoint;  
import org.aspectj.lang.annotation.Around;  
import org.aspectj.lang.annotation.Aspect;  
import org.aspectj.lang.annotation.Pointcut;  
import org.aspectj.lang.reflect.MethodSignature;  
import org.slf4j.MDC;  
import org.springframework.core.annotation.AnnotationUtils;  
  
import java.lang.reflect.Method;  
import java.util.Arrays;  
import java.util.UUID;  
import java.util.function.Function;  
  
@Slf4j  
@Aspect  
@Component
public class LogAspect {  
  
    private static ObjectMapper objectMapper = new ObjectMapper();  
  
    public static final String REQUEST_TRACE_ID = "REQUEST_TRACE_ID";  
  
	@Pointcut("@annotation(LogTag) || @within(LogTag)")
    public void logPointcut() {  
    }  
      
    /**  
     * @LogTag 注解拦截器  
     * 在方法执行前后记录日志，并在出现异常时抛出RuntimeException。  
     * @param proceedingJoinPoint 切入点对象，提供了对目标方法的控制权。  
     * @return 目标方法的执行结果。  
     */  
    @Around("logPointcut()")  
    public Object logExecution(ProceedingJoinPoint proceedingJoinPoint)  {  
        return logExecutionInner(proceedingJoinPoint,e -> {  
            throw new RuntimeException(e);  
        });  
    }  
  
    /**  
     * 记录方法执行日志和处理异常。  
     * @param proceedingJoinPoint 切入点对象，用于获取方法信息和执行方法。  
     * @param exceptionHandler 异常处理函数，当方法执行过程中出现异常时交由异常处理函数处理  
     * @return 方法执行的结果。  
     */  
    private Object logExecutionInner(ProceedingJoinPoint proceedingJoinPoint, Function<Throwable,Object> exceptionHandler) {  
        long start = System.currentTimeMillis();  
        String traceId = null;  
        String currentTrace = MDC.get(REQUEST_TRACE_ID);  
        if(currentTrace == null || currentTrace.isEmpty()){  
            traceId = UUID.randomUUID().toString().replaceAll("-", "");  
        }else {  
            traceId = currentTrace;  
        }  
        MDC.put(REQUEST_TRACE_ID, traceId);  
        // 获取方法声明  
        MethodSignature signature = (MethodSignature) proceedingJoinPoint.getSignature();  
        Method method = signature.getMethod();  
        // 获取注解  
        LogTag logTag = AnnotationUtils.findAnnotation(method, LogTag.class);  
        if (logTag == null) {  
            logTag = AnnotationUtils.findAnnotation(signature.getDeclaringType(), LogTag.class);  
        }  
        String LOG_PRE = logTag.prefix();  
        String s = proceedingJoinPoint.getSignature().toString();  
        log.info("{} START PROCESSING: {}", LOG_PRE,s);  
        // 方法入参  
        Object[] args = proceedingJoinPoint.getArgs();  
        try {  
            log.info("{} method[{}] request:{}",LOG_PRE,method.getName(), logTag.printToJson() ? objectMapper.writeValueAsString(args) : Arrays.toString(args));  
            // 执行方法  
            Object result = proceedingJoinPoint.proceed();  
            Class returnType = signature.getReturnType();  
            if(returnType == Response.class || returnType.getGenericSuperclass() == Response.class){  
                ((Response<?>) result).setRequestId(traceId);  
            }  
            log.info("{} method[{}] response:{}",LOG_PRE,method.getName(),logTag.printToJson() ? objectMapper.writeValueAsString(result) : result);  
            return result;  
        } catch (Throwable e){  
            log.info("{} method[{}] 执行异常",LOG_PRE,method.getName(),e);  
            return exceptionHandler.apply(e);  
        }finally {  
            // 方法执行时间  
            long executionTime = System.currentTimeMillis() - start;  
            log.info("{} END PROCESSING,cost:{} ms", LOG_PRE,executionTime);  
            MDC.remove(REQUEST_TRACE_ID);  
        }  
    }  
}

4. 配置自动装载

在resource目录下，新建META-INF文件夹，文件夹中新建文件spring.factories，文件内容为：

org.springframework.boot.autoconfigure.EnableAutoConfiguration =com.xxx.log.LogAutoConfiguration

效果展示

到此这篇关于基于Spring AOP实现日志自动打印功能的文章就介绍到这了,更多相关Spring AOP日志自动打印内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！