越大的項(xiàng)目滔灶，使用注解就越清晰，代碼可讀性越高吼肥，維護(hù)起來(lái)就越簡(jiǎn)單。簡(jiǎn)單來(lái)說(shuō)麻车，通過(guò)注解缀皱，可以使我們的開(kāi)發(fā)更方便簡(jiǎn)潔，通過(guò)規(guī)范約束我們的編程动猬，避免一些不必要的錯(cuò)誤啤斗，增強(qiáng)代碼的描述性等。缺點(diǎn)就是理解起來(lái)有一定的難度赁咙，別人前期需要花費(fèi)一些時(shí)間來(lái)理解這些注解钮莲。

總體概覽

注解的作用或者意義是什么

注解本身沒(méi)有任何的意義，單獨(dú)的注解就是一種注釋彼水，他需要結(jié)合其他如反射崔拥、注解處理器、插樁等技術(shù)才有意義凤覆。

注解的分類

根據(jù)注解的使用場(chǎng)景链瓦，主要分為三類，元注解、內(nèi)置注解和自定義注解慈俯。

元注解

用于定義注解的注解渤刃，通常用于注解的定義上，標(biāo)明該注解的使用范圍贴膘、生效范圍等卖子。

元數(shù)據(jù)Annotation：包含成員變量的Annotation。默認(rèn)值可用default設(shè)置刑峡。

public @interface MyAno {
    String name() default "angela";
    int age() default 18;
}

使用元數(shù)據(jù)需要設(shè)置默認(rèn)值

@MyAno(name = "范冰冰", age = 15)
public class UserAno {

}

@Retention

指定注解信息保留到哪個(gè)階段洋闽，分別為源代碼階段、編譯Class階段氛琢、運(yùn)行階段喊递。

@Retention包含一個(gè)名為“value”的成員變量，該value成員變量是RetentionPolicy枚舉類型阳似。

1.RetentionPolicy.SOURCE：Annotation只保留在源代碼中骚勘，編譯器編譯時(shí)，直接丟棄這種Annotation撮奏。
2.RetentionPolicy.CLASS：編譯器把Annotation記錄在class文件中俏讹。在編譯時(shí)保存，當(dāng)運(yùn)行Java程序時(shí)畜吊，JVM中不再保留該Annotation泽疆。
3.RetentionPolicy.RUNTIME：編譯器把Annotation記錄在class文件中。當(dāng)運(yùn)行Java程序時(shí)玲献，JVM會(huì)保留該Annotation殉疼，程序可以通過(guò)反射獲取該Annotation的信息。

三種保留級(jí)別應(yīng)用場(chǎng)景：

1.APT處理注解發(fā)生在編譯器捌年。

聲明注解瓢娜，限定參數(shù)傳入類型，注解設(shè)置為源碼級(jí)別礼预。

@IntDef(value = {1, 2, 3, 4, 5})
@Retention(RetentionPolicy.SOURCE)
@Target(ElementType.FIELD)
@interface Type {

}

public void setType(@Type int type) {

}

2.字節(jié)碼增強(qiáng)

說(shuō)人話就是在字節(jié)碼中寫代碼眠砾。

@Target

不設(shè)置target可用于各種類型作為注解，也可同時(shí)設(shè)置多個(gè)target托酸。
指定Annotation用于修飾哪些程序元素褒颈。@Target也包含一個(gè)名為”value“的成員變量ElementType為枚舉類型.

ElementType.TYPE：能修飾類、接口或枚舉類型
ElementType.FIELD：能修飾成員變量
ElementType.METHOD：能修飾方法
ElementType.PARAMETER：能修飾參數(shù)
ElementType.CONSTRUCTOR：能修飾構(gòu)造器
ElementType.LOCAL_VARIABLE：能修飾局部變量
ElementType.ANNOTATION_TYPE：能修飾注解
ElementType.PACKAGE：能修飾包

內(nèi)置注解

######@Documented 
將此注解包含在 javadoc 中 励堡，它代表著此注解會(huì)被javadoc工具提取成文檔谷丸。
 
######@Inherited
指定Annotation具有繼承性。

######@Deprecated 
用于表示某個(gè)程序元素（類念秧、方法等）已過(guò)時(shí) 

######@SuppressWarning
用來(lái)關(guān)閉編譯器輸出的警告信息

示例一：自定義注解簡(jiǎn)單例子：

自定義注解淤井，執(zhí)行在運(yùn)行階段，該注解用于修飾方法

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAnnotation {
    String name();
    int age() default 20;
    String phone();
}

在Person類中的方法里使用自定義注解，并設(shè)置初始值

public class Person {

    @MyAnnotation(name = "小王",age = 25,phone = "110")
    public void getInfo() {

    }

    public static void getAnnoValue() {
        try {
            MyAnnotation myAnnotation = Person.class.getMethod("getInfo").getAnnotation(MyAnnotation.class);
            System.out.println(myAnnotation.name() + "  " + myAnnotation.age() + "   " + myAnnotation.phone());
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        }
    }
}

