基于SpringBoot使用AOP技术实现操作日志管理

墨蓝 2023-05-31 06:55 16阅读 0赞

> 操作日志对于程序员或管理员而言，可以快速定位到系统中相关的操作，而对于操作日志的管理的实现不能对正常业务实现进行影响，否则即不满足单一原则，也会导致后续代码维护困难，因此我们考虑使用AOP切面技术来实现对日志管理的实现。

文章大致内容：  
1、基本概念  
2、基本应用  
3、日志管理实战  
对这几部分理解了，会对AOP的应用应该很轻松。

## 一、基本概念 ##

<table> 
 <thead> 
  <tr> 
   <th>项目</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Aspect（切面）</td> 
   <td>跨越多个类的关注点的模块化，切面是通知和切点的结合。通知和切点共同定义了切面的全部内容——它是什么，在何时和何处完成其功能。事务处理和日志处理可以理解为切面</td> 
  </tr> 
  <tr> 
   <td>Join point（连接点）</td> 
   <td>程序执行过程中的一个点，如方法的执行或异常的处理</td> 
  </tr> 
  <tr> 
   <td>Advice（通知）</td> 
   <td>切面在特定连接点上采取的动作</td> 
  </tr> 
  <tr> 
   <td>Pointcut（切点）</td> 
   <td>匹配连接点的断言。通知与切入点表达式相关联，并在切入点匹配的任何连接点上运行(例如，具有特定名称的方法的执行)。切入点表达式匹配的连接点概念是AOP的核心，Spring默认使用AspectJ切入点表达式语言</td> 
  </tr> 
  <tr> 
   <td>Introduction（引用）</td> 
   <td>为类型声明其他方法或字段。Spring AOP允许您向任何建议的对象引入新的接口(和相应的实现)。例如，您可以使用介绍使bean实现IsModified接口，以简化缓存</td> 
  </tr> 
  <tr> 
   <td>Target object（目标）</td> 
   <td>由一个或多个切面通知的对象。也称为“通知对象”。由于Spring AOP是通过使用运行时代理实现的，所以这个对象始终是代理对象</td> 
  </tr> 
  <tr> 
   <td>AOP proxy（代理）</td> 
   <td>AOP框架为实现切面契约(通知方法执行等)而创建的对象。在Spring框架中，AOP代理是JDK动态代理或CGLIB代理</td> 
  </tr> 
  <tr> 
   <td>Weaving（织入）</td> 
   <td>织入是将通知添加对目标类具体连接点上的过程，可以在编译时(例如使用AspectJ编译器)、加载时或运行时完成</td> 
  </tr> 
 </tbody> 
</table>

Spring切面可以应用5种类型的通知：

*  前置通知（Before）：在目标方法被调用之前调用通知
 *  后置通知（After）：在目标方法完成之后调用通知（无论是正常还是异常退出）
 *  返回通知（After-returning）：在目标方法成功执行之后调用通知
 *  异常通知（After-throwing）：在目标方法抛出异常后调用通知
 *  环绕通知（Around）：通知包裹了被通知的方法，在被通知的方法调用之前和调用之后执行自定义的行为  
    其执行的顺序为：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoeWFud3U2OA_size_16_color_FFFFFF_t_70]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoeWFud3U2OA_size_16_color_FFFFFF_t_70 1]  
    后续的基本应用，会将 **环绕通知**、**前置通知**、**后置通知**、**返回通知**、**异常通知**进行实现，并演示其执行顺序。

## 二、基本应用 ##

声明通知  
大家可以将下面的代码复制出来，验证上面的执行顺序。

@Aspect
    public class Test { 
        private static int step = 0;
    
        @Pointcut("@annotation(com.chenyanwu.erp.erpframework.annotation.Log)") // the pointcut expression
        private void operation() { }
    
        @Before("operation()")
        public void doBeforeTask() { 
            System.out.println(++step + " 前置通知");
        }
    
        @After("operation()")
        public void doAfterTask() { 
            System.out.println(++step + " 后置通知");
        }
    
        @AfterReturning(pointcut = "operation()", returning = "retVal")
        public void doAfterReturnningTask(Object retVal) { 
            System.out.println(++step + " 返回通知，返回值为：" + retVal.toString());
        }
    
        @AfterThrowing(pointcut = "operation()", throwing = "ex")
        public void doAfterThrowingTask(Exception ex) { 
            System.out.println(++step + " 异常通知，异常信息为：" + ex.getMessage());
        }
    
        /** * 环绕通知需要携带ProceedingJoinPoint类型的参数 * 环绕通知类似于动态代理的全过程ProceedingJoinPoint类型的参数可以决定是否执行目标方法 * 且环绕通知必须有返回值，返回值即目标方法的返回值 */
        //@Around("operation()")
        public Object doAroundTask(ProceedingJoinPoint pjp) { 
            String methodname = pjp.getSignature().getName();
            Object result = null;
            try { 
                // 前置通知
                System.out.println("目标方法" + methodname + "开始，参数为" + Arrays.asList(pjp.getArgs()));
                // 执行目标方法
                result = pjp.proceed();
                // 返回通知
                System.out.println("目标方法" + methodname + "执行成功，返回" + result);
            } catch (Throwable e) { 
                // 异常通知
                System.out.println("目标方法" + methodname + "抛出异常: " + e.getMessage());
            }
            // 后置通知
            System.out.println("目标方法" + methodname + "结束");
            return result;
        }
    }

