SpringBoot自定义注解+AOP实现系统操作日志

avatar 2019年08月19日23:52:22 8 14496 views
博主分享免费Java教学视频，B站账号：Java刘哥
在之前我们记录一些后台操作日志都是通过 logService.insert(log) 的方式，每次都要获取一堆信息，代码比较冗余和侵入性太强。我们想能不能通过一个东西抽取公共的代码，通过注解设置简单的日志描述即可自动完成一系列信息获取和日志的持久化操作。下面将介绍基于Spring 面向切面的思想和自定义注解来解决。 最终我们只需要如下图一个注解就能实现日志的记录   数据库   下面是具体实现 完整代码地址：https://github.com/saysky/sensboot

一、注解和面向切面的基本实现

1.注解类 SystemLog
  1. package com.liuyanzhao.sens.annotation;
  4. import com.liuyanzhao.sens.enums.LogType;
  6. import java.lang.annotation.*;
  8. /**
  9.  * 系统日志自定义注解
  10.  *
  11.  * @author liuyanzhao
  12.  */
  13. @Target({ElementType.PARAMETER, ElementType.METHOD})//作用于参数或方法上
  14. @Retention(RetentionPolicy.RUNTIME)
  15. @Documented
  16. public @interface SystemLog {
  18.     /**
  19.      * 日志名称
  20.      *
  21.      * @return
  22.      */
  23.     String description() default "";
  25.     /**
  26.      * 日志类型
  27.      *
  28.      * @return
  29.      */
  30.     LogType type() default LogType.OPERATION;
  31. }
  2.枚举类 LogType
  1. package com.liuyanzhao.sens.enums;
  3. /**
  4.  * @author liuyanzhao
  5.  */
  6. public enum LogType {
  8.     /**
  9.      * 默认0操作
  10.      */
  11.     OPERATION,
  13.     /**
  14.      * 1登录
  15.      */
  16.     LOGIN
  17. }
  3.切面类 SystemLogAspect
  1. package com.liuyanzhao.sens.aop;
  3. import com.liuyanzhao.sens.annotation.SystemLog;
  4. import com.liuyanzhao.sens.entity.Log;
  5. import com.liuyanzhao.sens.entity.User;
  6. import com.liuyanzhao.sens.enums.LogType;
  7. import com.liuyanzhao.sens.service.LogService;
  8. import com.liuyanzhao.sens.service.UserService;
  9. import com.liuyanzhao.sens.utils.IpInfoUtil;
  10. import com.liuyanzhao.sens.utils.ObjectUtil;
  11. import com.liuyanzhao.sens.utils.ThreadPoolUtil;
  12. import lombok.extern.slf4j.Slf4j;
  13. import org.aspectj.lang.JoinPoint;
  14. import org.aspectj.lang.annotation.AfterReturning;
  15. import org.aspectj.lang.annotation.Aspect;
  16. import org.aspectj.lang.annotation.Before;
  17. import org.aspectj.lang.annotation.Pointcut;
  18. import org.checkerframework.checker.units.qual.A;
  19. import org.springframework.beans.factory.annotation.Autowired;
  20. import org.springframework.core.NamedThreadLocal;
  21. import org.springframework.stereotype.Component;
  23. import javax.servlet.http.HttpServletRequest;
  24. import java.lang.reflect.Method;
  25. import java.util.Date;
  26. import java.util.HashMap;
  27. import java.util.Map;
  28. import java.util.Objects;
  30. /**
  31.  * Spring AOP实现日志管理
  32.  *
  33.  * @author liuyanzhao
  34.  */
  35. @Aspect
  36. @Component
  37. @Slf4j
  38. public class SystemLogAspect {
  40.     private static final ThreadLocal<Date> beginTimeThreadLocal = new NamedThreadLocal<Date>("ThreadLocal beginTime");
  43.     @Autowired
  44.     private LogService logService;
  46.     @Autowired
  47.     private UserService userService;
  49.     @Autowired
  50.     private IpInfoUtil ipInfoUtil;
  52.     @Autowired(required = false)
  53.     private HttpServletRequest request;
  55.     /**
  56.      * Controller层切点,注解方式
  57.      */
  58.     //@Pointcut("execution(* *..controller..*Controller*.*(..))")
  59.     @Pointcut("@annotation(com.liuyanzhao.sens.annotation.SystemLog)")
  60.     public void controllerAspect() {
  62.     }
  64.     /**
  65.      * 前置通知 (在方法执行之前返回)用于拦截Controller层记录用户的操作的开始时间
  66.      *
  67.      * @param joinPoint 切点
  68.      * @throws InterruptedException
  69.      */
  70.     @Before("controllerAspect()")
  71.     public void doBefore(JoinPoint joinPoint) throws InterruptedException {
  73.         //线程绑定变量（该数据只有当前请求的线程可见）
  74.         Date beginTime = new Date();
  75.         beginTimeThreadLocal.set(beginTime);
  76.     }
  79.     /**
  80.      * 后置通知(在方法执行之后并返回数据) 用于拦截Controller层无异常的操作
  81.      *
  82.      * @param joinPoint 切点
  83.      */
  84.     @AfterReturning("controllerAspect()")
  85.     public void after(JoinPoint joinPoint) {
  86.         try {
  87.             String username = "";
  88.             String description = getControllerMethodInfo(joinPoint).get("description").toString();
  89.             Map<String, String[]> requestParams = request.getParameterMap();
  91.             Log log = new Log();
  93.             //请求用户
  94.             //后台操作(非登录)
  95.             if (Objects.equals(getControllerMethodInfo(joinPoint).get("type"), 0)) {
  96.                 //后台操作请求(已登录)
  97.                 User user = userService.getLoginUser(request);
  98.                 if (user != null) {
  99.                     username = user.getUsername();
  100.                 }
  101.                 log.setUsername(username);
  102.             }
  103.             //日志标题
  104.             log.setName(description);
  105.             //日志类型
  106.             log.setLogType((int) getControllerMethodInfo(joinPoint).get("type"));
  107.             //日志请求url
  108.             log.setRequestUrl(request.getRequestURI());
  109.             //请求方式
  110.             log.setRequestType(request.getMethod());
  111.             //请求参数
  112.             log.setRequestParam(ObjectUtil.mapToString(requestParams));
  114.             //其他属性
  115.             log.setIp(ipInfoUtil.getIpAddr(request));
  116.             log.setCreateBy("system");
  117.             log.setUpdateBy("system");
  118.             log.setCreateTime(new Date());
  119.             log.setUpdateTime(new Date());
  120.             log.setDelFlag(0);
  122.             //.......
  123.             //请求开始时间
  124.             long beginTime = beginTimeThreadLocal.get().getTime();
  125.             long endTime = System.currentTimeMillis();
  126.             //请求耗时
  127.             Long logElapsedTime = endTime - beginTime;
  128.             log.setCostTime(logElapsedTime.intValue());
  130.             //持久化(存储到数据或者ES，可以考虑用线程池)
  131.             //logService.insert(log);
  132.             ThreadPoolUtil.getPool().execute(new SaveSystemLogThread(log, logService));
  134.         } catch (Exception e) {
  135.             log.error("AOP后置通知异常", e);
  136.         }
  137.     }
  140.     /**
  141.      * 保存日志至数据库
  142.      */
  143.     private static class SaveSystemLogThread implements Runnable {
  145.         private Log log;
  146.         private LogService logService;
  148.         public SaveSystemLogThread(Log esLog, LogService logService) {
  149.             this.log = esLog;
  150.             this.logService = logService;
  151.         }
  153.         @Override
  154.         public void run() {
  155.             logService.insert(log);
  156.         }
  157.     }
  159.     /**
  160.      * 获取注解中对方法的描述信息 用于Controller层注解
  161.      *
  162.      * @param joinPoint 切点
  163.      * @return 方法描述
  164.      * @throws Exception
  165.      */
  166.     public static Map<String, Object> getControllerMethodInfo(JoinPoint joinPoint) throws Exception {
  168.         Map<String, Object> map = new HashMap<String, Object>(16);
  169.         //获取目标类名
  170.         String targetName = joinPoint.getTarget().getClass().getName();
  171.         //获取方法名
  172.         String methodName = joinPoint.getSignature().getName();
  173.         //获取相关参数
  174.         Object[] arguments = joinPoint.getArgs();
  175.         //生成类对象
  176.         Class targetClass = Class.forName(targetName);
  177.         //获取该类中的方法
  178.         Method[] methods = targetClass.getMethods();
  180.         String description = "";
  181.         Integer type = null;
  183.         for (Method method : methods) {
  184.             if (!method.getName().equals(methodName)) {
  185.                 continue;
  186.             }
  187.             Class[] clazzs = method.getParameterTypes();
  188.             if (clazzs.length != arguments.length) {
  189.                 //比较方法中参数个数与从切点中获取的参数个数是否相同，原因是方法可以重载哦
  190.                 continue;
  191.             }
  192.             description = method.getAnnotation(SystemLog.class).description();
  193.             type = method.getAnnotation(SystemLog.class).type().ordinal();
  194.             map.put("description", description);
  195.             map.put("type", type);
  196.         }
  197.         return map;
  198.     }
  200. }
