常用自定义注解

Myth丶恋晨 2022-09-02 00:43 305阅读 0赞

导航

  • 一、方法计时器
  • 二、valid 参数校验的通用返回
  • 三、接口访问频次拦截（幂等）

一、方法计时器

注解类：MethodTimer

  1. @Target({ ElementType.METHOD})
  2. @Retention(RetentionPolicy.RUNTIME)
  3. public @interface MethodTimer { 
  4. }

处理器（需要AOP和spring的支持）：MethodTimerProcessor

  1. @Slf4j
  2. @Component
  3. @Aspect
  4. public class MethodTimerProcessor { 
  6.     /** * 处理 @MethodTimer 注解 */
  7.     @Around("@annotation(methodTimer)")
  8.     public Object timerAround(ProceedingJoinPoint point, MethodTimer methodTimer) throws Throwable { 
  9.         long beginMills = System.currentTimeMillis();
  10.         // process the method
  11.         Object result = point.proceed();
  12.         log.info("{} 耗时 : {} ms", point.getSignature(), System.currentTimeMillis() - beginMills);
  13.         return result;
  14.     }
  15. }

使用方法：直接标记在 Controller 的方法上。

二、valid 参数校验的通用返回

注解类：ValidCommonResp

  1. @Target(ElementType.METHOD)
  2. @Retention(RetentionPolicy.RUNTIME)
  3. public @interface ValidCommonResp { 
  4. }

处理器（aop+spring）：ValidCommonRespProcessor

  1. @Slf4j
  2. @Aspect
  3. @Component
  4. public class ValidCommonRespProcessor { 
  5.     /** * 处理 @ValidCommonResp 注解. * 注意，BindingResult是Spring validation的校验结果， * 当参数传入 BindingResult后,Spring MVC就不再控制校验 * 结果的返回，如果不希望使用 @ValidCommonResp的校验结果 * 封装，请在方法中实现校验结果的处理，二者任选其一。 * * @author mouhaotian */
  6.     @Around("@annotation(validCommonResp)")
  7.     public Object aroundAdvice(ProceedingJoinPoint point, ValidCommonResp validCommonResp) throws Throwable { 
  8.         Object[] args = point.getArgs();
  9.         for (Object arg : args) { 
  10.             if (arg instanceof BindingResult) { 
  11.                 BindingResult bindingResult = (BindingResult) arg;
  12.                 if (bindingResult.hasErrors()) { 
  13.                     FieldError fieldError = bindingResult.getFieldError();
  14.                     CommonResp commonResp = new CommonResp(
  15.                             CommonCode.FAIL,
  16.                             fieldError.getField() + fieldError.getDefaultMessage());
  17.                     return R.data(commonResp);
  18.                 }
  19.                 break;
  20.             }
  21.         }
  22.         Object result = point.proceed(args);
  23.         return result;
  24.     }
  25. }

使用方法：搭配 validation 注解、BindingResult 一起使用：

  1. @PostMapping("/xxxx")
  2.     @ValidCommonResp
  3.     public R submit(@Valid @RequestBody DoorzoneInfo doorzoneInfo, BindingResult result) { 
  4.         log.info("请求{}", doorzoneInfo);
  5.         R commonResp = doorzoneInfoService.insertOrUpdDoorzoneInfo(doorzoneInfo);
  6.         log.info("响应{}", commonResp);
  7.         return commonResp;
  8.     }

好处：可以替代代码块中处理 BindingResult 的逻辑。

三、接口访问频次拦截（幂等）

实现一个注解，当controller中的方法收到请求后，在一定时间之内（如10s内）拒绝接收相同参数的请求。即对后台接口的访问增加了频次限制，可以理解为一种不是特别标准的幂等。

注解 @Ide

  1. /** * 幂等校验注解类 */
  2. @Target(ElementType.METHOD)
  3. @Retention(RetentionPolicy.RUNTIME)
  4. @Documented
  5. public @interface Ide { 
  7.     /** * 关键key * key是本次请求中参数的键， * 重复请求的key取自header中的rid * 用来标识这个请求的唯一性 * 拦截器中会使用key从请求参数中获取value * * @return String */
  8.     String key() default "";
  10.     /** * 自定义key的前缀用来区分业务 */
  11.     String perFix();
  13.     /** * 自定义key的超时时间(基于接口) */
  14.     String expireTime();
  16.     /** * 禁止重复提交的模式 * 默认是全部使用 */
  17.     IdeTypeEnum ideTypeEnum() default IdeTypeEnum.ALL;
  18. }