使用反射操作注解實(shí)戰(zhàn)

定義一個(gè)注解的注解币狠，再定義一個(gè)能用在各種元素上的注解

/**
 * 定義target是注解的注解
 */
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
@interface AnnoTest {
    String value() default "anno";
}

/**
 * 定義一個(gè)幾乎全量信息的注解
 */
@AnnoTest("annotest")
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE_USE, ElementType.FIELD, ElementType.TYPE, ElementType.METHOD,
        ElementType.PACKAGE, ElementType.PARAMETER, ElementType.CONSTRUCTOR, ElementType.LOCAL_VARIABLE})
@Documented
@interface FullAnnoTest {
    String value() default "FullAnnoTest";
}

測(cè)試類和反射代碼:在各種元素前添加FullAnnoTest注解和對(duì)應(yīng)的value值游两，然后通過(guò)反射獲取各處的注解value。

class ParentObj {
}

@FullAnnoTest("class")
public class TestAnnoReflect<@FullAnnoTest("parameter") T> extends @FullAnnoTest("parent") ParentObj {

    //注解字段域
    private @FullAnnoTest("name") String name;

    //注解泛型字段域
    private @FullAnnoTest("value") T value;

    //注解通配符
    private @FullAnnoTest("list") List<@FullAnnoTest("generic") ?> list;

    @FullAnnoTest("constructor")
    public TestAnnoReflect() {
    }

    //注解方法
    @FullAnnoTest("method")             //注解方法參數(shù)
    public String hello(@FullAnnoTest("methodParameter") String name) throws @FullAnnoTest("Exception") Exception {  //注解異常拋出
        //注解局部變量
        @FullAnnoTest("result") String result;
        result = "result";
        System.out.println(result);
        return result;
    }

    @RequiresApi(api = Build.VERSION_CODES.O)
    public static void testAnnotation() throws NoSuchMethodException {
        TestAnnoReflect<String> testAnnoReflect = new TestAnnoReflect<>();
        Class<TestAnnoReflect<Object>> clazz = (Class<TestAnnoReflect<Object>>) testAnnoReflect.getClass();

        FullAnnoTest annotation;
        Field[] fields = clazz.getDeclaredFields();
        Annotation[] annotations = clazz.getAnnotations();

        //獲取class的注解
        annotation = (FullAnnoTest)annotations[0];
        System.out.println("修飾TestAnnoReflect類的注解value: " + annotation.value());

        //獲取構(gòu)造器的 注解
        Constructor<TestAnnoReflect<Object>> constructor = (Constructor<TestAnnoReflect<Object>>) clazz.getDeclaredConstructors()[0];
        annotation = constructor.getAnnotation(FullAnnoTest.class);
        System.out.println("構(gòu)造器的注解value: " + annotation.value());

        //獲取注解的 注解
        Class<? extends Annotation> annotationType = annotation.annotationType();
        AnnoTest annoTest = annotationType.getAnnotation(AnnoTest.class);
        System.out.println("修飾注解的注解AnnoTest-value: " + annoTest.value());

        //獲取方法的 注解
        Method method = clazz.getDeclaredMethod("hello", String.class);
        annotation = method.getAnnotation(FullAnnoTest.class);
        System.out.println("修飾方法的注解value: " + annotation.value());

        //獲取方法參數(shù)的 注解
        Parameter parameter = method.getParameters()[0];
        annotation = parameter.getAnnotation(FullAnnoTest.class);
        System.out.println("方法參數(shù)的注解value: " + annotation.value());

        //獲取方法拋出的異常上的 注解
        Class<?>[] exceptionTypes = method.getExceptionTypes();
        for (Class<?> exceptionType: exceptionTypes) {
            annotation = exceptionType.getAnnotation(FullAnnoTest.class);
            if (annotation != null) {
                System.out.println("方法拋出的異常上的注解value: " + annotation.value());
            }
        }

        //獲取包的 注解
        Package p = Package.getPackage("com.example.genericannotaionreflect.annotate");
        annotation = p.getAnnotation(FullAnnoTest.class);
        if (annotation != null) {
            System.out.println("修飾package的注解value: " + annotation.value());
        }

        //獲取各個(gè)屬性的注解 和 屬性類型的通配符注解漩绵，即 List<@FullAnnoTest("generic") ?>的注解
        for (Field field : fields) {
            FullAnnoTest fieldAnnotation = field.getAnnotation(FullAnnoTest.class);
            if (fieldAnnotation != null) {
                System.out.println("Field " + field.getName() + " Annotation Value: " + fieldAnnotation.value());

                // 獲取字段的泛型類型
                Type genericType = field.getGenericType();
                if (genericType instanceof ParameterizedType) {
                    ParameterizedType parameterizedType = (ParameterizedType) genericType;

                    // 獲取泛型參數(shù)的實(shí)際類型
                    Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
                    for (Type typeArgument : actualTypeArguments) {
                        if (typeArgument instanceof Class) {
                            Class<?> genericClass = (Class<?>) typeArgument;

                            // 獲取泛型參數(shù)上的注解
                            FullAnnoTest genericAnnotation = genericClass.getAnnotation(FullAnnoTest.class);
                            if (genericAnnotation != null) {
                                System.out.println("Generic Type Annotation Value: " + genericAnnotation.value());
                            }
                        }
                    }
                }
            }
        }
    }

}