注释已经很完善了，这里就不多说了，里面有一些工具类和 Log 相关的类后面会补充 至此，仅仅三个类即可实现我们之前的功能    

二、日志的实体、DAO和Service层代码

  1. package com.liuyanzhao.sens.entity;
  3. import com.baomidou.mybatisplus.annotations.TableField;
  4. import com.baomidou.mybatisplus.annotations.TableId;
  5. import com.baomidou.mybatisplus.annotations.TableLogic;
  6. import com.baomidou.mybatisplus.annotations.TableName;
  7. import com.baomidou.mybatisplus.enums.IdType;
  8. import lombok.Data;
  10. import java.io.Serializable;
  11. import java.util.Date;
  14. /**
  15.  * @author liuyanzhao
  16.  */
  17. @Data
  18. @TableName("log")
  19. public class Log  implements Serializable {
  21.     private static final long serialVersionUID = 1L;
  22.     /**
  23.      * ID，自增
  24.      */
  25.     @TableId(type = IdType.AUTO)
  26.     private Long id;
  29.     /**
  30.      * 方法操作名称
  31.      */
  32.     private String name;
  34.     /**
  35.      * 日志类型 0登陆日志 1操作日志
  36.      */
  37.     private Integer logType;
  39.     /**
  40.      * 请求路径
  41.      */
  42.     private String requestUrl;
  44.     /**
  45.      * 请求类型
  46.      */
  47.     private String requestType;
  49.     /**
  50.      * 请求参数
  51.      */
  52.     private String requestParam;
  54.     /**
  55.      * 请求用户
  56.      */
  57.     private String username;
  59.     /**
  60.      * ip
  61.      */
  62.     private String ip;
  64.     /**
  65.      * ip信息
  66.      */
  67.     private String ipInfo;
  69.     /**
  70.      * 花费时间
  71.      */
  72.     private Integer costTime;
  74.     /**
  75.      * 删除状态：1删除，0未删除
  76.      */
  77.     @TableField(value = "del_flag")
  78.     @TableLogic
  79.     private Integer delFlag = 0;
  81.     /**
  82.      * 创建人用户名
  83.      */
  84.     private String createBy;
  86.     /**
  87.      * 创建时间
  88.      */
  89.     private Date createTime;
  91.     /**
  92.      * 更新人
  93.      */
  94.     private String updateBy;
  96.     /**
  97.      * 更新时间
  98.      */
  99.     private Date updateTime;
  101. }
    2.日志DAO层，采用MyBatis-Plus
  1. package com.liuyanzhao.sens.mapper;
  3. import com.baomidou.mybatisplus.mapper.BaseMapper;
  4. import com.liuyanzhao.sens.entity.Log;
  5. import org.apache.ibatis.annotations.Mapper;
  8. /**
  9.  * @author 言曌
  10.  * @date 2019-08-09 15:15
  11.  */
  12. @Mapper
  13. public interface LogMapper extends BaseMapper<Log> {
  15. }
    3.Service实现
  1. package com.liuyanzhao.sens.service.impl;
  3. import com.liuyanzhao.sens.entity.Log;
  4. import com.liuyanzhao.sens.mapper.LogMapper;
  5. import com.liuyanzhao.sens.service.LogService;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Service;
  9. /**
  10.  * @author 言曌
  11.  * @date 2019-08-19 21:51
  12.  */
  13. @Service
  14. public class LogServiceImpl implements LogService {
  16.     @Autowired
  17.     private LogMapper logMapper;
  19.     @Override
  20.     public Integer insert(Log log) {
  21.         return logMapper.insert(log);
  22.     }
  23. }
  关于用户的service实现这里就不贴了，我觉得没有必要哈，完整代码文末会贴 GitHub地址  

