自定义注解实现方式解析

​自定义注意在日常开发中经常使用，同时有很多实现自定义注解的方式，本文将带你一一了解。

1.源注解解析

@Retention

    //注解只会存在源代码中，将会被编译器丢弃
    SOURCE,
    //注解将会保留到class文件阶段，但是在加载如vm的时候会被抛弃
    CLASS,
    //注解不单会被保留到class文件阶段，而且也会被vm加载进虚拟机的时候保留
    RUNTIME

@Target

用于描述类、接口(包括注解类型) 或enum声明 Class, interface (including annotation type), or enum declaration 
    TYPE,

    用于描述域 Field declaration (includes enum constants)
    FIELD,
 
    用于描述方法 Method declaration
    METHOD,
 
    用于描述参数 Formal parameter declaration 
    PARAMETER,

    用于描述构造器 Constructor declaration
    CONSTRUCTOR,
 
    用于描述局部变量 Local variable declaration
    LOCAL_VARIABLE,
 
    Annotation type declaration
    ANNOTATION_TYPE,
 
    用于描述包 Package declaration
    PACKAGE,
 
    用来标注类型参数 Type parameter declaration
    TYPE_PARAMETER,
 
     *能标注任何类型名称 Use of a type
    TYPE_USE

2.依赖于@Conditional

原理是是否满足@Conditional中绑定类的条件，如果满足，就将使用注解的类注入进factory，不满足就不注入，只能在类中使用或者配合@bean使用。

1.添加注解类

首先定义一个注解类，定义的变量为参数。

@Conditional(CustomOnPropertyCondition.class)意思为CustomOnPropertyCondition类中返回为true才会使用注解

package com.airboot.bootdemo.config;
import org.springframework.context.annotation.Conditional;
import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
@Documented
@Conditional(CustomPropertyCondition.class)
public @interface CustomProperty {
    
    //参数
    String name() default "";
        /**
         * havingValue数组，支持or匹配
         */

    //参数
    String[] havingValue() default {};

}

2.CustomOnPropertyCondition类

实现condition接口，以下是实现接口后的代码，然后在其中填补。

public class CustomPropertyCondition implements Condition {
    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        return false;
    }
}

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.Map;


public class CustomPropertyCondition implements Condition {
    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        //获取注解上的参数和配置值
        Map<String, Object> annotationAttributes = annotatedTypeMetadata.getAnnotationAttributes(RequestMapping.class.getName());
        //获取具体的参数值
        String propertyName = (String) annotationAttributes.get("name");
        String[] values = (String[]) annotationAttributes.get("havingValue");
        if (0 == values.length) {
            return false;
        }
        //从application.properties中获取配置
        String propertyValue = conditionContext.getEnvironment().getProperty(propertyName);
        // 有一个匹配上就ok
        for (String havingValue : values) {
            if (propertyValue.equalsIgnoreCase(havingValue)) {
                return true;
            }
        }
        return false;
    }
}

Map<String, Object> annotationAttributes = annotatedTypeMetadata.getAnnotationAttributes(RequestMapping.class.getName()); 获取类中注解上的参数

String propertyValue = conditionContext.getEnvironment().getProperty(propertyName);获取application.properties上的配置。

3.使用注解

@RequestMapping(value ="/Demo")
@Controller
@ResponseBody
@Api("demo测试类")
@CustomProperty(name = "condition",havingValue = {"2"})
public class DemoController {

}

注解会在在spring boot启动时加载。

3.使用HandlerMethodArgumentResolver

注意该方法只能接受get请求。

1.添加注解类

package com.airboot.bootdemo.config;

import java.lang.annotation.*;


