Java Annotation 机制源码分析与使用

1 Annotation

1.1 Annotation 概念及作用

     1.  概念

　　An annotation is a form of metadata, that can be added to Java source code. Classes, methods, variables, parameters and packages may be annotated. Annotations have no direct effect on the operation of the code they annotate.[3]

　　能够添加到 Java 源代码的语法元数据。类、方法、变量、参数、包都可以被注解，可用来将信息元数据与程序元素进行关联。

　　更直观的理解，它提供了一种安全的类似注释的机制，用来将任何的信息或元数据（metadata）与程序元素（类、方法、成员变量等）进行关联。

2.  定义    

　Annotation通过如下的方式进行定义

public @interface Override {
}

　　其中的@interface是一个关键字，这个关键字声明隐含了一个信息：它是继承了java.lang.annotation.Annotation接口，并非声明了一个interface。在设计annotations的时候必须把一个类型定义为@interface，而不能用class或interface关键字。定义的详细内容参考[1.2.3]自定义Annotation一节。

　3.  作用

　　Annotation的引入是为了从Java语言层面上，为Java源代码提供元数据的支持

　　　　(1).   标记，用于告诉编译器一些信息

　　　　Marker Annotation:该Annotation没有参数输入，更多类似于标识一个东西，类似于Java语言中的java.io.Serialable之类的接口，并无需要实现的方法。

　　　　(2).   编译时动态处理，如动态生成代码

　　　　(3).   运行时动态处理，如得到注解信息

1.2  Annotation 分类

1.2.1    标准 Annotation

    　　1.     @Override

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

　　　2.     @Deprecated

@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface Deprecated {
}

　　　3.    @SuppressWarnings

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {
    String[] value();
}

　　标准Annotation是指Java自带的几个Annotation，上面三个分别表示重写函数，函数已经被禁止使用，忽略某项Warning

1.2.2    元 Annotation

　元Annotation是指用来定义Annotation的Annotation

  　　 1.   @Retention

　@Retention表示Annotation作用范围和保留时间，可选值SOURCE（源码时），CLASS（编译时），RUNTIME（运行时），默认为 CLASS，值为 SOURCE 大都为Mark 　　Annotation，这类Annotation 大都用来校验,比如Override, SuppressWarnings

@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
}

　　　2.     @Target

　　@Target 表示Annotation可以用来修饰哪些程序元素，如 TYPE, METHOD, CONSTRUCTOR, FIELD, PARAMETER 等，未标注则表示可修饰所有

@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,
    /** Parameter declaration */
    PARAMETER,
    /** Constructor declaration */
    CONSTRUCTOR,
    /** Local variable declaration */
    LOCAL_VARIABLE,
    /** Annotation type declaration */
    ANNOTATION_TYPE,
    /** Package declaration */
    PACKAGE
}

　　　3.     @Inherited[4][5]

　　@Inherited 表示父类Annotation可以被子类继承

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

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

　　注意：@Inherited annotation类型是被标注过的class的子类所继承。类并不从它所实现的接口继承annotation，方法并不从它所重载的方法继承annotation。

　　当@Inherited annotation类型标注的annotation的Retention是RetentionPolicy.RUNTIME，则反射API增强了这种继承性。如果我们使用java.lang.reflect去查询一个　　@Inherited annotation类型的annotation时，反射代码检查将展开工作：检查class和其父类，直到发现指定的annotation类型被发现，或者到达类继承结构的顶层。

　　就是说， 查看查找@Inherited过的Annotation之时，需要反复的向上查找，方才可以。

   　　4.     @Documented

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

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

1.2.3    自定义Annotation

　　自定义Annotation表示自己根据需要定义的Annotation，定义时需要用到上面的元Annotation。这里只是一种分类而已，也可以根据作用域分为源码时、编译时、运行时 Annotation。

　　下面通过自定义Annotation MethodInfo，以实例来具体介绍自定义Annotation的使用。

　　　1.   自定义Annotation定义

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Inherited
public @interface MethodInfo {
     String author() default "[email protected]";
     String date();
     int version() default 1;
}

　　MethodInfo Annotation定义部分：

　　　　(1)   通过@interface 定义，注解名即为自定义注解名

　　　　(2)   注解配置参数名为注解类的方法名，且：

　　　　　　a)   所有方法没有方法体，方法名即为属性名，没有参数没有修饰符，实际只允许 public & abstract 修饰符，默认为 public ，不允许抛异常

　　　　　　b)  方法返回值只能是基本类型，String, Class, annotation, enumeration 或者是他们的一维数组，返回类型即为属性类型

　　　　　　c)  若只有一个默认属性，可直接用 value() 函数。一个属性都没有表示该 Annotation 为 Mark Annotation

