• java 注解 Annontation


    什么是注解?

      对于很多初次接触的开发者来说应该都有这个疑问?Annontation是Java5开始引入的新特征,中文名称叫注解。它提供了一种安全的类似注释的机制,用来将任何的信息或元数据(metadata)与程序元素(类、方法、成员变量等)进行关联。为程序的元素(类、方法、成员变量)加上更直观更明了的说明,这些说明信息是与程序的业务逻辑无关,并且供指定的工具或框架使用。Annontation像一种修饰符一样,应用于包、类型、构造方法、方法、成员变量、参数及本地变量的声明语句中。
      Java注解是附加在代码中的一些元信息,用于一些工具在编译、运行时进行解析和使用,起到说明、配置的功能。注解不会也不能影响代码的实际逻辑,仅仅起到辅助性的作用。包含在 java.lang.annotation 包中。

    注解的用处:

          1、生成文档。这是最常见的,也是java 最早提供的注解。常用的有@param @return 等
          2、跟踪代码依赖性,实现替代配置文件功能。比如Dagger 2 依赖注入,未来java 开发,将大量注解配置,具有很大用处;
          3、在编译时进行格式检查。如@override 放在方法前,如果你这个方法并不是覆盖了超类方法,则编译时就能检查出。

    注解的原理:

      注解本质是一个继承了Annotation 的特殊接口,其具体实现类是Java 运行时生成的动态代理类。而我们通过反射获取注解时,返回的是Java 运行时生成的动态代理对象$Proxy1。通过代理对象调用自定义注解(接口)的方法,会最终调用AnnotationInvocationHandler 的invoke 方法。该方法会从memberValues 这个Map 中索引出对应的值。而memberValues 的来源是Java 常量池。

    元注解:

    java.lang.annotation 提供了四种元注解,专门注解其他的注解(在自定义注解的时候,需要使用到元注解):
       @Documented – 注解是否将包含在JavaDoc中
       @Retention – 什么时候使用该注解
       @Target – 注解用于什么地方
       @Inherited – 是否允许子类继承该注解

      1.)@Retention – 定义该注解的生命周期
      ●   RetentionPolicy.SOURCE : 在编译阶段丢弃。这些注解在编译结束之后就不再有任何意义,所以它们不会写入字节码。@Override, @SuppressWarnings都属于这类注解。
      ●   RetentionPolicy.CLASS : 在类加载的时候丢弃。在字节码文件的处理中有用。注解默认使用这种方式
      ●   RetentionPolicy.RUNTIME : 始终不会丢弃,运行期也保留该注解,因此可以使用反射机制读取该注解的信息。我们自定义的注解通常使用这种方式。

      2.)Target – 表示该注解用于什么地方。默认值为任何元素,表示该注解用于什么地方。可用的ElementType 参数包括
      ● ElementType.CONSTRUCTOR: 用于描述构造器
      ● ElementType.FIELD: 成员变量、对象、属性(包括enum实例)
      ● ElementType.LOCAL_VARIABLE: 用于描述局部变量
      ● ElementType.METHOD: 用于描述方法
      ● ElementType.PACKAGE: 用于描述包
      ● ElementType.PARAMETER: 用于描述参数
      ● ElementType.TYPE: 用于描述类、接口(包括注解类型) 或enum声明

     3.)@Documented – 一个简单的Annotations 标记注解,表示是否将注解信息添加在java 文档中。

     4.)@Inherited – 定义该注释和子类的关系
         @Inherited 元注解是一个标记注解,@Inherited 阐述了某个被标注的类型是被继承的。如果一个使用了@Inherited 修饰的annotation 类型被用于一个class,则这个annotation 将被用于该class 的子类。

    常见标准的Annotation:

      1.)Override
          java.lang.Override 是一个标记类型注解,它被用作标注方法。它说明了被标注的方法重载了父类的方法,起到了断言的作用。如果我们使用了这种注解在一个没有覆盖父类方法的方法时,java 编译器将以一个编译错误来警示。
      2.)Deprecated
         Deprecated 也是一种标记类型注解。当一个类型或者类型成员使用@Deprecated 修饰的话,编译器将不鼓励使用这个被标注的程序元素。所以使用这种修饰具有一定的“延续性”:如果我们在代码中通过继承或者覆盖的方式使用了这个过时的类型或者成员,虽然继承或者覆盖后的类型或者成员并不是被声明为@Deprecated,但编译器仍然要报警。
     3.)SuppressWarnings
         SuppressWarning 不是一个标记类型注解。它有一个类型为String[] 的成员,这个成员的值为被禁止的警告名。对于javac 编译器来讲,被-Xlint 选项有效的警告名也同样对@SuppressWarings 有效,同时编译器忽略掉无法识别的警告名。
      @SuppressWarnings("unchecked")

    自定义注解:

    自定义注解类编写的一些规则:
      1. Annotation 型定义为@interface, 所有的Annotation 会自动继承java.lang.Annotation这一接口,并且不能再去继承别的类或是接口.
      2. 参数成员只能用public 或默认(default) 这两个访问权修饰
      3. 参数成员只能用基本类型byte、short、char、int、long、float、double、boolean八种基本数据类型和String、Enum、Class、annotations等数据类型,以及这一些类型的数组.
      4. 要获取类方法和字段的注解信息,必须通过Java的反射技术来获取 Annotation 对象,因为你除此之外没有别的获取注解对象的方法
      5. 注解也可以没有定义成员,,不过这样注解就没啥用了
    PS:自定义注解需要使用到元注解

    自定义注解实例:

    FruitName.java

    import java.lang.annotation.Documented;
    import java.lang.annotation.Retention;
    import java.lang.annotation.Target;
    import static java.lang.annotation.ElementType.FIELD;
    import static java.lang.annotation.RetentionPolicy.RUNTIME;
    
    /**
     * 水果名称注解
     */
    @Target(FIELD)
    @Retention(RUNTIME)
    @Documented
    public @interface FruitName {
        String value() default "";
    }

    FruitColor.java

    import java.lang.annotation.Documented;
    import java.lang.annotation.Retention;
    import java.lang.annotation.Target;
    import static java.lang.annotation.ElementType.FIELD;
    import static java.lang.annotation.RetentionPolicy.RUNTIME;
    
    /**
     * 水果颜色注解
     */
    @Target(FIELD)
    @Retention(RUNTIME)
    @Documented
    public @interface FruitColor {
        /**
         * 颜色枚举
         */
        public enum Color{ BLUE,RED,GREEN};
        
        /**
         * 颜色属性
         */
        Color fruitColor() default Color.GREEN;
    
    }

    FruitProvider.java

    import java.lang.annotation.Documented;
    import java.lang.annotation.Retention;
    import java.lang.annotation.Target;
    import static java.lang.annotation.ElementType.FIELD;
    import static java.lang.annotation.RetentionPolicy.RUNTIME;
    
    
    /**
     * 水果供应者注解
     */
    @Target(FIELD)
    @Retention(RUNTIME)
    @Documented
    public @interface FruitProvider {
        /**
         * 供应商编号
         */
        public int id() default -1;
        
        /**
         * 供应商名称
         */
        public String name() default "";
        
        /**
         * 供应商地址
         */
        public String address() default "";
    }

    FruitInfoUtil.java

    import java.lang.reflect.Field;
    
    /**
     * 注解处理器
     */
    public class FruitInfoUtil {
        public static void getFruitInfo(Class<?> clazz){
            
            String strFruitName=" 水果名称:";
            String strFruitColor=" 水果颜色:";
            String strFruitProvicer="供应商信息:";
            
            Field[] fields = clazz.getDeclaredFields();
            
            for(Field field :fields){
                if(field.isAnnotationPresent(FruitName.class)){
                    FruitName fruitName = (FruitName) field.getAnnotation(FruitName.class);
                    strFruitName=strFruitName+fruitName.value();
                    System.out.println(strFruitName);
                }
                else if(field.isAnnotationPresent(FruitColor.class)){
                    FruitColor fruitColor= (FruitColor) field.getAnnotation(FruitColor.class);
                    strFruitColor=strFruitColor+fruitColor.fruitColor().toString();
                    System.out.println(strFruitColor);
                }
                else if(field.isAnnotationPresent(FruitProvider.class)){
                    FruitProvider fruitProvider= (FruitProvider) field.getAnnotation(FruitProvider.class);
                    strFruitProvicer=" 供应商编号:"+fruitProvider.id()+" 供应商名称:"+fruitProvider.name()+" 供应商地址:"+fruitProvider.address();
                    System.out.println(strFruitProvicer);
                }
            }
        }
    }

    Apple.java

    import test.FruitColor.Color;
    
    /**
     * 注解使用
     */
    public class Apple {
        
        @FruitName("Apple")
        private String appleName;
        
        @FruitColor(fruitColor=Color.RED)
        private String appleColor;
        
        @FruitProvider(id=1,name="陕西红富士集团",address="陕西省西安市延安路89号红富士大厦")
        private String appleProvider;
        
        public void setAppleColor(String appleColor) {
            this.appleColor = appleColor;
        }
        public String getAppleColor() {
            return appleColor;
        }
        
        public void setAppleName(String appleName) {
            this.appleName = appleName;
        }
        public String getAppleName() {
            return appleName;
        }
        
        public void setAppleProvider(String appleProvider) {
            this.appleProvider = appleProvider;
        }
        public String getAppleProvider() {
            return appleProvider;
        }
        
        public void displayName(){
            System.out.println("水果的名字是:苹果");
        }
    }

    FruitRun.java

    /**
     * 输出结果
     */
    public class FruitRun {
        public static void main(String[] args) {
            FruitInfoUtil.getFruitInfo(Apple.class);
        }
    }

    运行结果是:

     水果名称:Apple
     水果颜色:RED
     供应商编号:1 供应商名称:陕西红富士集团 供应商地址:陕西省西安市延安路89号红富士大厦

     转自:https://www.cnblogs.com/acm-bingzi/p/javaAnnotation.html


    另一篇:框架开发之Java注解的妙用

    注解的好处:

    • 1.能够读懂别人写的代码,特别是框架相关的代码。
    • 2.本来可能需要很多配置文件,需要很多逻辑才能实现的内容,就可以使用一个或者多个注解来替代,这样就使得编程更加简洁,代码更加清晰。
    • 3.(重点)刮目相看。
    • (但是怎么样才能让别人刮目相看呢?会用注解不是目的,最重要的是要使用自定义注解来解决问题。)

    举个栗子:
    如果面试的时候,你跟老板说你会使用注解,老板觉得你这个人还行;但是如果老板发现你会自定义注解解决问题,老板肯定就会眼前一亮。

    注解这一概念是在java1.5版本提出的,说Java提供了一种原程序中的元素关联任何信息和任何元数据的途径的方法。

    一、Java中的常见注解

    1)JDK注解
       JDK注解一共分为三类:

     
                      JDK注解.png

    案例:
    我们先新建一个接口people,如下:

    public interface people {
        public String name();
        public int age();
        public void work();
    }

    然后再建一个类Child实现类people这个接口,并实现该类的方法:

    public class Child implements people {
        @Override
        public String name() {
            return null;
        }
    
        @Override
        public int age() {
            return 0;
        }
    
        @Override
        public void work() {
    
        }
    }
    看到这里,我们发现这里的所有方法都会加上一个@Override标记,它告诉我们,同时也告诉编译器我们的这些方法肯定覆盖了类people里面的方法的。假如说,我现在把类people里面的某一个方法注释掉:
    //public String name();

        再看类Child里面的name方法就会报错。这样,以后大家看到@Override的时候就能想到这个方法是覆盖了某个接口的方法的。

        然后,我们回过头来看类people里面有一个work的方法。这里我们可以理解为人是要工作的,但是并不是所有的人都在工作,那么怎么办呢?如果说这个接口正在用,我们不能删除这个方法,这个时候我们就可以这样:

    @Deprecated
    public void work();

    @Deprecated标记就表明这个方法已经过时了,在实际中,它又有什么样的应用场景呢?我们在建一个测试类:

    public class Test {
        public void work() {
            people people=new Child();
    !       people.work();
        }
    }
         这个时候我们会发现myeclipse会给一个警告,并且在work中间出现一个破折号,意思就是这个方法已经过时了。那么问题来了,虽然这个方法过时了,但是我们就是那么傲娇,一定要用它,怎么办呢?只需要这样:
    public class Test {
        @SuppressWarnings("deprecation")
        public void work() {
            people people=new Child();
            people.work();
        }
    }

    这样我们就忽略了这个警告。@SuppressWarnings("deprecation")就表示我们忽略了deprecation这样的一个警告。

    2)Java第三方注解

     
    第三方注解.png

    二、注解的分类

    1)按照运行机制划分:
    【源码注解→编译时注解→运行时注解】

      源码注解:只在源码中存在,编译成.class文件就不存在了。

      编译时注解:在源码和.class文件中都存在。像前面的@Override、@Deprecated、@SuppressWarnings,他们都属于编译时注解。

      运行时注解:在运行阶段还起作用,甚至会影响运行逻辑的注解。像@Autowired自动注入的这样一种注解就属于运行时注解,它会在程序运行的时候把你的成员变量自动的注入进来。

    2)按照来源划分:
      【来自JDK的注解——来自第三方的注解——自定义注解】

    3)元注解:
      元注解是给注解进行注解,可以理解为注解的注解就是元注解。

    三、自定义注解

    我们分四步来解析自定义注解:
    自定义注解的语法要求:

    @Target({ElementType.METHOD,ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Inherited
    @Documented
    public @interface Description {
        String desc();
        String author();
        int age() default 18;
    }

    首先我们要明确这不是一个接口,它是使用@interface关键字定义的一个注解。
    然后我们看下面的几个方法,String desc();虽然它很类似于接口里面的方法,其实它在注解里面只是一个成员变量(成员以无参无异常的方式声明),int age() default 18;(成员变量可以用default指定一个默认值的)。
    最后我们要知道:
      ①.成员类型是受限制的,合法的类型包括基本的数据类型以及String,Class,Annotation,Enumeration等。
      ②.如果注解只有一个成员,则成员名必须取名为value(),在使用时可以忽略成员名和赋值号(=)。
      ③.注解类可以没有成员,没有成员的注解称为标识注解。

    元注解:

    有没有发现上面那段代码有一个没有说呢?没错,它们就是我们所说的元注解:

    @Target({ElementType.METHOD,ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Inherited
    @Documented

    我们先看第一行:@Target是这个注解的作用域,ElementType.METHOD是这个注解的作用域的列表,METHOD是方法声明,除此之外,还有:
    CONSTRUCTOR(构造方法声明),FIELD(字段声明),LOCAL VARIABLE(局部变量声明),METHOD(方法声明),PACKAGE(包声明),PARAMETER(参数声明),TYPE(类接口)

    第二行:@Retention是它的生命周期,前面不是说注解按照运行机制有一个分类嘛,RUNTIME就是在运行时存在,可以通过反射读取。除此之外,还有:
    SOURCE(只在源码显示,编译时丢弃),CLASS(编译时记录到class中,运行时忽略),RUNTIME(运行时存在,可以通过反射读取)

    第三行:@Inherited是一个标识性的元注解,它允许子注解继承它。

    第四行:@Documented,生成javadoc时会包含注解。

    使用自定义注解:
    使用注解的语法:
    @<注解名>(<成员名1>=<成员值1>,<成员名1>=<成员值1>,...)
    案例:

        @Description(desc="i am Color",author="boy",age=18)
        public String Color() {
            return "red";
        }

      这里的Description是我们刚才在自定义注解语法要求里面定义的注解噢,然后我们可以给它的每一个成员变量赋值,注意数据类型。值得注意的是,因为我们前面定义的作用域是在方法和类接口上,所以这个注解在Color()方法上使用是没问题的。

    解析注解
    概念:
      通过反射获取类 、函数或成员上的运行时注解信息,从而实现动态控制程序运行的逻辑。

    准备工作:

     
                Description类.png
     
                  Child类.png

    接下来,我们就开始测试了:

    public class ParseAnn {
        public static void main(String[] args) {
            try {
                // 使用类加载器加载类
                Class c = Class.forName("com.test.Child");
                // 找到类上面的注解
                boolean isExist = c.isAnnotationPresent(Description.class);
                // 上面的这个方法是用这个类来判断这个类是否存在Description这样的一个注解
                if (isExist) {
                    // 拿到注解实例,解析类上面的注解
                    Description d = (Description) c.getAnnotation(Description.class);
                    System.out.println(d.value());
                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }

    输出的结果:
    i am class annotation
    可以看到,我们成功的解析了Child类上面的注解。

    接下来,我们继续解析方法上的注解:

                //获取所有的方法
                Method[] ms = c.getMethods();
                // 遍历所有的方法
                for (Method m : ms) {
                    boolean isExist1 = m.isAnnotationPresent(Description.class);
                    if (isExist1) {
                        Description d1=m.getAnnotation(Description.class);
                        System.out.println(d1.value());
                    }
                }

    输出的结果:
    i am class annotation
    i am method annotation
    可以看到,我们成功的解析了方法上面的注解。

                //另一种解析方法
                for (Method m : ms) {
                    //拿到方法上的所有的注解
                    Annotation[] as=m.getAnnotations();
                    for (Annotation a : as) {
                        //用二元操作符判断a是否是Description的实例
                        if (a instanceof Description) {
                            Description d=(Description) a;
                            System.out.println(d.value());
                        }
                    }
                }

    也可以得到上面的效果。

    此时,如果把Description类里面的元注解改一下,比如:
    @Retention(RetentionPolicy.RUNTIME)→@Retention(RetentionPolicy.SOURCE),再运行程序,结果会成怎样呢?如果改成CLASS呢?读者们要不要试一试?

    如果看过我写的《谈谈JAVA反射机制》——Class类的动态加载的读者,仔细想一下我们这个环境,就知道为什么了。

     
  • 相关阅读:
    小组自评、互评及反馈
    "一个程序员的生命周期"读后感
    阅读《构建之法》第10-12章
    阅读《构建之法》第8,9,10章
    冒泡算法程序分析树的评论
    1014 C语言文法定义与C程序的推导过程
    0917 实验一词法分析程序
    0909 我与编译原理不得不说的秘密
    复利计算器4
    复利及单利计算
  • 原文地址:https://www.cnblogs.com/myseries/p/10862074.html
Copyright © 2020-2023  润新知