Android知识程序员Android开发

注解-你可能需要知道这些

2017-09-28  本文已影响0人  24K男

在日常的开发工作中，尤其是在使用一些比较受欢迎的开源框架时，我们不可避免的都使用到了注解（Annotation），注解的使用范围也越来越广，而且在使用了注解后，我们的代码看起来也更简洁了。
本博文就带大家来分析和学习下注解，并简单分析下注解的在各种框架中的实现。

1. 什么是注解？

Java Annotation是JDK 5.0引入的一种解释机制。
我们日常开发中最常见的注解恐怕就是@Override的了，它代表我们的方法是重写的。
我们来看下@Override是如何定义的：

//使用在方法上
@Target(ElementType.METHOD)
// 该注解只在.java文件中存在，编译后的.class文件中是不存在的
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

注解的定义使用关键字：@interface，有点像我们定义接口。

在定义Override注解时，又使用了一些其他的注解(@Target@Retention)，这些注解被称为元注解，是自定义注解的基础和关键点。

2. 元注解

元注解是用来定义其他注解的注解，是不是觉得很费解，不要着急，我们来大家来认识下我们常用的元注解。

2.1 @Retention-Annotation能活多久

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Retention {
    RetentionPolicy value();
}


public enum RetentionPolicy {
    /**
     * Annotations are to be discarded by the compiler.
     */
    SOURCE,

    /**
     * Annotations are to be recorded in the class file by the compiler
     * but need not be retained by the VM at run time.  This is the default
     * behavior.
     */
    CLASS,

    /**
     * Annotations are to be recorded in the class file by the compiler and
     * retained by the VM at run time, so they may be read reflectively.
     *
     * @see java.lang.reflect.AnnotatedElement
     */
    RUNTIME
}

@Retention表示Annotation作用范围和保留时间，如果未标注则默认使用CLASS。取值范围如下：

2.2 @Target-Annotation能勾搭谁

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
    ElementType[] value();
}

public enum ElementType {
    /** Class, interface (including annotation type), or enum declaration */
    TYPE,

    /** Field declaration (includes enum constants) */
    FIELD,

    /** Method declaration */
    METHOD,

    /** Formal parameter declaration */
    PARAMETER,

    /** Constructor declaration */
    CONSTRUCTOR,

    /** Local variable declaration */
    LOCAL_VARIABLE,

    /** Annotation type declaration */
    ANNOTATION_TYPE,

    /** Package declaration */
    PACKAGE,

    /**
     * Type parameter declaration
     *
     * @since 1.8
     * @hide 1.8
     */
    TYPE_PARAMETER,

    /**
     * Use of a type
     *
     * @since 1.8
     * @hide 1.8
     */
    TYPE_USE
}

@Target表示Annotation可用用来修饰那些元素，如果未标注则表示可以修饰所有元素。取值范围如下：

2.3 @Inherited-被继承

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Inherited {
}

@Inherited标识某个被标注的类型是被继承的。使用了@Inherited修饰的annotation类型被用于一个class之时，则这个annotation将被用于该class的相应子类。

假设，我们定义了注解MyAnnotation，MyAnnotation被标注为@Inherited。类Base使用了MyAnnotation，则Base具有了“具有了注解MyAnnotation”Sub类继承了Base，由于MyAnnotation是@Inherited的(具有继承性)，所以Sub也“具有了注解MyAnnotation”。

2.4 @Documented-JavaDoc

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Documented {
}

@Documented所修饰的Annotation连同自定义Annotation所修饰的元素一同保存到Javadoc文档中。

3.自定义注解

学习完了常用的元注解之后，我们便可以尝试自定义注解了。

3.1 自定义注解

@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface MethodInfo {

    String author() default "ZSSir";

    String date();

    float version() default 1.0f;

}

