从 JVM 的角度看，注解本身对代码逻辑没有任何影响，如何使用注解完全由工具决定。
Java 的注解分为三类

  1. 由编译器使用的注解，例如
    1. @Override：让编译器检查该方法是否正确的实现了覆写
    2. @SuppressWarnings：告诉编译器忽略此处代码产生的警告
  2. 由工具处理 .class 文件使用的注解，比如有些工具在加载 class 的时候，对 class 做动态修改实现一些特殊的功能。使用频率不高

  3. 在程序运行期能够读取的注解，它们在加载后一直存在于 JVM 中。这一种是最常用到的注解

    定义注解

    Java 语言使用 @interface 语法来定义注解，它的格式如下：

    1. public @interface Report {
    2.  int type() default 0;
    3.  String level() default "info";
    4.  String value() default "";
    5. }

    注解的参数类似无参数方法，可以用 default 设定一个默认值（强烈推荐）。最常用的参数应当命名为 value。定义注解时，如果参数名称是 value，且只有一个参数，那么使用时可以忽略参数名称。通常情况下，核心参数使用 value 命名。

    1. public class Hello {
    2.  @Check(min=0, max=100, value=55)
    3.  public int n;
    5.  @Check(value=99)
    6.  public int p;
    8.  @Check(99) // @Check(value=99)
    9.  public int x;
    11.  @Check
    12.  public int y;
    13. }

    @Check 就是一个注解。第一个 @Check(min=0, max=100, value=55) 明确定义了三个参数，第二个 @Check(value=99) 只定义了一个 value 参数，它实际上和 @Check(99) 是完全一样的。最后一个 @Check 表示所有参数都使用默认值。

    元注解

    用于修饰其他注解的注解被称为元注解。Java 标准库已经定义了很多元注解，通常不会自己编写元注解

    @Target

    @Target 最常用的元注解。使用 @Target 定义 Annotation 能够被应用于源码的哪些位置：

  • 类或接口：ElementType.TYPE
  • 字段：ElementType.FIELD
  • 方法：ElementType.METHOD
  • 构造方法：ElementType.CONSTRUCTOR
  • 方法参数：ElementType.PARAMETER

    定义注解可用在多处位置是，可以把 @Target 注解参数变为数组。例如：{ ElementType.METHOD,ElementType.FIELD } 表示注解可用在方法或字段上

@Retention

@Retention 定义 Annotation 的生命周期

  • 仅编译期：RetentionPolicy.SOURCE
  • 仅class文件：RetentionPolicy.CLASS
  • 运行期：RetentionPolicy.RUNTIME

    如果 @Retention 不存在，则该 Annotation 默认为 CLASS。实际开发过程中，定义的 Annotation 生命周期都是 RUNTIME，所以务必要加上 @Retention(RetentionPolicy.RUNTIME) 这个元注解

@Repeatable

@Repeatable 定义 Annotation 是否可重复声明。这个注解用的比较少

@Inherited

@Inherited 定义子类是否可继承父类定义的 Annotation。@Inherited 仅针对 @Target(ElementType.TYPE) 类型的 Annotation 有效，并且仅针对 class 的继承，对 interface 的继承无效

  1. @Inherited
  2. @Target(ElementType.TYPE)
  3. public @interface Report {
  4.     int type() default 0;
  5.     String level() default "info";
  6.     String value() default "";
  7. }

在使用的时候，如果一个类用到了 @Report：

  1. @Report(type=1)
  2. public class Person {
  3. }

则它的子类默认也定义了该注解：

  1. public class Student extends Person {
  2. }

处理注解