三、线程池的使用

阿里巴巴代码规范中说明了，不建议使用 Executors.newFixedThreadPool(num); 这种形式创建线程，最好自己手动设置线程核心数和最大数以及队列大小，我们这里可以抽出个线程池静态工具类。
  1. package com.liuyanzhao.sens.utils;
  3. import java.util.concurrent.ArrayBlockingQueue;
  4. import java.util.concurrent.BlockingQueue;
  5. import java.util.concurrent.ThreadPoolExecutor;
  6. import java.util.concurrent.TimeUnit;
  8. /**
  9.  * @author liuyanzhao
  10.  */
  11. public class ThreadPoolUtil {
  13.     /**
  14.      * 线程缓冲队列
  15.      */
  16.     private static BlockingQueue<Runnable> bqueue = new ArrayBlockingQueue<Runnable>(100);
  17.     /**
  18.      * 核心线程数，会一直存活，即使没有任务，线程池也会维护线程的最少数量
  19.      */
  20.     private static final int SIZE_CORE_POOL = 5;
  21.     /**
  22.      * 线程池维护线程的最大数量
  23.      */
  24.     private static final int SIZE_MAX_POOL = 10;
  25.     /**
  26.      * 线程池维护线程所允许的空闲时间
  27.      */
  28.     private static final long ALIVE_TIME = 2000;
  30.     private static ThreadPoolExecutor pool = new ThreadPoolExecutor(SIZE_CORE_POOL, SIZE_MAX_POOL, ALIVE_TIME, TimeUnit.MILLISECONDS, bqueue, new ThreadPoolExecutor.CallerRunsPolicy());
  32.     static {
  34.         pool.prestartAllCoreThreads();
  35.     }
  37.     public static ThreadPoolExecutor getPool() {
  38.         return pool;
  39.     }
  41.     public static void main(String[] args) {
  42.         System.out.println(pool.getPoolSize());
  43.     }
  44. }
即该线程池随类加载时创建，维护5个线程，这5个线程永远存活，如果同时任务数大于5个，多余的将放在队列中，如果队列数超过队列最大大小2000，将开始创建额外的线程，直到线程数超过最大线程数10，调用 CallerRunsPolicy 拒绝策略。   使用方法如上切面类中
  1. ThreadPoolUtil.getPool().execute(new SaveSystemLogThread(log, logService));
 

四、完整代码地址

完整代码地址：https://github.com/saysky/sensboot 欢迎讨论，该项目主要用于基本框架和工具整合实例  
历史上的今天
八月
19日
  • 微信
  • 交流学习，有偿服务
  • weinxin
  • 博客/Java交流群
  • 资源分享，问题解决，技术交流。群号：590480292
  • weinxin
avatar

发表评论

avatar 登录者：匿名
匿名评论，评论回复后会有邮件通知

  

已通过评论：2   待审核评论数：0
  1. avatar 恒仔
    回复 2020年06月25日 03:00:24

    最后一段，“队列数超过队列最大大小2000”应该是100吧

  2. avatar hooqing
    回复 2019年09月11日 15:43:10

    楼主用的是idea么？模板好漂亮，哪一款给个下载链接呗