@Target({ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface UserCheck {

    //当前用户在request中的名字
    String value() default "userid";
}

2.定义类HandlerMethodArgumentResolver

其中resolveArgument中返回的是controllor的参数，也就是这个方法里面可以组装入参 。UserCheckMethodArgumentResolver 为拦截注解后的逻辑

import org.springframework.core.MethodParameter;
import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.ModelAndViewContainer;

public class UserCheckMethodArgumentResolver implements HandlerMethodArgumentResolver {
    @Override
    public boolean supportsParameter(MethodParameter methodParameter) {
        return false;
    }

    @Override
    public Object resolveArgument(MethodParameter methodParameter, ModelAndViewContainer modelAndViewContainer, NativeWebRequest nativeWebRequest, WebDataBinderFactory webDataBinderFactory) throws Exception {
        return null;
    }
}

import com.airboot.bootdemo.entity.DemoVO;
import org.springframework.core.MethodParameter;
import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.ModelAndViewContainer;

public class UserCheckMethodArgumentResolver implements HandlerMethodArgumentResolver {
    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        if (parameter.getParameterType().isAssignableFrom(DemoVO.class) && parameter.hasParameterAnnotation(UserCheck.class)) {
            return true;
        }
        return false;
    }

    @Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
        UserCheck currentUserAnnotation = parameter.getParameterAnnotation(UserCheck.class);
        //获取head中的
        String userId = webRequest.getHeader("userId");
        //组装入参 return后的参数 类型需要和controllor中的相同 
        DemoVO demoVO = new DemoVO();
        demoVO.setId(Long.valueOf(1));
        return demoVO;
    }
}

3.使用注解

    @GetMapping(value = "/selectDemoByVo")
    public List<DemoVO> selectDemoByVo(@RequestBody @UserCheck DemoVO demoVO) {
        return demoService.selectDemoVO(demoVO);
    }

4.基于aop

该方式在日常最常用。主要使用了AOP的功能。

1.AOP的名词介绍

1.JoinPoint  
* java.lang.Object[] getArgs()：获取连接点方法运行时的入参列表； 
* Signature getSignature() ：获取连接点的方法签名对象； 
* java.lang.Object getTarget() ：获取连接点所在的目标对象； 
* java.lang.Object getThis() ：获取代理对象本身； 

2.ProceedingJoinPoint  
* ProceedingJoinPoint继承JoinPoint子接口，它新增了两个用于执行连接点方法的方法： 
* java.lang.Object proceed() throws java.lang.Throwable：通过反射执行目标对象的连接点处的方法； 
* java.lang.Object proceed(java.lang.Object[] args) throws java.lang.Throwable：通过反射执行目标对象连接点处的方法，不过使用新的入参替换原来的入参。 

2.添加注解类

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation {

    int p0() default 0;
    String p1() default "";
    Class<?> clazz();

}

3.切面配置

其中切点要切到注解类的路径。

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Aspect
@Component
public class TestAspect {

    // 切入点签名
    @Pointcut("@annotation(com.airboot.bootdemo.config.TestAnnotation)")
    private void cut() {
    }

    // 前置通知
    @Before("cut()")
    public void BeforeCall() {
        log.info("====前置通知start");

        log.info("====前置通知end");
    }

    // 环绕通知
    @Around(value = "cut()")
    public Object AroundCall(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("====环绕通知start");

        // 注解所切的方法所在类的全类名
        String typeName = joinPoint.getTarget().getClass().getName();
        log.info("目标对象:[{}]", typeName);

        // 注解所切的方法名
        String methodName = joinPoint.getSignature().getName();
        log.info("所切方法名:[{}]", methodName);

        StringBuilder sb = new StringBuilder();
        // 获取参数
        Object[] arguments = joinPoint.getArgs();
        for (Object argument : arguments) {
            sb.append(argument.toString());
        }
        log.info("所切方法入参：[{}]", sb.toString());

        // 统计方法执行时间
        long start = System.currentTimeMillis();

        //执行目标方法，并获得对应方法的返回值
        Object result = joinPoint.proceed();
        log.info("返回结果:[{}]", result);

        long end = System.currentTimeMillis();
        log.info("====执行方法共用时：[{}]", (end - start));

        log.info("====环绕通知之结束");
        return result;
    }

    // 后置通知
    @After("cut()")
    public void AfterCall() {
        log.info("====后置通知start");

        log.info("====后置通知end");
    }