　　　　　　d)  可以加 default 表示默认值，null不能作为成员默认值

　　2.      自定义Annotation调用

public class App {
    @MethodInfo( author =“xiaotian”, date="2014/02/14", version=2)
    public String getAppName() {
        return "trinea";
    }
}

这里是调用自定义Annotation--MethodInfo的示例，MethodInfo Annotation 作用为给方法添加相关信息，包括 author、date、version

　3.   运行时Annotation解析

　　　　(1).   Annotation解析API

　　运行时Annotation指@Retention为RUNTIME的Annotation，可手动调用下面常用 API 解析。

public interface AnnotatedElement {
    /* Returns true if an annotation for the specified type
     * is present on this element, else false.  This method
     * is designed primarily for convenient access to marker annotations.*/
   boolean isAnnotationPresent(Class<? extends Annotation> annotationClass);

    /* Returns this element‘s annotation for the specified type if
     * such an annotation is present, else null */
   <T extends Annotation> T getAnnotation(Class<T> annotationClass);

    /* Returns all annotations present on this element.  (Returns an array
     * of length zero if this element has no annotations.)  The caller of
     * this method is free to modify the returned array; it will have no
     * effect on the arrays returned to other callers */
    Annotation[] getAnnotations();

    /* Returns all annotations that are directly present on this
     * element.  Unlike the other methods in this interface, this method
     * ignores inherited annotations.  (Returns an array of length zero if
     * no annotations are directly present on this element.)  The caller of
     * this method is free to modify the returned array; it will have no
     * effect on the arrays returned to other callers */
    Annotation[] getDeclaredAnnotations();

}

　　其中Constructor，Field，Method都继承类class AccessibleObject implements AnnotatedElement；可通过如下接口来解析annotation：

  • element.getAnnotation(AnnotationName.class)：

　　表示得到element某个 AnnotationName的信息，因为一个 Target 可以被多个 Annotation 修饰

  • element.getAnnotations( ) :

　　则表示得到element所有Annotations

  • element.isAnnotationPresent(AnnotationName.class):

　　表示该元素是否被某个 AnnotationNam修饰

　　(2).    App解析实例分析

public static void main(String[] args) {
    try {
        Class cls = Class.forName("java.test.annotation.App");
        for (Method method : cls.getMethods()) {
            MethodInfo methodInfo = method.getAnnotation(MethodInfo.class);
            if (methodInfo != null) {
                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());
            }
        }
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
}

　　以上解析代码以MethodInfo Annotation为例，利用 Target（这里是 Method）getAnnotation函数得到Annotation信息，然后就可以调用Annotation的方法得到响应属性值

　4.      编译时Annotation解析

　　  (1).     编译时Annotation解析过程

　　编译时Annotation指@Retention为CLASS 的Annotation，由apt(Annotation Processing Tool) 解析自动解析。

　　需要做的

　　　　　　a)   自定义类集成自AbstractProcessor

　　　　　　b)   重写其中的 process 函数

　　　　　　实际是 apt(Annotation Processing Tool) 在编译时自动查找所有继承自 AbstractProcessor 的类，然后调用他们的 process 方法去处理

　　  (2).     解析示例

　　假设之前自定义的MethodInfo的@Retention为CLASS，

@SupportedAnnotationTypes({ " java.test.annotation.MethodInfo" })
public class MethodInfoProcessor extends AbstractProcessor {
     @Override
    public boolean process(Set<?extends TypeElement> annotations, RoundEnvironment env) {
        HashMap<String, String> map = new HashMap<String, String>();
        for (TypeElement te : annotations) {
            for (Element element : env.getElementsAnnotatedWith(te)) {
                MethodInfo methodInfo = element.getAnnotation(MethodInfo.class);
                map.put(element.getEnclosingElement().toString(), methodInfo.author());
            }
        }
        return false;
    }
}

　　SupportedAnnotationTypes表示这个Processor要处理的Annotation 名字。process函数中参数annotations表示待处理的 Annotations，参数 env 表示当前或是之前的运行环境, process函数返回值表示这组annotations是否被这个 Processor 接受，如果接受后续子的 rocessor不会再对这个Annotations 进行处理。

参考

[1].    The Java™ Tutorials : http://docs.oracle.com/javase/tutorial/java/annotations/

[2].   APT: Compile-Time Annotation Processing with Java

http://www.javalobby.org/java/forums/t17876.html

[3].   Java annotation : http://en.wikipedia.org/wiki/Java_annotation

[4].     Java中@Inherited注解的运用: http://xiangdefei.iteye.com/blog/1044199

