深入理解Java注解

越大的项目,使用注解就越清晰,代码可读性越高,维护起来就越简单。简单来说,通过注解,可以使我们的开发更方便简洁,通过规范约束我们的编程,避免一些不必要的错误,增强代码的描述性等。缺点就是理解起来有一定的难度,别人前期需要花费一些时间来理解这些注解。

总体概览
注解的作用或者意义是什么

注解本身没有任何的意义,单独的注解就是一种注释,他需要结合其他如反射、注解处理器、插桩等技术才有意义。

注解的分类

根据注解的使用场景,主要分为三类,元注解、内置注解和自定义注解。

元注解

用于定义注解的注解,通常用于注解的定义上,标明该注解的使用范围、生效范围等。

元数据Annotation:包含成员变量的Annotation。默认值可用default设置。
public @interface MyAno {
    String name() default "angela";
    int age() default 18;
}

使用元数据需要设置默认值

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

}
@Retention

指定注解信息保留到哪个阶段,分别为源代码阶段、编译Class阶段、运行阶段。

@Retention包含一个名为“value”的成员变量,该value成员变量是RetentionPolicy枚举类型。

1.RetentionPolicy.SOURCE:Annotation只保留在源代码中,编译器编译时,直接丢弃这种Annotation。
2.RetentionPolicy.CLASS:编译器把Annotation记录在class文件中。在编译时保存,当运行Java程序时,JVM中不再保留该Annotation。
3.RetentionPolicy.RUNTIME:编译器把Annotation记录在class文件中。当运行Java程序时,JVM会保留该Annotation,程序可以通过反射获取该Annotation的信息。

三种保留级别应用场景:
1.APT处理注解发生在编译器。
声明注解,限定参数传入类型,注解设置为源码级别。
@IntDef(value = {1, 2, 3, 4, 5})
@Retention(RetentionPolicy.SOURCE)
@Target(ElementType.FIELD)
@interface Type {

}

public void setType(@Type int type) {

}
2.字节码增强

说人话就是在字节码中写代码。

@Target

不设置target可用于各种类型作为注解,也可同时设置多个target。
指定Annotation用于修饰哪些程序元素。@Target也包含一个名为”value“的成员变量ElementType为枚举类型.

ElementType.TYPE:能修饰类、接口或枚举类型
ElementType.FIELD:能修饰成员变量
ElementType.METHOD:能修饰方法
ElementType.PARAMETER:能修饰参数
ElementType.CONSTRUCTOR:能修饰构造器
ElementType.LOCAL_VARIABLE:能修饰局部变量
ElementType.ANNOTATION_TYPE:能修饰注解
ElementType.PACKAGE:能修饰包

内置注解
######@Documented 
将此注解包含在 javadoc 中 ,它代表着此注解会被javadoc工具提取成文档。
 
######@Inherited
指定Annotation具有继承性。

######@Deprecated 
用于表示某个程序元素(类、方法等)已过时 

######@SuppressWarning
用来关闭编译器输出的警告信息
示例一:自定义注解简单例子:

自定义注解,执行在运行阶段,该注解用于修饰方法

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

在Person类中的方法里使用自定义注解,并设置初始值

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);
        }
    }
}
使用反射操作注解实战

定义一个注解的注解,再定义一个能用在各种元素上的注解

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

/**
 * 定义一个几乎全量信息的注解
 */
@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";
}

