注解学习 - 简书

背景：

之前对注解其实也特别迷，从来没有自己试过写过自定义注解（其实，一开始学java的那本书，都没有讲过注解，到今年为止我才开始接触注解，之前只是感觉某些地方加上注解之后，就有一些特殊的用法了）

注解是啥：

注解是放在Java源码的类、方法、字段、参数前的一种特殊“注释”，相比于普通的注释，注解可以被编译器打包进入class文件，因此，注解是一种用作标注的“元数据。
我个人感觉注解本生也就是一种特殊类型的类，里面可以定义一些属性，注解上面也可以标注一些属性，并且注解本身不提供任何功能，而那些杂七杂八的功能其实都是别的代码通过反射等手段来实现的。

注解的定义

@Target({ElementType.FIELD, ElementType.PARAMETER})
@Inherited
@Retention(RetentionPolicy.RUNTIME)
public @interface MethodAn1 {
    int value() default 0;// 默认值是0
}

像类一样定义一个注解，注解自身也可以使用注解，注解里面可以定义一些常规属性，还可以设置属性的默认值

常见注解：

@Override：让编译器检查该方法是否正确地实现了覆写；
@SuppressWarnings：告诉编译器忽略此处代码产生的警告。

元注解：（有一些注解可以修饰别的注解）

@Target

用来定义注解可以使用在哪些地方

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

@Retention

另一个重要的元注解@Retention定义了Annotation的生命周期：



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

如果@Retention不存在，则该Annotation默认为CLASS。因为通常我们自定义的Annotation都是RUNTIME，所以，务必要加上

@Repeatable

使用@Repeatable这个元注解可以定义Annotation是否可重复。这个注解应用不是特别广泛。

@Inherited

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

注解的使用例子：

package com.liuwei;
import java.lang.annotation.*;
@Target({ElementType.FIELD, ElementType.PARAMETER})
@Inherited
@Retention(RetentionPolicy.RUNTIME)
public @interface Range {
    int min() default 0;
    int max() default 256;
}

@Target({ElementType.FIELD, ElementType.PARAMETER})
@Inherited
@Retention(RetentionPolicy.RUNTIME)
public @interface MethodAn1 {
    int value() default 0;
}

import java.lang.annotation.*;

@Target({ElementType.FIELD, ElementType.PARAMETER})
@Inherited
@Retention(RetentionPolicy.RUNTIME)
public @interface MethodAn2 {
    String name() default  "test";
}

@Target({ElementType.FIELD, ElementType.PARAMETER})
@Inherited
@Retention(RetentionPolicy.RUNTIME)
public @interface MethodAn3 {
    String name() default  "test";
}

@Liuewei(value = 100, name = "测试")
public class Person {

    @Range(min = 5, max = 25)
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    private String name;

    private void speak(String word){
        System.out.println(word);
    }

    public void test (@MethodAn3 @MethodAn1(value = 0) int value,  @MethodAn2(name = "lw") String name ) {
        System.out.println("测试使用方法参数注解");
    }
}

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Test {

public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException {
    Person p = new Person();
    p.setAge(900);
    Class<? extends Person> aClass = p.getClass();
    checkParam(p);
    // 判断用户是否存在
    boolean annotationPresent = aClass.isAnnotationPresent(Liuewei.class);
    System.out.println(1);
    if (annotationPresent) {
        // 获取注解和属性
        Liuewei lw = aClass.getAnnotation(Liuewei.class);
        String name = lw.name();
        System.out.println(1);
        Annotation[] annotations = aClass.getAnnotations();
        System.out.println(1);

        // 获取方法上的参数注解, 方法的一个参数可以有多个注解， 这边是一个二维的矩阵
        Method test = aClass.getMethod("test", int.class, String.class);
        Annotation[][] parameterAnnotations = test.getParameterAnnotations();
        Annotation[] parameterAnnotation = parameterAnnotations[0];
        for (Annotation annotation : parameterAnnotation) {
            System.out.println(1);
        }
    }
}

public static void checkParam(Person person) throws IllegalAccessException {
    Class<? extends Person> aClass = person.getClass();
    Field[] fields = aClass.getDeclaredFields();
    for (Field field : fields) {
        Range annotation = field.getAnnotation(Range.class);

        if (annotation != null ) {
            if (field.getType().getName().equals("int")) {
                field.setAccessible(true);
                // 获取某个对象的属性
               Integer a = (Integer) field.get(person);
               int b = a;
                int max = annotation.max();
                int min = annotation.min();
                if (a < min || max < b ) {
                    throw new IllegalArgumentException("参数不正确");
                }
            }
        }
    }
}

}

上面写了一个简单的注解，定义了一个range注解， 然后写了一个checkParam函数，检查这个注解所在的参数是否值超过注解的最大最小值，一旦超过了，那么就抛出异常。
注解本身没有任何作用，配上aop和反射一起使用，就可以有很多的功效。






###参考博客
[https://www.liaoxuefeng.com/wiki/1252599548343744/1265102803921888](https://www.liaoxuefeng.com/wiki/1252599548343744/1265102803921888)