spring boot 自定义注解

布满荆棘的人生 2021-09-25 02:04 484阅读 0赞

java 自定义注解

在项目开发的过程中我们能遇到的自定义注解一般分为两类：

  1. 通过自定义注解自动获取参数值。比如：@LoginUser
  2. 通过自定义注解做验证。比如 验签，token验证
    上面两类最大的区别就是一个需要返回值一个不需要返回值。
    接下来我将对如上两类自定义的处理方法进行实际的实现，自定义的基础理论可以在网上查找一下，我这里就不做详细的介绍。

第一类 @Loguser

实现分为三步：

  1. 定义一个注解@LoginUser
  2. 创建一个LoginUser注解的解析器
  3. 创建一个配置类（在WebMvcConfigurer ）

定义一个注解

注意： Target

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

创建一个LoginUser注解的解析器

  1. @Component
  2. public class LoginUserHandlerMethodArgumentResolver implements HandlerMethodArgumentResolver {
  3.     @Autowired
  4.     private LoginService loginService;
  6.     @Override
  7.     public boolean supportsParameter(MethodParameter parameter) {
  8.         return parameter.getParameterType().isAssignableFrom(User.class) && parameter.hasParameterAnnotation(LoginUser.class);
  9.     }
  10.     @Override
  11.     public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer container,NativeWebRequest request, WebDataBinderFactory factory) throws Exception {
  12.             Long cUserId=(Long) request.getAttribute(Constants.CURRENT_USER_ID,RequestAttributes.SCOPE_REQUEST);
  13.              if (cUserId>0) {
  15.                   User user = loginService.getUserById(cUserId);
  16.                   if(user == null) {
  17.                       throw new RuntimeException(i18nService.getMessage("user.not.exist"));
  18.                   }
  19.                   //重点是这里返回对象
  20.                   return user;
  21.              }
  22.      }
  23. }

创建一个配置类

  1. @Configuration
  2. public class LoginUserConfigurer implements WebMvcConfigurer {
  3.     //必须用注入方式，不能用new，否则此对象内部属性无法被注入
  4.     @Autowired
  5.     private LoginUserHandlerMethodArgumentResolver loginUserHandlerMethodArgumentResolver;
  7.     /**
  8.      * 配置自定义参数解析器
  9.      */
  10.     @Override
  11.     public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
  12.         argumentResolvers.add(loginUserHandlerMethodArgumentResolver);
  13.     }
  15. }

直接可以在代码里面使用

  1. public ResponseResult saveServiceInfo(@LoginUser User loginUser) {
  2.     // 下面直接获取数据
  3.     loginUser.getUsername();
  4. }

第二类 验证

  1. 先定义注解
  2. 定义一个切面
  3. 直接使用

定义注解

注意： Target

  1. import java.lang.annotation.*;
  2. @Target({ElementType.METHOD,ElementType.PARAMETER, ElementType.TYPE})
  3. @Retention(RetentionPolicy.RUNTIME)
  4. @Documented
  5. public @interface ValidatedSignature {
  6.     String value() default "";
  7. }

定义切面

  1. Aspect
  2. @Component
  3. @SuppressWarnings({"unused"})
  4. public class ValidatedSignatureAspect {
  6.     public static final Logger logger = LoggerFactory.getLogger(ValidatedSignature.class);
  8.     public static final String TOKEN_KEY = "token";
  10.     /**
  11.      * checkUrl,keyUrl,tokenScope是通过Spring的@Value注解来获取配置文件中的配置项
  12.      *
  13.      * @Value等同于Spring原先的配置模式中的value <bean id="" class="">
  14.      * <property name="" value="">
  15.      * </bean>
  16.      */
  19.     @Pointcut("@annotation(com.louis.kitty.admin.annotation.ValidatedSignature)")
  20.     public void annotationPointcut() {
  21.         logger.info("annotationPointcut()");
  23.     }
  26.     @Before("annotationPointcut()")
  27.     public void beforePointcut(JoinPoint joinPoint) {
  28.         // 此处进入到方法前  可以实现一些业务逻辑
  29.         logger.info("beforePointcutJoinPoint joinPoint)");
  30.     }
  32.     @Around("annotationPointcut()")
  33.     public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
  34.         logger.info("doAround(ProceedingJoinPoint joinPoint)");
  36.         MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
  37.         String[] params = methodSignature.getParameterNames();// 获取参数名称
  38.         Class[] paramsType = methodSignature.getParameterTypes();
  39.         Object[] args = joinPoint.getArgs();// 获取参数值
  40.         JSONObject jsonObj=new JSONObject();
  41.         for (int index=0;index<params.length;index++) {
  42.             jsonObj.put(params[index],args[index]);
  43.         }
  44.         logger.info(jsonObj.toJSONString());
  45.         int size1=params.length;
  46.         int size2=paramsType.length;
  47.         int size3=args.length;
  50.         RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
  51.         HttpServletRequest request = ((ServletRequestAttributes) requestAttributes).getRequest();
  52.         String token = request.getHeader("token");
  55. //        if (null == params || params.length == 0) {
  56. //            String mes = "Using Token annotation, the token parameter is not passed, and the parameter is not valid.";
  57. //            logger.info(mes);
  58. //            throw new Exception(mes);
  59. //        }
  60. //        boolean hasToken = false;
  61. //        int index = 0;
  62. //        for (int i = 0; i < params.length; i++) {
  63. //            if (TOKEN_KEY.equals(params[i])) {
  64. //                hasToken = true;
  65. //                index = i;
  66. //                break;
  67. //            }
  68. //        }
  69. //        if (!hasToken) {
  70. //            String mes = "The token parameter is not included in the requested parameter, the parameter is not valid.";
  71. //            logger.info(mes);
  72. //            throw new Exception(mes);
  73. //        }
  74.         return jsonObj;
  75. //        return joinPoint.proceed();
  76.     }
  78.     /**
  79.      * 在切入点return内容之后切入内容（可以用来对处理返回值做一些加工处理）
  80.      *
  81.      * @param joinPoint
  82.      */
  83.     @AfterReturning("annotationPointcut()")
  84.     public void doAfterReturning(JoinPoint joinPoint) {
  85.         logger.info("doAfterReturning(JoinPoint joinPoint)");
  86.     }
  87. }

代码直接使用

  1. @ValidatedSignature
  2. public ResponseResult saveServiceInfo() {
  4. }

发表评论

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

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

相关阅读