Java 的注解本身对代码逻辑没有影响。其生命周期根据 @Retention 的配置决定。因为注解定义后也是一种 class，所有的注解都继承自 java.lang.annotation.Annotation，所以读取注解需要用到反射 API
Java 反射 API 提供的用于读取 Annotation 的方法包括：

  • 判断某个注解是否存在于 Class、Field、Method 或 Constructor：
    • Class.isAnnotationPresent(Class)
    • Field.isAnnotationPresent(Class)
    • Method.isAnnotationPresent(Class)
    • Constructor.isAnnotationPresent(Class)
  • 读取注解 Annotation，如果 Annotation 不存在，将返回 null
    • Class.getAnnotation(Class)
    • Field.getAnnotation(Class)
    • Method.getAnnotation(Class)
    • Constructor.getAnnotation(Class)

      定义参数校验注解工具类

  1. 定义注解 @Range，针对数字型校验最大和最小值、字符串型校验最大和最小长度 ```java 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) public @interface Range { int min() default 0; int max() default 255; }

  2. 2. 定义用于接收校验结果的输出模型类 `ValidationResult` 和 `ValidationError`
  3.    1. `isValid` 属性表示 `JavaBean` 是否通过校验
  4.    1. `errors` 属性存储校验失败的字段和失败原因
  5. ```java
  6. import lombok.Getter;
  7. import lombok.Setter;
  8. import lombok.ToString;
  10. import java.util.List;
  12. @ToString
  13. public class ValidationResult {
  15.     @Getter
  16.     @Setter
  17.     private boolean isValid;
  19.     @Getter
  20.     @Setter
  21.     private List<ValidationError> errors;
  22. }
  24. import lombok.Getter;
  25. import lombok.Setter;
  26. import lombok.ToString;
  28. import java.lang.reflect.Field;
  30. @ToString
  31. public class ValidationError {
  32.     @Getter
  33.     @Setter
  34.     private Field field;
  37.     @Getter
  38.     @Setter
  39.     private String message;
  40. }

  1. 定义字段校验工具类 FieldValidation，工作流程大致分为

    1. 读取 JavaBean 实例类型
    2. 读取 JavaBean 中字段

    3. 遍历字段是否声明 @Range 注解，如果定义则根据规则校验字段内容是否合法

      1. public abstract class FieldValidation {
      3. /**
      4. * 根据特性校验字段值
      5. *
      6. * @param instance 对象示例
      7. * @return boolean
      8. */
      9. public static ValidationResult check(Object instance) throws IllegalAccessException {
      10.   final ValidationResult result = new ValidationResult();
      11.   final ArrayList<ValidationError> errors = CollUtil.newArrayList();
      13.   final Class<?> instanceClass = instance.getClass();
      14.   final Field[] declaredFields = instanceClass.getDeclaredFields();
      15.   if (ArrayUtil.isEmpty(declaredFields)) {
      16.       result.setValid(true);
      17.       return result;
      18.   }
      19.   for (Field field : declaredFields) {
      20.       if (!field.canAccess(instance)) {
      21.           field.setAccessible(true);
      22.       }
      23.       if (!field.isAnnotationPresent(Range.class)) {
      24.           continue;
      25.       }
      27.       final Range range = field.getAnnotation(Range.class);
      28.       final int min = range.min();
      29.       final int max = range.max();
      31.       if (field.getType() == int.class) {
      32.           final var value = (int) field.get(instance);
      33.           if (value < min) {
      34.               final ValidationError error = new ValidationError();
      35.               error.setField(field);
      36.               error.setMessage(String.format("value = %s,can't less than %s", value, min));
      38.               errors.add(error);
      39.           }
      40.           if (value > max) {
      41.               final ValidationError error = new ValidationError();
      42.               error.setField(field);
      43.               error.setMessage(String.format("value = %s,can't greater than %s", value, max));
      45.               errors.add(error);
      46.           }
      47.           continue;
      48.       }
      50.       if (field.getType() == String.class) {
      51.           final var value = (String) field.get(instance);
      52.           if (StrUtil.isEmpty(value)) {
      53.               final ValidationError error = new ValidationError();
      54.               error.setField(field);
      55.               error.setMessage("value can't be null");
      57.               errors.add(error);
      58.               continue;
      59.           }
      60.           final int length = value.length();
      61.           if (length < min) {
      62.               final ValidationError error = new ValidationError();
      63.               error.setField(field);
      64.               error.setMessage(String.format("length can't greater than %s,but %s", max, length));
      66.               errors.add(error);
      67.           }
      68.           if (length > max) {
      69.               final ValidationError error = new ValidationError();
      70.               error.setField(field);
      71.               error.setMessage(String.format("length can't greater than %s,but %s", max, length));
      73.               errors.add(error);
      74.           }
      75.       }
      76.   }
      78.   result.setErrors(errors);
      79.   result.setValid(errors.isEmpty());
      80.   return result;
      81. }
      82. }

  2. 使用 @Range 示例 DemoBean ```java import lombok.Setter;

public class DemoBean {

  1. @Setter
  2. @Range(min = 1, max = 200)
  3. private int age;
  5. @Setter()
  6. @Range(min = 1, max = 3)
  7. private String name;

}

  2. 5. 调用示例
  3. ```java
  4. @Slf4j
  5. public class Main {
  6.     public static void main(String[] args) {
  7.         final DemoBean demoBean = new DemoBean();
  8.         demoBean.setAge(8989);
  9.         demoBean.setName("xcxcxcxc");
  10.         ValidationResult result = new ValidationResult();
  11.         try {
  12.             result = FieldValidation.check(demoBean);
  13.         } catch (IllegalAccessException e) {
  14.             e.printStackTrace();
  15.         }
  16.         log.info("Validation return {}",result.toString());
  17.     }
  18. }
  19. // 打印结果
  20. 22:17:29.127 [main] INFO  com.dev.Main - Validation return ValidationResult(isValid=false, errors=[ValidationError(field=private int com.dev.annotation.DemoBean.age, message=value = 8989,can't greater than 200), ValidationError(field=private java.lang.String com.dev.annotation.DemoBean.name, message=length can't greater than 3,but 8)])