Java 注解 初探 （一）

　　自JDK1.5之后，就开始出现注解。想要了解注解的来源和注解的用法，通过搜索引擎大都是针对某一个注解的解释，很难找到关于注解系列的文章，便自己看下。

　　基于Annotation的注释，说明Annotaion是所有注解类型扩展的公共接口。当自定义为@inferface便实现该接口。可用 instanceof去校验@interface是否属于Annotation.而上面的Target属于注解其它的注解的元注解。元注解有四个：Target、Retention、Documented、

Inherited。

　　Target

　　　　TYPE: 类
　　　　FIELD： 字段
　　　　METHOD： 方法
　　　　PARAMETER: 参数
　　　　CONSTRUCTOR: 构造函数
　　　　LOCAL_VARIABLE：本地变量
　　　　ANNOTATION_TYPE：注解
　　　　PACKAGE：包

　　现在演示一下Target

　　自定一个注解，作用于FIELD的：

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface AnnotationTarget {
    String[] value() default "iamsb";
}

　　被标记的字段拥有了超能力，是的，其它的字段仍然很傻，以下是被标记的字段赋予超能力的过程

public class AnnotationTargetProcessor {

    public static void process(Class clazz, Object obj) {
        Field[] fields = clazz.getDeclaredFields();
        for(Field field : fields) {
            if(field.isAnnotationPresent(AnnotationTarget.class)){
                try {
                    field.setAccessible(true);   // 被注解的字段是private ,所以设置true
                    field.set(obj, "now,i am still sb");
                } catch (IllegalArgumentException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}

　　最后的测试类

　　

public class SBVO {
    private String a;

    private String b;

    @AnnotationTarget("zz")
    private String c;

    private Integer d;

    private Boolean  bool = false;

    public static void main(String[] args) {
        SBVO sv = new SBVO();
        AnnotationTargetProcessor.process(SBVO.class,sv);
        String c = sv.c;
        String b = sv.b;
        System.out.println( "c ==== " + c);  //  c ==== now,i am still sb
        System.out.println( "b ==== " + b);　//   b ==== null
    }
}

说明：1.@AnnotationTarget声明的是@Target(ElementType.FIELD)，所以在用注解的时候，只能作用于字段上，而当你把@AnnotationTarget("zz")想放在类上面时，编译都不让你过，提示：The annotation @AnnotationTarget is disallowed for this location
　　　2.注解本身不具备超能力，它本身属于被动的。而是我们的规则处理类发现某个元素有某种注解，就按照某种规则来给这个元素赋予某种能力。比如我上面的AnnotationTargetProcessor扫描到字段c 有个AnnotationTarget注解，那我就给与你什么能力。同理，springboot的
　　　　某个类（目前不知道是哪个）发现有个类被标记了@Service,那我就把它来赋予Service能力。
　　　3.@interface里面只能定义返回类型为 所有基本类型、String、enum、Annotation、Class和 它们的数组。
　　　4.用注解的时候，跟我们调用方法一样 注解名（元素名=元素值），比如我们springboot的启动类 @SpringBootApplication(scanBasePackages = "xxxx",exclude={xxx.class,yyy.class}) ，可以查到SpringBootApplication注解下scanBasePackages和exclude
　　　　元素。
　　　5.@AnnotationTarget("zz")这里要说一下，这个原本是这样：@AnnotationTarget("value=zz"),如果声明的注解里只对value赋值，那么在引用的时候value=可以省略。

　　接着再看下元注解

　　Documented

　　它没有元素，所以也被称为标记注解，我在SBVO中添加一行代码：

　

@AnnotationTarget("nc")
public static final String e = "SPRING SUMMER"; 

　　然后用javadoc  -encoding UTF-8 AnnotationTarget.java SBVO.java 生成文档，这里我的类里面有中文，所以添加了utf8方式，生成的doc文档，入口是index.html，见下图：

　　就是标红椭圆的注解是否被添加到doc文档的差别。如果没有添加元注解Documented,这里是没有红色椭圆的文本信息的。所以定义了Documented的自定义注解，在生成javadoc文档时，就会添加该注解文本信息。

　　接着看

　　Retention

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
}

　　1. SOURCE ,编译器将丢弃注解

　　2. CLASS，编译器将在类文件中记录注解，但是不需要在运行时被VM保留。这是默认值的行为。

　　3. RUNTIME，编译器将在类文件中记录注解，并且在运行时被VM保留。因此在反射时可以读取得到它们。

　　作何解释呢？我先把我自定义注解AnnotationTarget的保留策略改成RetentionPolicy.SOURCE

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.SOURCE)
public @interface AnnotationTarget {
    String[] value() default "iamsb";
}

　　仍然用下面这个类来引用它

public class SBVO {
    private String a;

    private String b;

    @AnnotationTarget("zz")
    private String c;

    private Integer d;

    private Boolean  bool = false;

    @AnnotationTarget("nc")
    public static final String e = "SPRING SUMMER"; 

    @AnnotationTarget("")
    private String f = "i do not want to be a sb.";

    public static void main(String[] args) {
        SBVO sv = new SBVO();
        AnnotationTargetProcessor.process(SBVO.class,sv);
        String c = sv.c;
        String b = sv.b;
        String f = sv.f;
        System.out.println( "c ==== " + c);
        System.out.println( "b ==== " + b);
        System.out.println( "e ==== " + e);
        System.out.println( "f ==== " + f);
    }
}

　　经过编译后，把引用的SBVO.class反编译，可以看到

public class SBVO
{
  private String a;
  private String b;
  private String c;                                   // 未保留
  private Integer d;
  private Boolean bool = Boolean.valueOf(false);
  public static final String e = "SPRING SUMMER";     // 未保留
  private String f = "i do not want to be a sb.";     // 未保留

  public static void main(String[] args)
  {
    SBVO sv = new SBVO();
    AnnotationTargetProcessor.process(SBVO.class, sv);
    String c = sv.c;
    String b = sv.b;
    String f = sv.f;
    System.out.println("c ==== " + c);
    System.out.println("b ==== " + b);
    System.out.println("e ==== SPRING SUMMER");
    System.out.println("f ==== " + f);
  }
}

　　这里就解释了策略为SOURCE时，编译后就把注解丢弃了。

　　当我把策略改成RetentionPolicy.CLASS,编译后再来看SBVO.class

public class SBVO
{
  private String a;
  private String b;
  @AnnotationTarget({"zz"})
  private String c;                                  // 保留了注解
  private Integer d;
  private Boolean bool = Boolean.valueOf(false);
  @AnnotationTarget({"nc"})
  public static final String e = "SPRING SUMMER";    // 保留了注解
  @AnnotationTarget({""})
  private String f = "i do not want to be a sb.";    // 保留了注解

  public static void main(String[] args)
  {
    SBVO sv = new SBVO();
    AnnotationTargetProcessor.process(SBVO.class, sv);
    String c = sv.c;
    String b = sv.b;
    String f = sv.f;
    System.out.println("c ==== " + c);
    System.out.println("b ==== " + b);
    System.out.println("e ==== SPRING SUMMER");
    System.out.println("f ==== " + f);
  }
}

　　此时我来运行SBVO的main 方法，得到结果：

　   c ==== null
　　b ==== null
　　e ==== SPRING SUMMER
　　f ==== i do not want to be a sb.

　　此时main方法里面的AnnotationTargetProcessor.process(SBVO.class, sv); 其中process方法if(field.isAnnotationPresent(AnnotationTarget.class)) 判断始终是false，反射取不到，说明注解没在虚拟机中驻留。所以，c、b、e、f都是原值，那我在把自定义注解

AnnotationTarget策略更改成RetentionPolicy.RUNTIME，首先注解时保留在SBVO.class文件中的

  @AnnotationTarget({"zz"})
  private String c;                                 // 保留
  private Integer d;
  private Boolean bool = Boolean.valueOf(false);
  @AnnotationTarget({"nc"})
  public static final String e = "SPRING SUMMER";   // 保留
  @AnnotationTarget({""})
  private String f = "i do not want to be a sb.";   // 保留

然后，运行SBVO中的main方法，结果为：

　　java.lang.IllegalAccessException: Can not set static final java.lang.String field studiii.zlsj_test.annotation.target.SBVO.e to java.lang.String
　　　　　　　　at sun.reflect.UnsafeFieldAccessorImpl.throwFinalFieldIllegalAccessException(Unknown Source)
　　　　　　　　at sun.reflect.UnsafeFieldAccessorImpl.throwFinalFieldIllegalAccessException(Unknown Source)
　　　　　　　　at sun.reflect.UnsafeQualifiedStaticObjectFieldAccessorImpl.set(Unknown Source)
　　　　　　　　at java.lang.reflect.Field.set(Unknown Source)
　　　　　　　　at studiii.zlsj_test.annotation.target.AnnotationTargetProcessor.process(AnnotationTargetProcessor.java:19)
　　　　　　　　at studiii.zlsj_test.annotation.target.SBVO.main(SBVO.java:30)
　　c ==== now,i am still sb                          // c 由空值改成当前值
　　b ==== null                                             // b 未添加注解
　　e ==== SPRING SUMMER                    // final 改不了，上面也抛异常了
　　f ==== now,i am still sb                          // f 值由 i do not want to be a sb.改成 now,i am still sb

此时看到AnnotationTargetProcessor.process通过反射把标记了注解的字段都更改了，e标记了注解，但e是final变量，所以当想要更改它时，是不允许的。

接着看最后一个
　　Inherited
　　从它的源码可以看到，它没有定义任何元素，所以它和Documented一样，属于标记注解。再来看一下它的注释：

/**
 * Indicates that an annotation type is automatically inherited.  If
 * an Inherited meta-annotation is present on an annotation type
 * declaration, and the user queries the annotation type on a class
 * declaration, and the class declaration has no annotation for this type,
 * then the class's superclass will automatically be queried for the
 * annotation type.  This process will be repeated until an annotation for this
 * type is found, or the top of the class hierarchy (Object)
 * is reached.  If no superclass has an annotation for this type, then
 * the query will indicate that the class in question has no such annotation.
 *
 * <p>Note that this meta-annotation type has no effect if the annotated
 * type is used to annotate anything other than a class.  Note also
 * that this meta-annotation only causes annotations to be inherited
 * from superclasses; annotations on implemented interfaces have no
 * effect.
 *
 * @author  Joshua Bloch
 * @since 1.5
 * @jls 9.6.3.3 @Inherited
 */

　　翻译一下：表明它是一个自动继承的注解类。如果一个声明的注解类（自定义注解）上存在这个继承元注解，并且用户去查找某个声明类上的自定义注解，并且这个声明类没有这个自定义注解，那么将自动去搜索这个类的父类的自定义注解。这个过程将

　　　　　　　重复，直到这个自定义注解被找到，或者搜索直到这个声明类的最顶层Object类。如果没有父类（这里指父、祖父、曾祖父直到Object）含有自定义注解，那么就表明这个声明类没有这个自定义注解。

　　　　　　　注意，如果自定义注解不是注释在一个类上的话，这个元注解（指Inherited）是没有效果的。还注意，这个元注解只会导致注解被继承自超类，实现接口上的注解是无效的。

　　再翻译一下：1.这是一个自动继承的元注解，它是注解自定义注解的注解。

　　　　　　　　2.如果某个类的父类、或者祖父类等有@Inherited注解或含有@Inherited的自定义注解，那么子类便可继承父类的注解。

　　　　　　　　3.该注解只对类有效，对接口实现是无效的。

　　例子：

　　创建一个注解，标记Inherited

@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface InheAnnoTest {
    String value() default "ni da ye";
}

　　创建一个父类

@InheAnnoTest("Just Parent")
public class ParentClass {

    private String name ;

    @AnnotationTarget("yes, i am 15")
    String age;

    @MethodTestAnno("yeah")
    public void attack() {

    }
    @InheAnnoTest("ojbk")
    protected String plus() {
        return "";
    }
}

　　创建一个子类

public class ChildClass extends ParentClass {

    private String name ;

    String age;

    public void attack() {

    }

    protected String plus() {
        return "plus";
    }

}

　　测试类

public class Test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Class<ChildClass> cc = ChildClass.class;
        Class<ParentClass> pc = ParentClass.class;
        System.out.println(pc.isAnnotationPresent(InheAnnoTest.class));        // true
        System.out.println(cc.isAnnotationPresent(InheAnnoTest.class));        // true
        Annotation[]  annos = cc.getAnnotations();
        for(Annotation anno : annos) {
            System.out.println(anno.annotationType().getName());               // studiii.zlsj_test.annotation.inheritedTest.InheAnnoTest
        }
    }

}

