使用 Spring Boot AOP 实现 Web 日志处理和分布式锁

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
清单 2. 添加 AOP 相关依赖
<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ControllerWebLog {
     String name();
     boolean intoDb() default false;

}

@Aspect
   @Component
   @Order(100)
   public class WebLogAspect {
   }

@Pointcut(\\\"execution(* cn.itweknow.sbaop.controller..*.*(..))\\\")
   public void webLog() {}

@Before(value = \\\"webLog()& & @annotation(controllerWebLog)\\\")
       public void doBefore(JoinPoint joinPoint, ControllerWebLog controllerWebLog) {
           // 开始时间。
           long startTime = System.currentTimeMillis();
           Map<String, Object> threadInfo = new HashMap<>();
           threadInfo.put(START_TIME, startTime);
           // 请求参数。
           StringBuilder requestStr = new StringBuilder();
           Object[] args = joinPoint.getArgs();
           if (args != null && args.length > 0) {
               for (Object arg : args) {
                   requestStr.append(arg.toString());
               }
           }
           threadInfo.put(REQUEST_PARAMS, requestStr.toString());
           threadLocal.set(threadInfo);
           logger.info(\\\"{}接口开始调用:requestData={}\\\", controllerWebLog.name(), threadInfo.get(REQUEST_PARAMS));
    }

@AfterReturning(value = \\\"webLog()&& @annotation(controllerWebLog)\\\", returning = \\\"res\\\")
   public void doAfterReturning(ControllerWebLog controllerWebLog, Object res) {
           Map<String, Object> threadInfo = threadLocal.get();
           long takeTime = System.currentTimeMillis() - (long) threadInfo.getOrDefault(START_TIME, System.currentTimeMillis());
           if (controllerWebLog.intoDb()) {
               insertResult(controllerWebLog.name(), (String) threadInfo.getOrDefault(REQUEST_PARAMS, \\\"\\\"),
                           JSON.toJSONString(res), takeTime);
           }
           threadLocal.remove();
           logger.info(\\\"{}接口结束调用:耗时={}ms,result={}\\\", controllerWebLog.name(),
                   takeTime, res);
   }

@AfterThrowing(value = \\\"webLog()& & @annotation(controllerWebLog)\\\", throwing = \\\"throwable\\\")
       public void doAfterThrowing(ControllerWebLog controllerWebLog, Throwable throwable) {
           Map< String, Object> threadInfo = threadLocal.get();
           if (controllerWebLog.intoDb()) {
               insertError(controllerWebLog.name(), (String)threadInfo.getOrDefault(REQUEST_PARAMS, \\\"\\\"),
                       throwable);
           }
           threadLocal.remove();
           logger.error(\\\"{}接口调用异常，异常信息{}\\\",controllerWebLog.name(), throwable);
   }

@PostMapping(\\\"/post-test\\\")
   @ApiOperation(\\\"接口日志 POST 请求测试\\\")
   @ControllerWebLog(name = \\\"接口日志 POST 请求测试\\\", intoDb = true)
   public BaseResponse postTest(@RequestBody BaseRequest baseRequest) {
   }

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface DistributeLock {
    String key();
    long timeout() default 5;
    TimeUnit timeUnit() default TimeUnit.SECONDS;
}

private String getLock(String key, long timeout, TimeUnit timeUnit) {
        try {
            String value = UUID.randomUUID().toString();
            Boolean lockStat = stringRedisTemplate.execute((RedisCallback< Boolean>)connection ->
                    connection.set(key.getBytes(Charset.forName(\\\"UTF-8\\\")), value.getBytes(Charset.forName(\\\"UTF-8\\\")),
                            Expiration.from(timeout, timeUnit), RedisStringCommands.SetOption.SET_IF_ABSENT));
            if (!lockStat) {
                // 获取锁失败。
                return null;
            }
            return value;
        } catch (Exception e) {
            logger.error(\\\"获取分布式锁失败，key={}\\\", key, e);
            return null;
        }
}

private void unLock(String key, String value) {
        try {
            String script = \\\"if redis.call(\\\'get\\\', KEYS[1]) == ARGV[1] then return redis.call(\\\'del\\\', KEYS[1]) else return 0 end\\\";
            boolean unLockStat = stringRedisTemplate.execute((RedisCallback< Boolean>)connection ->
                    connection.eval(script.getBytes(), ReturnType.BOOLEAN, 1,
                            key.getBytes(Charset.forName(\\\"UTF-8\\\")), value.getBytes(Charset.forName(\\\"UTF-8\\\"))));
            if (!unLockStat) {
                logger.error(\\\"释放分布式锁失败，key={}，已自动超时，其他线程可能已经重新获取锁\\\", key);
            }
        } catch (Exception e) {
            logger.error(\\\"释放分布式锁失败，key={}\\\", key, e);
        }
}

@Around(value = \\\"distribute()&& @annotation(distributeLock)\\\")
public Object doAround(ProceedingJoinPoint joinPoint, DistributeLock distributeLock) throws Exception {
        String key = annotationResolver.resolver(joinPoint, distributeLock.key());
        String keyValue = getLock(key, distributeLock.timeout(), distributeLock.timeUnit());
        if (StringUtil.isNullOrEmpty(keyValue)) {
            // 获取锁失败。
            return BaseResponse.addError(ErrorCodeEnum.OPERATE_FAILED, \\\"请勿频繁操作\\\");
        }
        // 获取锁成功
        try {
            return joinPoint.proceed();
        } catch (Throwable throwable) {
            return BaseResponse.addError(ErrorCodeEnum.SYSTEM_ERROR, \\\"系统异常\\\");
        } finally {
            // 释放锁。
            unLock(key, keyValue);
        }
}

@PostMapping(\\\"/post-test\\\")
@ApiOperation(\\\"接口日志 POST 请求测试\\\")
@ControllerWebLog(name = \\\"接口日志 POST 请求测试\\\", intoDb = true)
@DistributeLock(key = \\\"post_test_#{baseRequest.channel}\\\", timeout = 10)
public BaseResponse postTest(@RequestBody BaseRequest baseRequest) {
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return BaseResponse.addResult();
}