AOP 横切处理逻辑

  1. /** * 注解执行器 处理重复请求 和串行指定条件的请求 * <p> * 两种模式的拦截 * 1.rid 是针对每一次请求的 * 2.key+val 是针对相同参数请求 * </p> * <p> * 另根据谢新的建议对所有参数进行加密检验，提供思路，可以自行扩展 * DigestUtils.md5Hex(userId + "-" + request.getRequestURL().toString()+"-"+ JSON.toJSONString(request.getParameterMap())); * 或 DigestUtils.md5Hex(ip + "-" + request.getRequestURL().toString()+"-"+ JSON.toJSONString(request.getParameterMap())); * </p> */
  2. @Slf4j
  3. @Aspect
  4. @Component
  5. @RequiredArgsConstructor
  6. @ConditionalOnClass(RedisService.class)
  7. public class IdeAspect extends BaseAspect { 
  9.     private final ThreadLocal<String> PER_FIX_KEY = new ThreadLocal<String>();
  11.     /** * 配置注解后 默认开启 */
  12.     private final boolean enable = true;
  14.     /** * request请求头中的key */
  15.     private final static String HEADER_RID_KEY = "RID";
  17.     /** * redis中锁的key前缀 */
  18.     private static final String REDIS_KEY_PREFIX = "RID:";
  20.     /** * 锁等待时长 */
  21.     private static int LOCK_WAIT_TIME = 10;
  23.     private final RedisService redisService;
  25.     @Autowired
  26.     IdeAspectConfig ideAspectConfig;
  28.     @Pointcut("@annotation(cn.com.bmac.wolf.core.ide.annotation.Ide)")
  29.     public void watchIde() { 
  31.     }
  33.     @Before("watchIde()")
  34.     public void doBefore(JoinPoint joinPoint) { 
  35.         Ide ide = getAnnotation(joinPoint, Ide.class);
  37.         if (enable && null != ide) { 
  38.             ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
  39.             if (null == attributes) { 
  40.                 throw new IdeException("请求数据为空");
  41.             }
  42.             HttpServletRequest request = attributes.getRequest();
  43.             //根据配置文件中的超时时间赋值
  44.             if (Func.isNotBlank(ideAspectConfig.getExpireTime())) { 
  45.                 if(Func.isNumeric(ideAspectConfig.getExpireTime())){ 
  46.                     LOCK_WAIT_TIME = Integer.parseInt(ideAspectConfig.getExpireTime());
  47.                 }
  48.             }
  49.             //根据注解传参赋值
  50.             if(Func.isNotBlank(ide.expireTime())){ 
  51.                 LOCK_WAIT_TIME = Integer.parseInt(ide.expireTime());
  52.             }
  53.             //1.判断模式
  54.             if (ide.ideTypeEnum() == IdeTypeEnum.ALL || ide.ideTypeEnum() == IdeTypeEnum.RID) { 
  55.                 //2.1.通过rid模式判断是否属于重复提交
  56.                 String rid = request.getHeader(HEADER_RID_KEY);
  58.                 if (Func.isNotBlank(rid)) { 
  59.                     Boolean result = redisService.tryLock(REDIS_KEY_PREFIX + rid, LOCK_WAIT_TIME);
  60.                     if (!result) { 
  61.                         throw new IdeException("命中RID重复请求");
  62.                     }
  63.                     log.debug("msg1=当前请求已成功记录,且标记为0未处理,,{}={}", HEADER_RID_KEY, rid);
  64.                 } else { 
  65.                     log.warn("msg1=header没有rid,防重复提交功能失效,,remoteHost={}" + request.getRemoteHost());
  66.                 }
  67.             }
  68.             boolean isApiExpireTime = false;
  69.             if (ide.ideTypeEnum() == IdeTypeEnum.ALL
  70.                     || ide.ideTypeEnum() == IdeTypeEnum.KEY) { 
  71.                 //2.2.通过自定义key模式判断是否属于重复提交
  72.                 String key = ide.key();
  73.                 if (Func.isNotBlank(key)) { 
  74.                     String val = "";
  75.                     Object[] paramValues = joinPoint.getArgs();
  76.                     String[] paramNames = ((CodeSignature) joinPoint.getSignature()).getParameterNames();
  77.                     //获取自定义key的value
  78.                     String[] keys = key.split("\\|");
  80.                     for(int i = 0; i < keys.length; i++){ 
  81.                         for (int j = 0; j < paramNames.length; j++) { 
  82.                             //BindingResult 不能转json，会导致线程报错终止
  83.                             if (paramValues[j] instanceof BindingResult) { 
  84.                                 continue;
  85.                             }
  86.                             String params = JSON.toJSONString(paramValues[j]);
  87.                             if (params.startsWith("{")) { 
  88.                                 //如果是对象
  89.                                 //通过key获取value
  90.                                 JSONObject jsonObject = JSON.parseObject(params);
  91.                                 val = val + jsonObject.getString(keys[i]);
  92.                             } else if (keys[i].equals(paramNames[j])) { 
  93.                                 //如果是单个k=v
  94.                                 val = val + params;
  95.                             } else { 
  96.                                 //如果自定义的key,在请求参数中没有此参数,说明非法请求
  97.                                 log.warn("自定义的key,在请求参数中没有此参数,防重复提交功能失效");
  98.                             }
  99.                         }
  100.                     }
  103.                     //判断重复提交的条件
  104.                     String perFix = "";
  105.                     if (Func.isNotBlank(val)) { 
  106.                         String[] perFixs = ide.perFix().split("\\|");
  107.                         int perFixsLength = perFixs.length;
  108.                         for(int i = 0; i < perFixs.length; i++){ 
  109.                             if(Func.isNotBlank(perFix)){ 
  110.                                 perFix = perFix + ":" + perFixs[i];
  111.                             }else{ 
  112.                                 perFix = perFixs[i];
  113.                             }
  114.                         }
  115.                         perFix = perFix + ":" + val;
  116.                         Boolean result = true;
  117.                         try { 
  118.                             result = redisService.tryLock(perFix, LOCK_WAIT_TIME);
  119.                         } catch (Exception e) { 
  120.                             log.error("获取redis锁发生异常", e);
  121.                             throw e;
  122.                         }
  123.                         if (!result) { 
  124.                             String targetName = joinPoint.getTarget().getClass().getName();
  125.                             String methodName = joinPoint.getSignature().getName();
  126.                             log.error("msg1=不允许重复执行,,key={},,targetName={},,methodName={}", perFix, targetName, methodName);
  127.                             throw new IdeException("不允许重复提交");
  128.                         }
  129.                         //存储在当前线程
  130.                         PER_FIX_KEY.set(perFix);
  131.                         log.info("msg1=当前请求已成功锁定:{}", perFix);
  132.                     } else { 
  133.                         log.warn("自定义的key,在请求参数中value为空,防重复提交功能失效");
  134.                     }
  135.                 }
  136.             }
  137.         }
  138.     }
  140.     @After("watchIde()")
  141.     public void doAfter(JoinPoint joinPoint) throws Throwable { 
  142.         try { 
  143.             Ide ide = getAnnotation(joinPoint, Ide.class);
  144.             if (enable && null != ide) { 
  146.                 if (ide.ideTypeEnum() == IdeTypeEnum.ALL
  147.                         || ide.ideTypeEnum() == IdeTypeEnum.RID) { 
  148.                     ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
  149.                     HttpServletRequest request = attributes.getRequest();
  150.                     String rid = request.getHeader(HEADER_RID_KEY);
  151.                     if (Func.isNotBlank(rid)) { 
  152.                         try { 
  153.                             log.info("msg1=当前请求已成功处理,,rid={}", rid);
  154.                         } catch (Exception e) { 
  155.                             log.error("释放redis锁异常", e);
  156.                         }
  157.                     }
  158.                     PER_FIX_KEY.remove();
  159.                 }
  161.                 if (ide.ideTypeEnum() == IdeTypeEnum.ALL
  162.                         || ide.ideTypeEnum() == IdeTypeEnum.KEY) { 
  163.                     // 自定义key
  164.                     String key = ide.key();
  165.                     if (Func.isNotBlank(key) && Func.isNotBlank(PER_FIX_KEY.get())) { 
  166.                         try { 
  167.                             log.info("msg1=当前请求已成功释放,,key={}", PER_FIX_KEY.get());
  168.                             PER_FIX_KEY.set(null);
  169.                             PER_FIX_KEY.remove();
  170.                         } catch (Exception e) { 
  171.                             log.error("释放redis锁异常", e);
  172.                         }
  173.                     }
  174.                 }
  175.             }
  176.         } catch (Exception e) { 
  177.             log.error(e.getMessage(), e);
  178.         }
  179.     }
  180. }

其他相关类

  1. @Data
  2. @Component
  3. @ConfigurationProperties(prefix = "ide")
  4. public class IdeAspectConfig { 
  5.     /** * 过期时间 秒 */
  6.     private String expireTime;
  8. }
  10. @Getter
  11. @AllArgsConstructor
  12. public enum IdeTypeEnum { 
  14.     /** * 0+1 */
  15.     ALL(0, "ALL"),
  16.     /** * ruid 是针对每一次请求的 */
  17.     RID(1, "RID"),
  18.     /** * key+val 是针对相同参数请求 */
  19.     KEY(2, "KEY");
  21.     private final Integer index;
  22.     private final String title;
  23. }

发表评论

表情：
评论列表 （有 0 条评论，305人围观）

还没有评论，来说两句吧...

相关阅读