　　如果ChildClass和ParentClass 无继承关系，那么

　　　　System.out.println(cc.isAnnotationPresent(InheAnnoTest.class));         // false
　并且 annos 就为空了。

　再来验证接口，创建一个接口：
　　

@InheAnnoTest("")                                                            // 打上了标记
public interface ParentInterface {

    public static final String name = "daye";

    void atack();
}

　　实现类：

public class ChildInterface implements ParentInterface{

    @Override
    public void atack() {

    }
}

　　得到结果：

Class<ChildInterface> ci = ChildInterface.class;
System.out.println(ci.isAnnotationPresent(InheAnnoTest.class));                      // false

　　因此，就印证了Inherited注释里得说明。
　　总结一下：注解Annotation 从JDK1.5之后被引入。它包含了4个元注解：Tagert、Documented、 Retention、 Inherited，元注解的意思就是可以注解其它注解的注解。就好比我们拼音有6个元音 a、o、e、i、u、u（..）,可以组成很多双韵母，比如ai、ei、ui、ao、ou等等，进而拼出
　　　　　　  中华上下五千年沉淀的各种汉字。同理，4个元注解也可衍生出各种功能的注解。
　　　　　　　Tagert注解指明你定义的注解的作用域，是Field、Method还是Type等。
　　　　　　　Documented注解表示通过javadoc后，会再doc中显示出来。
　　　　　　  Retention注解，表示注解的保留策略，仅有三种，1.编译时就把注解丢弃。2.编译时保留，但再JVM中不保留。3.编译时保留，JVM中也保留，反射可从JVM中取到该注解。
　　　　　　  Inherited注解，表示子类可以取到父类中定义了该注解的注解。