简介

一次偶然的机会，在做一个系统的时候需要记录用户操作日志，以下分享下。

步骤

1、依赖

需要引入相应依赖，这里肯定时能和数据库关联了（简单的来说就是能够在浏览器上进行增删改查）。

  1. <!-- aop的依赖 -->
  2. <dependency>
  3.     <groupId>org.springframework.boot</groupId>
  4.     <artifactId>spring-boot-starter-aop</artifactId>
  5. </dependency>

2、自定义日志注解

定义一个方法级别的@Log注解，用于标注需要监控的方法：

  1. import java.lang.annotation.ElementType;
  2. import java.lang.annotation.Retention;
  3. import java.lang.annotation.RetentionPolicy;
  4. import java.lang.annotation.Target;
  6. /**
  7.  * 定义一个Log的日志注解，用在方法上
  8.  */
  9. @Target(ElementType.METHOD)
  10. @Retention(RetentionPolicy.RUNTIME)
  11. public @interface Log {
  12.     String value() default "";
  13. }

3、创建库表和实体

在数据库中创建一张sys_operation_log表，用于保存用户的操作日志

a. 数据库

  2. SET FOREIGN_KEY_CHECKS=0;
  4. -- ----------------------------
  5. -- Table structure for sys_operation_log
  6. -- ----------------------------
  7. DROP TABLE IF EXISTS `sys_operation_log`;
  8. CREATE TABLE `sys_operation_log` (
  9.   `ID` int(11) NOT NULL AUTO_INCREMENT COMMENT '用户操作日志主键',
  10.   `LOG_NAME` varchar(255) DEFAULT NULL COMMENT '日志名称',
  11.   `USER_ID` varchar(30) DEFAULT NULL COMMENT '用户id',
  12.   `API` varchar(255) DEFAULT NULL COMMENT 'api名称',
  13.   `METHOD` varchar(255) DEFAULT NULL COMMENT '方法名称',
  14.   `CREATE_TIME` datetime DEFAULT NULL COMMENT '创建时间',
  15.   `SUCCEED` tinyint(4) DEFAULT NULL COMMENT '是否执行成功(0失败1成功)',
  16.   `MESSAGE` varchar(255) DEFAULT NULL COMMENT '具体消息备注',
  17.   PRIMARY KEY (`ID`) USING BTREE
  18. ) ENGINE=InnoDB AUTO_INCREMENT=20 DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT COMMENT='操作日志';
  20. -- ----------------------------
  21. -- Records of sys_operation_log
  22. -- ----------------------------
  23. INSERT INTO `sys_operation_log` VALUES ('17', '业务操作日志', 'tom', '/resource/menus', 'GET', '2018-04-22 16:05:05', '1', null);
  24. INSERT INTO `sys_operation_log` VALUES ('18', '业务操作日志', 'tom', '/resource/menus', 'GET', '2018-04-22 16:05:09', '1', null);
  25. INSERT INTO `sys_operation_log` VALUES ('19', '业务操作日志', 'tom', '/resource/api/-1/1/10', 'GET', '2018-04-22 16:08:15', '1', null);

b. 实体类

  1. import com.fasterxml.jackson.annotation.JsonFormat;
  2. import lombok.Data;
  4. import java.io.Serializable;
  5. import java.util.Date;
  7. /**
  8.  * 用户操作日志主键
  9.  * Create by ck on 2019/6/17
  10.  */
  12. @Data
  13. public class sysOperationLog implements Serializable {
  15.     private static final long serialVersionUID = 8147899229715719433L;
  16.     /**
  17.      * 主键
  18.      */
  19.     private Integer id;
  21.     /**
  22.      * 日志名称
  23.      */
  24.     private String logName;
  26.     /**
  27.      * 用户id
  28.      */
  29.     private String userId;
  31.     /**
  32.      * api名称
  33.      */
  34.     private String api;
  36.     /**
  37.      * 方法名称
  38.      */
  39.     private String method;
  41.     /**
  42.      * 是否执行成功 0失败 -- 1成功
  43.      */
  44.     private Byte succeed;
  46.     /**
  47.      * 详细备注
  48.      */
  49.     private String message;
  51.     /**
  52.      * 创建时间
  53.      */
  54.     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
  55.     private Date createTime;
  57. }

4、切面和切点