打蛹浮：

修飾TestAnnoReflect類的注解value: class
構(gòu)造器的注解value: constructor
修飾注解的注解AnnoTest-value: annotest
修飾方法的注解value: method
方法參數(shù)的注解value: methodParameter
Field list Annotation Value: list
Field name Annotation Value: name
Field value Annotation Value: value
Generic Type Annotation Value: generic

其中用到field的泛型獲取技術(shù)：

field.getGenericType()方法：
getGenericType()是Field接口的一個(gè)方法，它返回一個(gè)Type對(duì)象止吐，表示字段的通用類型宝踪，包括泛型信息。
可能是Class碍扔、ParameterizedType瘩燥、GenericArrayType等，例如List<String> list不同，list屬性的getGenericType()得到的是List<String>類型的Type厉膀。

• Class類型 表示普通類型

• ParameterizedType 表示一個(gè)參數(shù)化類型，即帶有實(shí)際類型參數(shù)的泛型類型二拐。 對(duì)于 List<String>服鹅，Map<Integer, String> 等，它們都屬于 ParameterizedType百新。

• GenericArrayType 表示數(shù)組類型企软，其中的元素類型是參數(shù)化類型或者是類型變量。對(duì)于 List<String>[] 或者 T[]（其中 T 是類型變量）饭望，它們都屬于 GenericArrayType仗哨。

getActualTypeArguments()方法
是ParameterizedType接口的一個(gè)方法，用于獲取泛型類型的實(shí)際類型參數(shù)铅辞。在Java中藻治，泛型類型通常指的是參數(shù)化類型，比如List<String>巷挥，其中List是泛型類型，而String是它的實(shí)際類型參數(shù)验靡，該方法返回的是數(shù)組倍宾。

• 使用注解來(lái)代替枚舉類

雖然推薦使用枚舉類替代一些int常量，但是在android中胜嗓，官方還是不建議使用枚舉類的：

Enums often require more than twice as much memory as static constants. You should strictly avoid using enums on Android.

由官網(wǎng)的描述可知高职，枚舉類還是很耗費(fèi)內(nèi)存的，所以更加優(yōu)雅的方式應(yīng)該是使用注解的形式辞州。官方使用兩個(gè)注解類浆洗，IntDef和StringDef,用來(lái)提供枚舉的替代方案荞彼。

class OrderState {

    companion object {
        //Android端制定訂單狀態(tài)翠胰，分別為全部迈螟，待支付， 待提貨袋毙， 已完成， 已取消
        const val ALL = 0
        const val WAIT_PAY = 1
        const val WAIT_DILIVERY = 2
        const val COMPLETED = 3
        const val CANCELLED = 4

        /**
         * 根據(jù)訂單列表頁(yè)獲取訂單頁(yè)請(qǐng)求狀態(tài)
         */
        fun getOrderListStatus(@OrderState status: Int): Int = when (status) {
            ALL ->
                ...
            WAIT_PAY ->
                ...
            WAIT_DILIVERY ->
                ...
            COMPLETED ->
                ...
            CANCELLED ->
                ...
            else -> STATUS_ALL
        }
    }

    @IntDef(ALL, WAIT_PAY, WAIT_DILIVERY, COMPLETED, CANCELLED)
    @Retention(RetentionPolicy.SOURCE)
    internal annotation class OrderState
}

注解的本質(zhì)

public interface Annotation {
    boolean equals(Object obj);
    int hashCode();
    String toString();
    /**
     * Returns the annotation type of this annotation.
     * @return the annotation type of this annotation
     */
    Class<? extends Annotation> annotationType();
}

注解本質(zhì)上它是繼承自Annotation的一個(gè)接口。但我們是可以通過(guò)反射拿到Annotation實(shí)例的阔拳，實(shí)際上，我們?cè)谶\(yùn)行期獲取到的注解类嗤，都是接口的代理類糊肠。

注解的實(shí)際過(guò)程：

? 注解實(shí)質(zhì)上會(huì)被編譯器編譯為接口，并且繼承java.lang.annotation.Annotation接口遗锣。
? 注解的成員變量會(huì)被編譯器編譯為同名的抽象方法货裹。
? 根據(jù)Java的class文件規(guī)范，class文件中會(huì)在程序元素的屬性位置記錄注解信息精偿。

Kotlin注解與Java注解有什么不同弧圆？

Kotlin 的注解完全兼容 Java 的注解。

參考：
https://developer.aliyun.com/article/1114687

Github代碼地址：

https://github.com/running-libo/GenericAnnotationReflect