SpringBoot工具库:切面记录接口日志

￡神魔★判官ぃ 2023-10-07 12:36 9阅读 0赞

**目录**

简介

一、新增要使用的依赖

二、定义日志记录切面类

logging.config=classpath:log4j2_dev.xml

--------------------

## 简介 ##

*  log4j是apache实现的一个开源日志组件
 *  logback同样是由log4j的作者设计完成的，拥有更好的特性，用来取代log4j的一个日志框架，是slf4j的原生实现
 *  Log4j2是log4j 1.x和logback的改进版，据说采用了一些新技术（无锁异步、等等），使得日志的吞吐量、性能比log4j 1.x提高10倍，并解决了一些死锁的bug，而且配置更加简单灵活
 *  **slf4j**是对所有日志框架制定的一种规范、标准、接口，并不是一个框架的具体的实现，因为接口并不能独立使用，需要和具体的日志框架实现配合使用（如log4j、logback），**使用接口的好处是当项目需要更换日志框架的时候，只需要更换jar和配置，不需要更改相关java代码**

## 一、项目配置 ##

springboot项目，直接引入`spring-boot-starter-web`依赖即可，因为`spring-boot-starter-web`包含了`spring-boot-starter`。而`spring-boot-starter`包含了`spring-boot-starter-logging`，所以我们只需要引入 web 组件即可

**1）引入依赖**

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

**本项目以logback演示**

**2）添加配置**

application.properties中添加配置

logging.config=classpath:logback-spring.xml

或者 yml中设置配置文件路径

# 日志配置
    logging:
      # 指定配置文件的路径
      config: logback-spring.xml
      level:
        # root表示整个项目，默认级别为info
        root: info

log4j2默认会在classpath目录下寻找log4j2.xml、log4j.json、log4j.jsn等名称的文件，如果都没有找到，则会按默认配置输出，也就是输出到控制台，也可以对配置文件自定义位置

**3）xml配置文件**

在resources下新建logback-spring.xml配置文件，详细内容参考[logback-spring.xml][]

## 二、定义日志记录切面类 ##

**@Pointcut**定义切入点，此处是com.example.controller包下的所有Controller（对controller层所有请求处理做切入点），然后通过@Before实现对请求内容的日志记录，最后通过@AfterReturning记录请求返回的对象。

**实现AOP的切面主要有以下几个要素：**

使用@Aspect注解将一个java类定义为切面类  
使用@Pointcut定义一个切入点，可以是一个规则表达式，比如下例中某个package下的所有函数，也可以是一个注解等。  
根据需要在切入点不同位置的切入内容  
使用@Before在切入点开始处切入内容  
使用@After在切入点结尾处切入内容  
使用@AfterReturning在切入点return内容之后切入内容（可以用来对处理返回值做一些加工处理）  
使用@Around在切入点前后切入内容，并自己控制何时执行切入点自身的内容  
使用@AfterThrowing用来处理当切入内容部分抛出异常之后的处理逻辑