测试类和反射代码:在各种元素前添加FullAnnoTest注解和对应的value值,然后通过反射获取各处的注解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")             //注解方法参数
    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());

        //获取构造器的 注解
        Constructor<TestAnnoReflect<Object>> constructor = (Constructor<TestAnnoReflect<Object>>) clazz.getDeclaredConstructors()[0];
        annotation = constructor.getAnnotation(FullAnnoTest.class);
        System.out.println("构造器的注解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());

        //获取方法参数的 注解
        Parameter parameter = method.getParameters()[0];
        annotation = parameter.getAnnotation(FullAnnoTest.class);
        System.out.println("方法参数的注解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());
        }

        //获取各个属性的注解 和 属性类型的通配符注解,即 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;

                    // 获取泛型参数的实际类型
                    Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
                    for (Type typeArgument : actualTypeArguments) {
                        if (typeArgument instanceof Class) {
                            Class<?> genericClass = (Class<?>) typeArgument;

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

}

打印:

修饰TestAnnoReflect类的注解value: class
构造器的注解value: constructor
修饰注解的注解AnnoTest-value: annotest
修饰方法的注解value: method
方法参数的注解value: methodParameter
Field list Annotation Value: list
Field name Annotation Value: name
Field value Annotation Value: value
Generic Type Annotation Value: generic
其中用到field的泛型获取技术:

field.getGenericType()方法:
getGenericType()是Field接口的一个方法,它返回一个Type对象,表示字段的通用类型,包括泛型信息。
可能是Class、ParameterizedType、GenericArrayType等,例如List<String> list,list属性的getGenericType()得到的是List<String>类型的Type。

  • Class类型 表示普通类型

  • ParameterizedType 表示一个参数化类型,即带有实际类型参数的泛型类型。 对于 List<String>,Map<Integer, String> 等,它们都属于 ParameterizedType。

  • GenericArrayType 表示数组类型,其中的元素类型是参数化类型或者是类型变量。对于 List<String>[] 或者 T[](其中 T 是类型变量),它们都属于 GenericArrayType。

getActualTypeArguments()方法
是ParameterizedType接口的一个方法,用于获取泛型类型的实际类型参数。在Java中,泛型类型通常指的是参数化类型,比如List<String>,其中List是泛型类型,而String是它的实际类型参数,该方法返回的是数组。

  • 使用注解来代替枚举类

虽然推荐使用枚举类替代一些int常量,但是在android中,官方还是不建议使用枚举类的:

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

由官网的描述可知,枚举类还是很耗费内存的,所以更加优雅的方式应该是使用注解的形式。官方使用两个注解类,IntDef和StringDef,用来提供枚举的替代方案。

class OrderState {

    companion object {
        //Android端制定订单状态,分别为全部,待支付, 待提货, 已完成, 已取消
        const val ALL = 0
        const val WAIT_PAY = 1
        const val WAIT_DILIVERY = 2
        const val COMPLETED = 3
        const val CANCELLED = 4

        /**
         * 根据订单列表页获取订单页请求状态
         */
        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
}
注解的本质
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();
}

注解本质上它是继承自Annotation的一个接口。但我们是可以通过反射拿到Annotation实例的,实际上,我们在运行期获取到的注解,都是接口的代理类。

注解的实际过程:

• 注解实质上会被编译器编译为接口,并且继承java.lang.annotation.Annotation接口。
• 注解的成员变量会被编译器编译为同名的抽象方法。
• 根据Java的class文件规范,class文件中会在程序元素的属性位置记录注解信息。

Kotlin注解与Java注解有什么不同?

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

参考:
https://developer.aliyun.com/article/1114687

Github代码地址:

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

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 213,254评论 6 492
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 90,875评论 3 387
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 158,682评论 0 348
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 56,896评论 1 285
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 66,015评论 6 385
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 50,152评论 1 291
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 39,208评论 3 412
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 37,962评论 0 268
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 44,388评论 1 304
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,700评论 2 327
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,867评论 1 341
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 34,551评论 4 335
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 40,186评论 3 317
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,901评论 0 21
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,142评论 1 267
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 46,689评论 2 362
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 43,757评论 2 351

推荐阅读更多精彩内容

  • 什么是注解(Annotation):Annotation(注解)就是Java提供了一种元程序中的元素关联任何信息和...
    九尾喵的薛定谔阅读 3,151评论 0 2
  • 本文章涉及代码已放到github上annotation-study 1.Annotation为何而来 What:A...
    zlcook阅读 29,131评论 15 116
  • 从JDK5开始,Java增加了Annotation(注解),Annotation是代码里的特殊标记,这些标记可以在...
    CarlosLynn阅读 554评论 0 2
  • 从JDK5开始,Java增加了Annotation(注解),Annotation是代码里的特殊标记,这些标记可以在...
    lay_wn阅读 843评论 0 1
  • java自定义注解 Java注解是附加在代码中的一些元信息,用于一些工具在编译、运行时进行解析和使用,起到说明、配...
    尼尔君阅读 516评论 0 0