Spring实现自定义注解

Spring实现自定义注解

自定义注解的意义

自定义注解是一种代码标签，其本身并没有任何作用。只有在特定的场景下由特定的代码去解析处理才有作用和意义。

自定义注解本身是为了简化代码开发，解耦，提高代码的可读性和维护性。

Spring常用注解

元注解：元注解就是注解的注解。主要有以下几种：

• Retention：定义注解的生命周期。
• Dicumented：文档注解化，会被javadoc工具文档化。
• Inherited：标注注解继承的。
• Target：通过ElementType指定注解的的使用范围。

Target的ElementType值描述：

注解语法

• 成员方法需要是无参无异常的。
• 可以使用defafult来赋默认值。
• 成员方法的返回类型必须是八大基础数据类型，封装类型不行，如：String，Class，Annotation，枚举类型等。
• 如果注解中只有一个方法，则方法名为value。
• 注解类中可以没有任何成员信息，这样的注解为标识注解。

注解作用域@Retention

Retention，注解的生命周期（作用域）是由该注解维护的。
主要有以下几种配置：

• Source：源码注解，只存在源码中，编译成class文件后就会消失。（RetentionPolicy.SOURCE）
• Class：编译时注解，在源码和class文件中存在，在运行时会移除，比如：@Override。（RetentionPolicy.CLASS）
• runtime：运行时注解，会保留到代码运行的时候，甚至可能会影响运行时逻辑。比如：@Autowired。（RetentionPolicy.RUNTIME）

@Target注解

@Target 定义注解的使用位置，用来说明该注解可以被声明在哪些元素之前。
常见声明如下：

• ElementType.TYPE：说明该注解只能被声明在一个类前。
• ElementType.FIELD：说明该注解只能被声明在一个类的字段前。
• ElementType.METHOD：说明该注解只能被声明在一个类的方法前。
• ElementType.PARAMETER：说明该注解只能被声明在一个方法参数前。
• ElementType.CONSTRUCTOR：说明该注解只能声明在一个类的构造方法前。
• ElementType.LOCAL_VARIABLE：说明该注解只能声明在一个局部变量前。
• ElementType.ANNOTATION_TYPE：说明该注解只能声明在一个注解类型前。
• ElementType.PACKAGE：说明该注解只能声明在一个包名前。

引入依赖

// javax.validation
// https://mvnrepository.com/artifact/javax.validation/validation-api
implementation group: 'javax.validation', name: 'validation-api', version: '2.0.1.Final'

字段注解

字段注解一般是用于校验字段是否满足要求，hibernate-validate依赖提供了很多校验注解 ，如@NotNull、@Range等，但这些注解并不能够满足所有的业务场景。

Check注解接口实现

import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

// 只允许用在类的字段上
@Target({ElementType.FIELD})
// 注解保留在程序运行期间，此时可以通过反射获得定义在某个类上的所有注解
@Retention(RetentionPolicy.RUNTIME)
// 通过使用validatedBy来指定与注解关联的验证器
@Constraint(validatedBy = ParamConstraintValidated.class)
public @interface Check {

    /**
     * 合法的参数值
     */
    String[] paramValues();

    /**
     * 提示信息
     */
    String message() default "参数不为指定值";

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

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

}

Check注解验证类实现

import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;
import java.util.Arrays;
import java.util.List;

public class ParamConstraintValidated implements ConstraintValidator<Check, Object> {

    /**
     * 合法的参数值，从注解中获取
     */
    private List<String> paramValues;

    @Override
    public void initialize(Check constraintAnnotation) {
        // 初始化时获取注解上的值
        paramValues = Arrays.asList(constraintAnnotation.paramValues());
    }

    public boolean isValid(Object o, ConstraintValidatorContext constraintValidatorContext) {
        if (paramValues.contains(o)) {
            return true;
        }

        // 不在指定的参数列表中
        return false;
    }
}

验证对象Entity实现

import javax.validation.constraints.NotNull;

public class User {

    /**
     * 姓名
     * 内置注解
     */
    @NotNull
    private String name;

    /**
     * 性别 man or women
     */
    @Check(paramValues = {"man", "woman"})
    private String sex;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getSex() {
        return sex;
    }
}

测试控制层实现

import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {

    @PostMapping("/api/test")
    public String test(@Validated @RequestBody User user) {
        return user.getName() + " : " + user.getSex();
    }
}

方法&类注解

权限注解使用场景。

权限注解接口实现

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

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface PermissionCheck {

    /**
     * 资源key
     */
    String resourceKey();

}

拦截器配置类实现

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 PermissionCheckInterceptor());
    }
}

权限验证拦截类实现

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

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class PermissionCheckInterceptor extends HandlerInterceptorAdapter {

    /**
     * 处理器处理之前调用
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
                             Object handler) throws Exception {
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        PermissionCheck permission = findPermissionCheck(handlerMethod);

        // 如果没有添加权限注解则直接跳过允许访问
        if (permission == null) {
            return true;
        }

        // 获取注解中的值
        String resourceKey = permission.resourceKey();

        // TODO 权限校验一般需要获取用户信息，通过查询数据库进行权限校验
        // TODO 这里只进行简单演示，如果resourceKey为testKey则校验通过，否则不通过
        if ("testKey".equals(resourceKey)) {
            return true;
        }

        return false;
    }

    /**
     * 根据handlerMethod返回注解信息
     *
     * @param handlerMethod 方法对象
     * @return PermissionCheck注解
     */
    private PermissionCheck findPermissionCheck(HandlerMethod handlerMethod) {
        // 在方法上寻找注解
        PermissionCheck permission = handlerMethod.getMethodAnnotation(PermissionCheck.class);
        if (permission == null) {
            // 在类上寻找注解
            permission = handlerMethod.getBeanType().getAnnotation(PermissionCheck.class);
        }

        return permission;
    }
}

测试控制层实现

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {

    @GetMapping("/api/test/true")
    @PermissionCheck(resourceKey = "testKey")
    public String testPermissionCheckTrue() {
        return "yes! ";
    }

    @GetMapping("/api/test/false")
    @PermissionCheck(resourceKey = "test")
    public String testPermissionCheckFalse() {
        return "no! ";
    }
}