定义一个LogAspect类，使用@Aspect标注让其成为一个切面，切点为使用@Log注解标注的方法，使用@Around环绕通知：

  2. import com.ck.syscheck.annotate.Log;
  3. import com.ck.syscheck.model.SysOperationLog;
  4. import com.ck.syscheck.service.SysOperationService;
  5. import org.aspectj.lang.ProceedingJoinPoint;
  6. import org.aspectj.lang.annotation.Around;
  7. import org.aspectj.lang.annotation.Aspect;
  8. import org.aspectj.lang.annotation.Pointcut;
  9. import org.aspectj.lang.reflect.MethodSignature;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
  12. import org.springframework.stereotype.Component;
  14. import java.lang.reflect.Method;
  15. import java.util.Date;
  17. @Aspect
  18. @Component
  19. public class LogAspect {
  21.     @Autowired
  22.     private SysOperationService sysOperationService;
  24.     @Pointcut("@annotation(com.ck.syscheck.annotate.Log)")
  25.     public void pointcut() { }
  27.     @Around("pointcut()")
  28.     public Object around(ProceedingJoinPoint point) {
  29.         Object result = null;
  30.         long beginTime = System.currentTimeMillis();
  31.         try {
  32.             // 执行方法
  33.             result = point.proceed();
  34.         } catch (Throwable e) {
  35.             e.printStackTrace();
  36.         }
  37.         // 执行时长(毫秒)
  38.         long time = System.currentTimeMillis() - beginTime;
  39.         // 保存日志
  40.         saveLog(point, time);
  41.         return result;
  42.     }
  44.     private void saveLog(ProceedingJoinPoint joinPoint, long time) {
  45.         MethodSignature signature = (MethodSignature) joinPoint.getSignature();
  46.         Method method = signature.getMethod();
  47.         SysOperationLog sysOperationLog = new SysOperationLog();
  48.         Log logAnnotation = method.getAnnotation(Log.class);
  49.         if (logAnnotation != null) {
  50.             // 注解上的描述
  51.             sysOperationLog.setApi(logAnnotation.value());
  52.         }
  53.         // 请求的方法名
  54.         String className = joinPoint.getTarget().getClass().getName();
  55.         String methodName = signature.getName();
  56.         sysOperationLog.setMethod(className + "." + methodName + "()");
  57.         // 请求的方法参数值
  58.         Object[] args = joinPoint.getArgs();
  59.         // 请求的方法参数名称
  60.         LocalVariableTableParameterNameDiscoverer u = new LocalVariableTableParameterNameDiscoverer();
  61.         String[] paramNames = u.getParameterNames(method);
  62.         if (args != null && paramNames != null) {
  63.             String params = "";
  64.             for (int i = 0; i < args.length; i++) {
  65.                 params += "  " + paramNames[i] + ": " + args[i];
  66.             }
  67.             sysOperationLog.setMessage(params);
  68.         }
  69.         // 模拟一个用户名
  70.         sysOperationLog.setUserId("admin");
  71.         sysOperationLog.setCreateTime(new Date());
  72.         // 保存系统日志
  73.         sysOperationService.insert(sysOperationLog);
  74.     }
  75. }

5、测试

  1. import com.ck.syscheck.annotate.Log;
  2. import org.springframework.web.servlet.ModelAndView;
  5. @RestController
  6. @RequestMapping("/api")
  7. public class SysUserController {    
  8.     /**
  9.      * @return 测试
  10.      */
  11.     @Log("测试test")
  12.     @RequestMapping("/test")
  13.     public ModelAndView test(ModelAndView modelAndView) {
  14.         modelAndView.setViewName("/front/test");
  15.         return modelAndView;
  16.     }
  17.     @Log("添加add")
  18.     @RequestMapping("/add")
  19.     public ModelAndView add(ModelAndView modelAndView) {
  20.         modelAndView.setViewName("/front/add");
  21.         return modelAndView;
  22.     }
  24.     @Log("更新Update")
  25.     @RequestMapping("/update")
  26.     public ModelAndView update(ModelAndView modelAndView) {
  28.         modelAndView.setViewName("/front/update");
  29.         return modelAndView;
  30.     }
  31. }

可以存到数据库
image.png

这里面是以部分字段作为参考栗子，具体的还需要看项目需求。demo源码所在位置：
GitHub：https://github.com/Tidetrace/sys-check