其中需要注意的是切入点：@Pointcut的表达式  
*格式：*

> execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern)throws-pattern?)  
> 括号中各个pattern分别表示：

*  修饰符匹配（modifier-pattern?）
 *  返回值匹配（ret-type-pattern）可以为\*表示任何返回值,全路径的类名等
 *  类路径匹配（declaring-type-pattern?）
 *  方法名匹配（name-pattern）可以指定方法名 或者 *代表所有, set* 代表以set开头的所有方法
 *  参数匹配（(param-pattern)）可以指定具体的参数类型，多个参数间用“,”隔开，各个参数也可以用“*”来表示- 匹配任意类型的参数，如(String)表示匹配一个String参数的方法；(*,String) 表示匹配有两个参数的方法，第一个参数可以是任意类型，而第二个参数是String类型；可以用(…)表示零个或多个任意参数
 *  异常类型匹配（throws-pattern?）
 *  其中后面跟着“?”的是可选项

*示例：*

> 1）execution(\* *(…))  
> //表示匹配所有方法  
> 2）execution(public \* com. savage.service.UserService.*(…))  
> //表示匹配com.savage.server.UserService中所有的公有方法  
> 3）execution(\* com.savage.server…*.*(…))  
> //表示匹配com.savage.server包及其子包下的所有方法

## 三、日志管理实战 ##

有了上面基本应用的理解，现在我们直接就贴代码：  
1、依赖的jar包

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

2、自定义注解

@Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Log { 
        String value() default "";
    }

3、实现切面