[5].   Annotation Inheritance Examples: http://www.jroller.com/alessiopace/entry/annotation_inheritance_examples

时间： 2024-11-03 21:13:39

Java Annotation 机制源码分析与使用的相关文章

Java NIO——Selector机制源码分析---转

一直不明白pipe是如何唤醒selector的,所以又去看了jdk的源码(openjdk下载),整理了如下: 以Java nio自带demo : OperationServer.java   OperationClient.java(见附件) 其中server端的核心代码: public void initSelector() { try { selector = SelectorProvider.provider().openSelector(); this.serverChannel1 =

Spark资源调度机制源码分析--基于spreadOutApps及非spreadOutApps两种资源调度算法

Spark资源调度机制源码分析--基于spreadOutApps及非spreadOutApps两种资源调度算法 1.spreadOutApp尽量平均分配到每个executor上: 2.非spreadOutApp尽量在使用单个executor的资源. 源码分析 org.apache.spark.deploy.master.Master 1.首先判断,master状态不是ALIVE的话,直接返回2.调度driver3. Application的调度机制(核心之核心,重中之重) 源码如下: 1 /*

java.io.BufferedOutputStream 源码分析

BufferedOutputStream  是一个带缓冲区到输出流,通过设置这种输出流,应用程序就可以将各个字节写入底层输出流中,而不必针对每次字节写入调用底层系统. 俩个成员变量,一个是存储数据的内部缓冲区,一个是缓冲区中的有效字节数. /** * The internal buffer where data is stored. */ protected byte buf[]; /** * The number of valid bytes in the buffer. This value

Java split方法源码分析

Java split方法源码分析 1 public String[] split(CharSequence input [, int limit]) { 2 int index = 0; // 指针 3 boolean matchLimited = limit > 0; // 是否限制匹配个数 4 ArrayList<String> matchList = new ArrayList<String>(); // 匹配结果队列 5 Matcher m = matcher(inp

Android -- 消息处理机制源码分析(Looper,Handler,Message)

android的消息处理有三个核心类:Looper,Handler和Message.其实还有一个Message Queue(消息队列),但是MQ被封装到Looper里面了,我们不会直接与MQ打交道,因此我没将其作为核心类.下面一一介绍: Looper Looper的字面意思是“循环者”,它被设计用来使一个普通线程变成Looper线程.所谓Looper线程就是循环工作的线程.在程序开发中(尤其是GUI开发中),我们经常会需要一个线程不断循环,一旦有新任务则执行,执行完继续等待下一个任务,这就是Lo

Android 中View的绘制机制源码分析 三

到目前为止,measure过程已经讲解完了,今天开始我们就来学习layout过程,不过在学习layout过程之前,大家有没有发现我换了编辑器,哈哈,终于下定决心从Html编辑器切换为markdown编辑器,这里之所以使用"下定决心"这个词,是因为毕竟Html编辑器使用好几年了,很多习惯都已经养成了,要改变多年的习惯确实不易,相信这也是还有很多人坚持使用Html编辑器的原因.这也反应了一个现象,当人对某一事物非常熟悉时,一旦出现了新的事物想取代老的事物时,人们都有一种抵触的情绪,做技术的

Android 中View的绘制机制源码分析 二

尊重原创:http://blog.csdn.net/yuanzeyao/article/details/46842891 本篇文章接着上篇文章的内容来继续讨论View的绘制机制,上篇文章中我们主要讲解了View的measure过程,今天我们就来学习ViewGroup的measure过程,由于ViewGroup只是一个抽象类,所以我们需要以一个具体的布局来分析measure过程,正如我上篇文章说的,我打算使用LinearLayout为例讲解measure过程,如果你还没有读过上篇文章,那么建议你先

【JAVA】ThreadLocal源码分析

ThreadLocal内部是用一张哈希表来存储: 1 static class ThreadLocalMap { 2 static class Entry extends WeakReference<ThreadLocal<?>> { 3 /** The value associated with this ThreadLocal. */ 4 Object value; 5 6 Entry(ThreadLocal<?> k, Object v) { 7 super(k)

Android应用setContentView与LayoutInflater加载解析机制源码分析

[工匠若水 http://blog.csdn.net/yanbober 转载烦请注明出处,尊重分享成果] 1 背景 其实之所以要说这个话题有几个原因: 理解xml等控件是咋被显示的原理,通常大家写代码都是直接在onCreate里setContentView就完事,没怎么关注其实现原理. 前面分析<Android触摸屏事件派发机制详解与源码分析三(Activity篇)>时提到了一些关于布局嵌套的问题,当时没有深入解释. 所以接下来主要分析的就是View或者ViewGroup对象是如何添加至应用程