    // 最终通知
    @AfterReturning("cut()")
    public void AfterReturningCall() {
        log.info("====最终通知start");

        log.info("====最终通知end");
    }

    // 异常通知
    @AfterThrowing(value = "cut()", throwing = "ex")
    public void afterThrowing(Throwable ex) {
        throw new RuntimeException(ex);
    }

}

4.使用注解

    @RequestMapping(value = "/selectDemoByVo")
    @TestAnnotation(p0 = 123, p1 = "qaws",clazz = DemoVO.class)
    public List<DemoVO> selectDemoByVo(@RequestBody DemoVO demoVO) {
        return demoService.selectDemoVO(demoVO);
    }

5.拦截器

1.添加注解类

import java.lang.annotation.*;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface InterceptorAnnotation {


    String[] value() default {};

    String[] authorities() default {};

    String[] roles() default {};
}

2.实现拦截器

主要原理就是拦截所有的请求，然后判断方法上是否有自定的注解，如果有注解，执行注解的操作。

import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.Method;

public class TestAnnotationInterceptor extends HandlerInterceptorAdapter {
    // 在调用方法之前执行拦截
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 将handler强转为HandlerMethod, 前面已经证实这个handler就是HandlerMethod
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        // 从方法处理器中获取出要调用的方法
        Method method = handlerMethod.getMethod();
        // 获取出方法上的自定义注解
        InterceptorAnnotation access = method.getAnnotation(InterceptorAnnotation.class);
        if (access == null) {
            // 如果注解为null,没有注解 不拦截
            return true;
        }
        //获取注解值
        if (access.authorities().length > 0) {
            // 如果权限配置不为空, 则取出配置值
            String[] authorities = access.authorities();
        }
        // 拦截之后应该返回公共结果, 这里没做处理
        return true;
    }
}

3.注册拦截器

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@Configuration
public class InterceptorConfig extends WebMvcConfigurerAdapter {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new TestAnnotationInterceptor()).addPathPatterns("/**");
    }
}

4.使用注解

    @RequestMapping(value = "/selectDemoByVo")
    @InterceptorAnnotation(authorities = {"admin"})
    public List<DemoVO> selectDemoByVo(@RequestBody DemoVO demoVO) {
        return demoService.selectDemoVO(demoVO);
    }

6.ConstraintValidator注解实现验证

此方法大多是验证入参格式使用。

1.添加注解类

其中message是返回值，groups()和payload() 是必须有的。@Constraint(validatedBy = TestConstraintValidator.class) 是处理注解逻辑的类。

import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.*;

@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Constraint(validatedBy = TestConstraintValidator.class)
public @interface TestConstraintAnnotation {

    String message() default "入参大小不合适";

    long min();

    long max();

    boolean required() default true;

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};

}

2.逻辑类

需要实现ConstraintValidator<TestConstraintAnnotation, Object>，第一个参数是注解类，第二个参数是入参类型。只有第一次调用时才会调用initialize ，如果满足isValid逻辑，那么就正常执行，不满足会有message提示。

public class TestConstraintValidator implements ConstraintValidator<TestConstraintAnnotation, Object> {
    private long max = 1;
    private long min = 1;

    @Override
    public void initialize(TestConstraintAnnotation constraintAnnotation) {
        max = constraintAnnotation.max();
        min = constraintAnnotation.min();
    }

    @Override
    public boolean isValid(Object o, ConstraintValidatorContext constraintValidatorContext) {
        if(o == null){
            return true;
        }
        if(Long.valueOf(o.toString())>=min && Long.valueOf(o.toString())<=max){
            return true;
        }
        return false;
    }
}

3.使用注解

vo中在需要验证的参数上加上自定义的注解，在方法接收参数前加入@Valid 说明本方法需要验证。

    @RequestMapping(value = "/selectDemoByVo")
    public List<DemoVO> selectDemoByVo(@Valid @RequestBody DemoVO demoVO) {
        return demoService.selectDemoVO(demoVO);
    }

    @TestConstraintAnnotation(min = 1, max = 10)
    private Long id;

​