devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

springboot aop注解_spring boot aop注解

作者：笔触狂放9 | 2024-08-18 04:08:50

赞

踩

spring boot aop注解

目录

1.需求描述

2.实现思路

3.代码实现

3.1添加aspect依赖

3.2新建避免前端重复提交注解@AvoidRepeatable

3.3编写注解aop切面代码

1.需求描述

        实现通过给指定方法添加注解的方式，对添加注解的方法进行重新提交进行控制。

2.实现思路

        新建一个用于标识避免重复的注解@AvoidRepeatable，同时当前后端调用注解标识的方法时，约定一个单次调用唯一凭证uuid，后端收到调用后，先在redis中检测是否有对该方法的uuid缓存，如果有说明前面已有携带该uuid的调用，直接提示重复提交；若在redis中无该uuid的缓存，先在redis中缓存，再执行业务方法，若业务方法执行失败，清除uuid缓存，若业务方法执行成功，不主动清除uuid缓存，通过设置超时时间来清除uuid，用于避免在执行成功后在超时内避免重复提交。

        代码编写顺序：

        1.引入aspect依赖，用于注解aop切面代码编写。

        2.新建避免前端重复提交注解@AvoidRepeatable。

        3.编写注解aop切面代码。

        4.在需要避免重复提交的方法上添加@AvoidRepeatable注解。

3.代码实现

3.1添加aspect依赖

  1. 		<!-- aop切面 -->
  2. 		<dependency>
  3. 			<groupId>org.aspectj</groupId>
  4. 			<artifactId>aspectjrt</artifactId>
  5. 			<version>1.9.5</version>
  6. 		</dependency>
  7. 		<dependency>
  8. 			<groupId>org.aspectj</groupId>
  9. 			<artifactId>aspectjweaver</artifactId>
  10. 			<version>1.9.5</version>
  11. 		</dependency>

3.2新建避免前端重复提交注解@AvoidRepeatable

  1. package com.ybjdw.product.utils;
  2.  
  3. import java.lang.annotation.ElementType;
  4. import java.lang.annotation.Retention;
  5. import java.lang.annotation.RetentionPolicy;
  6. import java.lang.annotation.Target;
  7.  
  8. /**
  9.  * <一句话功能简述> 避免前端重复提交注解
  10.  * <功能详细描述> 在需要保存的方法上添加上，同时要求前端传递唯一参数uuid
  11.  * author: zhanggj
  12.  * 创建时间:  2017年9月7日
  13.  */
  14. @Target(ElementType.METHOD)
  15. @Retention(RetentionPolicy.RUNTIME)
  16. public @interface AvoidRepeatable {
  17.  
  18. }