我们来分析下如何自定义注解：

  1. 使用@interface来标识这是一个注解，后面跟的是注解名。
  2. 使用元注解来定义注解的相关信息。
  3. 定义方法（方法名其实是属性名）：
    • 所有的方法都没有方法体（好像我们定义接口一样）。
    • 方法不能抛出异常。
    • 方法不能使用除public和abstract的其他修饰符。
    • 方法返回只能为基本类型、String, Class, annotation, enumeration 或者是他们的一维数组。返回值类型即为属性的类型。
    • 若只有一个属性，可以直接使用value（）方法；若不包含任何属性，则表示该注释为Mark Annotation。
    • 可以加 default 表示默认值，null不能作为成员默认值。

3.2 使用注解

public class AppInfo {
    @MethodInfo(author = "ZS",date = "2017/9/28",version = 1.0f)
    public static String getAppName(){
        return "Smart";
    }
}

4. 注解解释

上个章节我们分析了如何自定义和使用注解，但是这个时候注解还没有意义，我们必须要解释注解，才能正确使用其功能。本章节就带大家来分析下，如何来解释我们的注解。

解释注解最常用的有两种方式：

  1. 运行时注解

  2. 编译时注解

4.1 运行时注解

相信大家一定多多少少都了解一点关于反射的知识，反射、反射，程序员的快乐，可见反射在程序员心目中的地位是多么的高，而运行时注解其实就是使用反射技术来解释注解的。

public class AppInfo {

    @MethodInfo(author = "ZS", date = "2017/9/28", version = 1.0f)
    public static String getAppName() {
        return "Smart";
    }

    public static void main(String[] args) {
        // 获取类声明的所有方法
        Method[] methods = AppInfo.class.getDeclaredMethods();
        for (Method method : methods) {
            //判断方法是否被MethodInfo注解修饰
            boolean isPresent = method.isAnnotationPresent(MethodInfo.class);
            if (isPresent) {
                //获取注解信息
                MethodInfo methodInfo = method.getAnnotation(MethodInfo.class);
                System.out.println("method name:" + method.getName());
                System.out.println("method author:" + methodInfo.author());
                System.out.println("method version:" + methodInfo.version());
                System.out.println("method date:" + methodInfo.date());
            }

        }

    }

}

运行结果：
method name:getAppName
method author:ZS
method version:1.0
method date:2017/9/28

可见我们通过反射取得了Method，并获取到了方法上的注解，这就是反射解释注解的简单示例。

下面我们在再来看一个使用在属性上的注解：

@Documented
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface FieldInfo {
    String value() default "";
}

使用注解FieldInfo:

public class AppInfo {

    @FieldInfo("core.xz.zs")
    private String mAppPackage = "com.zs.core";


    public static void main(String[] args) {
        AppInfo appInfo = new AppInfo();
        Field[] fields = appInfo.getClass().getFields();
        for (Field field : fields) {
            boolean isPresent = field.isAnnotationPresent(FieldInfo.class);
            if (isPresent) {
                FieldInfo fieldInfo = field.getAnnotation(FieldInfo.class);

                //反射设置属性值
                try {
                    field.setAccessible(true);
                    field.set(appInfo, fieldInfo.value());
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }

            }
        }

        System.out.println(appInfo.mAppPackage);

    }
}

运行结果：

core.xz.zs

我们通过反射获取到了注解，并将注解的属性值成功设置给了appInfo的mAppPackage属性。
如果你对SpringMvc比较了解，你会发现DI和IOC也使用了注解和反射技术。

4.2 编译时注解

编译时注解相对于运行时注解复杂，本章节只简单的分析下如何实现，不做详细描述。

编译时Annotation指@Retention为CLASS 的Annotation，由apt(Annotation Processing Tool) 解析自动解析。
　a) 自定义类集成自AbstractProcessor
　b) 重写其中的 process()函数，实际是 apt(Annotation Processing Tool) 在编译时自动查找所有继承自 AbstractProcessor 的类，然后调用他们的 process 方法去处理。
　
详细的编译时注解，大家可以自己分析学习下，在此不做描述。

5. 结束语

注解在我们日常开发中经常使用到，希望大家通过本博文能了解和学习到关于注解的知识，谢谢。

上一篇下一篇

猜你喜欢

热点阅读