import java.util.Arrays;
    import javax.servlet.http.HttpServletRequest;
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.AfterThrowing;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.context.annotation.Configuration;
    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 com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.serializer.SerializerFeature;
    import com.ykx.transfer.consts.TransferConstants;
    import lombok.extern.slf4j.Slf4j;
    	
    	/**
    	 * 
    	 * 类名称：LogRecordAspect   
    	 * 类描述：   
    	 * 创建人：Administrator
    	 * 创建时间：2019年11月22日 下午12:04:10   
    	 * 修改人：Administrator
    	 * 修改时间：2019年11月22日 下午12:04:10   
    	 * 修改备注：   
    	 * @version
    	 */
    	@Aspect
    	@Slf4j
    	@Configuration
    	@Component
    	public class LogRecordAspect {
    	    
    		
    		 ThreadLocal<Long> startTime = new ThreadLocal<Long>();
    		/**
    		     * 定义一个切入点.
    		  * 	("execution(public * com.group.*.web..*.*(..))")
    		     * 解释下：
    		     * 第一个 * 代表任意修饰符及任意返回值.
    		     * 第二个 * 任意包名
    		     * 第三个 * 代表任意方法.
    		     * 第四个 * 定义在web包或者子包
    		     * 第五个 * 任意方法
    		  * .. 	匹配任意数量的参数.
    	     */
    		@Pointcut("execution(* com.ykx.transfer.contorller.*Controller.*(..)) or execution(* com.ykx.transfer.service.*Service.*(..))")
    	    public void executeService() {
    	    }
    	
    	    @Around("executeService()")
    	    public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
    	        RequestAttributes ra = RequestContextHolder.getRequestAttributes();
    	        ServletRequestAttributes sra = (ServletRequestAttributes) ra;
    	        HttpServletRequest request = sra.getRequest();
    	        String url = request.getRequestURL().toString();
    	        String uri = request.getRequestURI();
    	        String method = request.getMethod();
    	        String methodName = pjp.getSignature().getName();
    			Object[] args = pjp.getArgs();
    			String IP=request.getRemoteAddr();
    	//      String queryString = request.getQueryString();
    	        if (!TransferConstants.CHECK_URL.equals(request.getRequestURI())) {
    	            log.info("【环绕通知】请求参数：url: {}, uri: {},IP:{},method: {},methodName: {}, params: {}", url,uri,IP, method,methodName,Arrays.toString(args));
    	        }
    	        Object result = pjp.proceed(); //调用目标方法
    	        String resultString = JSON.toJSONString(result, SerializerFeature.DisableCircularReferenceDetect, SerializerFeature.WriteMapNullValue);
    	        if (!TransferConstants.CHECK_URL.equals(request.getRequestURI())) {
    	            log.info("【环绕通知】 返回值	:{}", resultString);
    	        }
    	        return result;
    	    }
    	
    	     
    	     @AfterThrowing(pointcut = "executeService()",throwing = "throwable")
    	     public void afterThrowing(JoinPoint joinPoint, Throwable throwable) {
    	         String methodName = joinPoint.getSignature().getName();
    	         log.info("【异常通知】"+"Method Name : [" + methodName + "] ---> AOP after throwing ,and throwable message is : " + throwable.getMessage());
    	     }
    	
    		
    	}

Spring Boot对AOP的默认配置属性是开启的，也就是说spring.aop.auto属性的值默认是true；同时我们只要引入了AOP依赖后，默认就已经增加了@EnableAspectJAutoProxy功能，不需要我们在程序启动类上面加入注解@EnableAspectJAutoProxy，也不需要在yml中配置spring.aop.proxy-target-class，不过这个默认值是false即使用的是JDK动态代理，当我们需要使用CGLIB来实现AOP的时候，需要配置spring.aop.proxy-target-class=true。

项目使用时，只需要把@Pointcut切点对应的包路径替换掉即可

## 保存到数据库 ##

如果项目需要保存到数据库，则数据库表创建：

/*==============================================================*/
    /* Table: sys_log  系统日志表                              */
    /*==============================================================*/
    CREATE TABLE public.sys_log (
        id SERIAL NOT NULL PRIMARY KEY,
        user_id VARCHAR ( 50 ) NULL,
        user_name VARCHAR ( 50 ) NULL,
        operation VARCHAR ( 100 ) NULL,
        response_time INT4 NULL,
        method VARCHAR ( 200 ) NULL,
        params TEXT  NULL,
        ip VARCHAR ( 50 ) NULL,
        gmt_create TIMESTAMP NULL 
    );
    COMMENT ON TABLE public.sys_log IS '系统日志';
    COMMENT ON COLUMN public.sys_log.id IS '主键id';
    COMMENT ON COLUMN public.sys_log.user_id IS '用户id';
    COMMENT ON COLUMN public.sys_log.user_name IS '用户名称';
    COMMENT ON COLUMN public.sys_log.operation IS '用户操作';
    COMMENT ON COLUMN public.sys_log.response_time IS '响应时间';
    COMMENT ON COLUMN public.sys_log.method IS '请求方法';
    COMMENT ON COLUMN public.sys_log.params IS '请求参数';
    COMMENT ON COLUMN public.sys_log.ip IS 'IP地址';
    COMMENT ON COLUMN public.sys_log.gmt_create IS '创建时间';