3.3编写注解aop切面代码

  1. package com.ybjdw.product.utils;
  2.  
  3. import com.alibaba.fastjson.JSON;
  4. import com.alibaba.fastjson.JSONObject;
  5. import com.ybjdw.base.utils.ConcurrentUtils;
  6. import com.ybjdw.base.utils.HttpUtils;
  7. import org.apache.commons.lang3.StringUtils;
  8. import org.aspectj.lang.ProceedingJoinPoint;
  9. import org.aspectj.lang.annotation.After;
  10. import org.aspectj.lang.annotation.AfterReturning;
  11. import org.aspectj.lang.annotation.AfterThrowing;
  12. import org.aspectj.lang.annotation.Around;
  13. import org.aspectj.lang.annotation.Aspect;
  14. import org.aspectj.lang.annotation.Before;
  15. import org.aspectj.lang.annotation.Pointcut;
  16. import org.aspectj.lang.reflect.MethodSignature;
  17. import org.slf4j.Logger;
  18. import org.slf4j.LoggerFactory;
  19. import org.springframework.beans.factory.annotation.Autowired;
  20. import org.springframework.context.annotation.Lazy;
  21. import org.springframework.data.redis.core.RedisTemplate;
  22. import org.springframework.stereotype.Component;
  23.  
  24. import java.lang.reflect.Method;
  25.  
  26. /**
  27.  * author: zhanggw
  28.  * 创建时间:  2021/9/7
  29.  */
  30. @Aspect
  31. @Component
  32. @Lazy(false)
  33. public class AvoidRepeatableAspect {
  34.  
  35.     private static final Logger logger = LoggerFactory.getLogger(AvoidRepeatableAspect.class);
  36.  
  37.     @Autowired
  38.     private RedisTemplate<String, String> redisTemplate;
  39.  
  40.     /**
  41.      * 定义切入点：对要拦截的方法进行定义与限制，如包、类
  42.      *
  43.      * 1、execution(public * *(..)) 任意的公共方法
  44.      * 2、execution（* set*（..）） 以set开头的所有的方法
  45.      * 3、execution（* com.ybjdw.annotation.LoggerApply.*（..））com.ybjdw.annotation.LoggerApply这个类里的所有的方法
  46.      * 4、execution（* com.ybjdw.annotation.*.*（..））com.ybjdw.annotation包下的所有的类的所有的方法
  47.      * 5、execution（* com.ybjdw.annotation..*.*（..））com.ybjdw.annotation包及子包下所有的类的所有的方法
  48.      * 6、execution(* com.ybjdw.annotation..*.*(String,?,Long)) com.ybjdw.annotation包及子包下所有的类的有三个参数，第一个参数为String类型，第二个参数为任意类型，第三个参数为Long类型的方法
  49.      * 7、execution(@annotation(com.ybjdw.product.utils.AvoidRepeatable)) 跟随注解
  50.      */
  51.     @Pointcut("@annotation(com.ybjdw.product.utils.AvoidRepeatable)")
  52.     private void cutMethod() {
  53.     }
  54.  
  55.     /**
  56.      * 前置通知：在目标方法执行前调用
  57.      */
  58.     @Before("cutMethod()")
  59.     public void begin() {
  60.     }
  61.  
  62.     /**
  63.      * 后置通知：在目标方法执行后调用，若目标方法出现异常，则不执行
  64.      */
  65.     @AfterReturning("cutMethod()")
  66.     public void afterReturning() {
  67.     }
  68.  
  69.     /**
  70.      * 后置/最终通知：无论目标方法在执行过程中出现一场都会在它之后调用
  71.      */
  72.     @After("cutMethod()")
  73.     public void after() {
  74.     }
  75.  
  76.     /**
  77.      * 异常通知：目标方法抛出异常时执行
  78.      */
  79.     @AfterThrowing("cutMethod()")
  80.     public void afterThrowing() {
  81.     }
  82.  
  83.     /**
  84.      * 环绕通知：灵活自由的在目标方法中切入代码
  85.      */
  86.     @Around("cutMethod()")
  87.     public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
  88.         Object retObj = null;
  89.         Object[] params = joinPoint.getArgs(); // 方法参数
  90.         String methodName = joinPoint.getSignature().getName(); // 方法名
  91.         try{
  92.             if(params != null && params.length > 0){
  93.                 JSONObject dataJson = JSON.parseObject(params[0].toString());
  94.                 if(dataJson != null){
  95.                     String uuid = dataJson.getString("uuid"); // 单次唯一凭证
  96.                     if(StringUtils.isBlank(uuid)){
  97.                         return joinPoint.proceed();
  98.                     }
  99.  
  100.                     String redisKey = methodName + uuid;
  101.                     boolean uniqueRun = ConcurrentUtils.isUniqueRun(redisTemplate, redisKey, 1000*60*3); // 重复检测
  102.                     if(uniqueRun){ // 唯一运行
  103.                         retObj = joinPoint.proceed();
  104.                         if(retObj != null){
  105.                             JSONObject methodReturnJson = JSON.parseObject(retObj.toString());
  106.                             if(!methodReturnJson.getBooleanValue("flag")){ // 方法执行失败清理缓存锁，以便于前端再次提交；成交则保留缓存锁，防止重复提交
  107.                                 ConcurrentUtils.freeRedisLock(redisTemplate, redisKey);
  108.                             }
  109.                         }
  110.                     }else{
  111.                         logger.error("product_avoidrepeatable_around_error : methodName:{},uuid:{}重复提交!", methodName, uuid);
  112.                         return HttpUtils.showFail("product_avoidrepeatable_around_error","methodName:"+methodName+",uuid:"+uuid+"重复提交!");
  113.                     }
  114.                 }
  115.             }
  116.         }catch (Exception e){
  117.             logger.debug("methodName:{},params:{}",methodName,params);
  118.             logger.error("防止重复提交异常!", e);
  119.         }
  120.         return retObj;
  121.     }
  122.  
  123.     /**
  124.      * 获取方法中声明的注解
  125.      */
  126.     public AvoidRepeatable getDeclaredAnnotation(ProceedingJoinPoint joinPoint) throws NoSuchMethodException {
  127.         // 获取方法名
  128.         String methodName = joinPoint.getSignature().getName();
  129.         // 反射获取目标类
  130.         Class<?> targetClass = joinPoint.getTarget().getClass();
  131.         // 拿到方法对应的参数类型
  132.         Class<?>[] parameterTypes = ((MethodSignature) joinPoint.getSignature()).getParameterTypes();
  133.         // 根据类、方法、参数类型（重载）获取到方法的具体信息
  134.         Method objMethod = targetClass.getMethod(methodName, parameterTypes);
  135.         // 拿到方法定义的注解信息
  136.         AvoidRepeatable annotation = objMethod.getDeclaredAnnotation(AvoidRepeatable.class);
  137.         // 返回
  138.         return annotation;
  139.     }
  140.  
  141. }

3.4在目标方法上添加注解

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/995850
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号