@Aspect
    @Order(5)
    @Component
    public class LogAspect { 
    
        private Logger logger = LoggerFactory.getLogger(LogAspect.class);
    
        @Autowired
        private ErpLogService logService;
    
        @Autowired
        ObjectMapper objectMapper;
    
        private ThreadLocal<Date> startTime = new ThreadLocal<Date>();
    
        @Pointcut("@annotation(com.chenyanwu.erp.erpframework.annotation.Log)")
        public void pointcut() { 
    
        }
    
        /** * 前置通知，在Controller层操作前拦截 * * @param joinPoint 切入点 */
        @Before("pointcut()")
        public void doBefore(JoinPoint joinPoint) { 
            // 获取当前调用时间
            startTime.set(new Date());
        }
    
        /** * 正常情况返回 * * @param joinPoint 切入点 * @param rvt 正常结果 */
        @AfterReturning(pointcut = "pointcut()", returning = "rvt")
        public void doAfter(JoinPoint joinPoint, Object rvt) throws Exception { 
            handleLog(joinPoint, null, rvt);
        }
    
        /** * 异常信息拦截 * * @param joinPoint * @param e */
        @AfterThrowing(pointcut = "pointcut()", throwing = "e")
        public void doAfter(JoinPoint joinPoint, Exception e) throws Exception { 
            handleLog(joinPoint, e, null);
        }
    
        @Async
        private void handleLog(final JoinPoint joinPoint, final Exception e, Object rvt) throws Exception{ 
            // 获得注解
            Method method = getMethod(joinPoint);
            Log log = getAnnotationLog(method);
            if (log == null) { 
                return;
            }
            Date now = new Date();
            // 操作数据库日志表
            ErpLog erpLog = new ErpLog();
            erpLog.setErrorCode(0);
            erpLog.setIsDeleted(0);
            // 请求信息
            HttpServletRequest request = ToolUtil.getRequest();
            erpLog.setType(ToolUtil.isAjaxRequest(request) ? "Ajax请求" : "普通请求");
            erpLog.setTitle(log.value());
            erpLog.setHost(request.getRemoteHost());
            erpLog.setUri(request.getRequestURI().toString());
    // erpLog.setHeader(request.getHeader(HttpHeaders.USER_AGENT));
            erpLog.setHttpMethod(request.getMethod());
            erpLog.setClassMethod(joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());
            // 请求的方法参数值
            Object[] args = joinPoint.getArgs();
            // 请求的方法参数名称
            LocalVariableTableParameterNameDiscoverer u
                    = new LocalVariableTableParameterNameDiscoverer();
            String[] paramNames = u.getParameterNames(method);
            if (args != null && paramNames != null) { 
                StringBuilder params = new StringBuilder();
                params = handleParams(params, args, Arrays.asList(paramNames));
                erpLog.setParams(params.toString());
            }
            String retString = JsonUtil.bean2Json(rvt);
            erpLog.setResponseValue(retString.length() > 5000 ? JsonUtil.bean2Json("请求参数数据过长不与显示") : retString);
            if (e != null) { 
                erpLog.setErrorCode(1);
                erpLog.setErrorMessage(e.getMessage());
            }
            Date stime = startTime.get();
            erpLog.setStartTime(stime);
            erpLog.setEndTime(now);
            erpLog.setExecuteTime(now.getTime() - stime.getTime());
            erpLog.setUsername(MySysUser.loginName());
            HashMap<String, String> browserMap = ToolUtil.getOsAndBrowserInfo(request);
            erpLog.setOperatingSystem(browserMap.get("os"));
            erpLog.setBrower(browserMap.get("browser"));
            erpLog.setId(IdUtil.simpleUUID());
            logService.insertSelective(erpLog);
        }
    
        /** * 是否存在注解，如果存在就获取 */
        private Log getAnnotationLog(Method method) { 
            if (method != null) { 
                return method.getAnnotation(Log.class);
            }
            return null;
        }
    
        private Method getMethod(JoinPoint joinPoint) { 
            Signature signature = joinPoint.getSignature();
            MethodSignature methodSignature = (MethodSignature) signature;
            Method method = methodSignature.getMethod();
            if (method != null) { 
                return method;
            }
            return null;
        }
    
        private StringBuilder handleParams(StringBuilder params, Object[] args, List paramNames) throws JsonProcessingException { 
            for (int i = 0; i < args.length; i++) { 
                if (args[i] instanceof Map) { 
                    Set set = ((Map) args[i]).keySet();
                    List list = new ArrayList();
                    List paramList = new ArrayList<>();
                    for (Object key : set) { 
                        list.add(((Map) args[i]).get(key));
                        paramList.add(key);
                    }
                    return handleParams(params, list.toArray(), paramList);
                } else { 
                    if (args[i] instanceof Serializable) { 
                        Class<?> aClass = args[i].getClass();
                        try { 
                            aClass.getDeclaredMethod("toString", new Class[]{ null});
                            // 如果不抛出NoSuchMethodException 异常则存在 toString 方法 ，安全的writeValueAsString ，否则 走 Object的 toString方法
                            params.append(" ").append(paramNames.get(i)).append(": ").append(objectMapper.writeValueAsString(args[i]));
                        } catch (NoSuchMethodException e) { 
                            params.append(" ").append(paramNames.get(i)).append(": ").append(objectMapper.writeValueAsString(args[i].toString()));
                        }
                    } else if (args[i] instanceof MultipartFile) { 
                        MultipartFile file = (MultipartFile) args[i];
                        params.append(" ").append(paramNames.get(i)).append(": ").append(file.getName());
                    } else { 
                        params.append(" ").append(paramNames.get(i)).append(": ").append(args[i]);
                    }
                }
            }
            return params;
        }
    }

4、对应代码添加注解

@Log("新增学生")
        @RequestMapping(value = "/create", method = RequestMethod.POST)
        @ResponseBody
        public ResultBean<String> create(@RequestBody @Validated ErpStudent item) { 
            if(service.insertSelective(item) == 1) { 
                // 插入
                insertErpSFamilyMember(item);
                return new ResultBean<String>("");
            }
    
            return new ResultBean<String>(ExceptionEnum.BUSINESS_ERROR, "新增学生异常！", "新增失败!", "");
        }

通过对业务进行操作后，会写入数据库，界面查询：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoeWFud3U2OA_size_16_color_FFFFFF_t_70 2]

日志管理的完整的代码可以从git上获取：  
[https://github.com/chyanwu/erp-framework][https_github.com_chyanwu_erp-framework]

更多精彩，更多技术请关注：码蚁在线（coding\_online）  
![在这里插入图片描述][20190926215452589.jpg_pic_center]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoeWFud3U2OA_size_16_color_FFFFFF_t_70]: /images/20230531/38289f212b7645849b683860e3b05fa2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoeWFud3U2OA_size_16_color_FFFFFF_t_70 1]: /images/20230531/3c85a0730a554a559c3c4193afb6703a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoeWFud3U2OA_size_16_color_FFFFFF_t_70 2]: /images/20230531/757dd6fb6f444c3fbf178dc2950e04d8.png
[https_github.com_chyanwu_erp-framework]: https://github.com/chyanwu/erp-framework
[20190926215452589.jpg_pic_center]: /images/20230531/2cba48f8e4804b2082d9f0540ee8b340.png