注解接口定义：

/**
     * 系统日志注解
     * @author xx
     * @Date 2021-4-14 18:01:05
     */
    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface SysLogService {
    
        String value() default "";
    
    }

**参数解释：**

@Target 定义该注解可以用于何处，包含：ElementType.PARAMETER;ElementType.METHOD;ElementType.TYPE等；  
@Retention 是定义被它所注解的注解保留多久；有SOURCE(保留在源文件)；CLASS(保留到class文件);RUNTIME(JVM加载后仍存在)三种；  
@Documented 注解只是用来做标识，没什么实际作用

具体实现：

/**
     * 系统日志，切面处理类
     * @author xx
     * @Date 2021-4-14 19:30:02
     */
    @Aspect
    @Component
    @Slf4j
    public class SysLogAspect {
    
        @Autowired
        private SysLogMapper sysLogMapper;
        @Autowired
        SysUserApplicationService sysUserApplicationService;
    
        @Pointcut("@annotation(com.yoi.core.domain.repository.SysLogService)")
        public void logPointCut() {
        }
    
        @Around("logPointCut()")
        public Object around(ProceedingJoinPoint point) throws Throwable {
            long beginTime = System.currentTimeMillis();
            //执行方法
            Object result = point.proceed();
            //执行时长(毫秒)
            long time = System.currentTimeMillis() - beginTime;
            //保存日志
            saveSysLog(point, time);
            return result;
        }
    
        private void saveSysLog(ProceedingJoinPoint joinPoint, long time) {
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            Method method = signature.getMethod();
            SysLog sysLog = new SysLog();
            SysLogService syslog = method.getAnnotation(SysLogService.class);
            if(syslog != null){
                //注解上的描述
                sysLog.setOperation(syslog.value());
            }
            //请求的方法名
            String className = joinPoint.getTarget().getClass().getName();
            String methodName = signature.getName();
            sysLog.setMethod(className + "." + methodName + "()");
            //请求的参数
            Object[] args = joinPoint.getArgs();
            try{
                String params = JSONUtils.beanToJson(args[0]);
                sysLog.setParams(params);
            }catch (Exception e){
    
            }
            //设置IP地址
            sysLog.setIp(WebUtils.getIpAddr());
            //用户名
            String userId = WebUtils.getUserId();
            sysLog.setUserId(userId);
            if(ObjectUtils.isNotEmpty(userId)){
                SysUserDto sysUserDto = sysUserApplicationService.getUserByUserId(userId);
                sysLog.setUserName(sysUserDto.getUserName());
            }
            sysLog.setResponseTime(time);
            sysLog.setGmtCreate(DateUtils.getCurrentDate());
            if(ObjectUtils.isNotEmpty(syslog.value())){
                //保存系统日志
                int num = sysLogMapper.insert(sysLog);
                if(num>0){
                    log.info("save log{} success!",sysLog.toString());
                }else{
                    log.info("save log{} faild!",sysLog.toString());
                }
            }else{
                log.debug(className + "." + methodName + "() :request log{}!",sysLog.toString());
            }
        }
    
    }

接口定义的注解使用：

@ApiOperation(value = "保存测试接口", notes = "保存测试接口")
        @SysLogService("保存测试接口")
        @PostMapping("/test")
        public boolean test(@ApiParam(value = "传入json格式", required = true) @RequestBody Test test) {
            return faultApplicationService.save(test);
        }

[https://blog.csdn.net/qq\_39853669/article/details/124640353][https_blog.csdn.net_qq_39853669_article_details_124640353]

[logback-spring.xml]: https://blog.csdn.net/qq_20957669/article/details/105515045
[https_blog.csdn.net_qq_39853669_article_details_124640353]: https://blog.csdn.net/qq_39853669/article/details/124640353