注解详解_例子

(1) 定义注解：

package annotations;
import java.lang.annotation.*;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DefineAnnotation {
   public String hello() default "aaa";
   String world();
}


（2）、使用注解
package annotations;

public class UseDefineAnnotation {
  @Deprecated
  @DefineAnnotation(hello="ttitfly",world="WORLD!!!")
  public void say(){
  System.out.println("say hello");
  }
 
  /* public static void main(String[] args) {
   UseDefineAnnotation tAnnotation=new UseDefineAnnotation();
   tAnnotation.say();
}*/
}


（3）、处理器 解析注解
package annotations;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;

public class TestDefineAnnotation {

/**
* @param args
*/
public static void main(String[] args) throws Exception{
// TODO Auto-generated method stub
       UseDefineAnnotation useDefineAnnotation=new UseDefineAnnotation();
       //1、要解析的方法带有注解的类
       Class clazz=UseDefineAnnotation.class;
      
     //Method method = clazz.getMethod("say", null);//因为是无参数的，所以直接写个null也可以
       //2、获得带有注解的方法
       Method method=clazz.getDeclaredMethod("say", new Class[]{});
       method.invoke(useDefineAnnotation, new Class[]{}); //在实例myAnnotation上执行方法method()
     //该方法是否使用了MyAnnotation这个注解类
       boolean isExists=method.isAnnotationPresent(DefineAnnotation.class);
       if(isExists){
       //3、获得方法上的注解
       /*Annotation在运行时刻，是通过java的动态代理实现的，  
              每次得到一个annotation，实际上并不是得到该annotation的实例，
              而是得到了它的一个代理，这个代理java在命名上采用的是$Proxy1,
              $Proxy2...的形式，数字是按照出现的顺序来定的   */
       DefineAnnotation annotation=method.getAnnotation(DefineAnnotation.class);
       //4、方法注解的element方法
       System.out.println(annotation.hello()+" "+annotation.world());
       }
      
       System.out.println("-------------------");
       /************************************************/    
       Method[] methods=clazz.getDeclaredMethods();
       for(Method mt:methods){
       Annotation[] annotations=mt.getAnnotations();
       for(Annotation ant:annotations){
       System.out.println(ant.annotationType().getName());
      
    //不能通过getClass().getName()的方式获得了。这样获得的结果类似这样的：$Proxy3，主要原因是因为Annotation在运行时刻，是通过java的动态代理实现的，  
             //每次得到一个annotation，实际上并不是得到该annotation的实例，而是得到了它的一个代理，这个代理java在命名上采用的是$Proxy1,$Proxy2...的形式，数字是按照出现的顺序来定的  
             //而***getClass()方法返回的是该对象运行时刻所代表的真实对象***,在这里也就是代理对象了
          System.out.println(ant.getClass().getName());
        //输出结果为：java.lang.reflect.Proxy
          System.out.println(ant.getClass().getSuperclass().getName());
       }
       }
}

}


（4）、注解的继承性 (Inherited)
注解定义时使用了@Inherit,注解用于Type（如class）上时，Type上的注解将被Type的派生类型继承到
package annotations;
import java.lang.annotation.*;

//没有指定@Target()，则注解可用于所有的ElementType
@Inherited
@Retention(RetentionPolicy.RUNTIME)
//在自己定义的Annotation里加入一个@Inherited ，就标识了这个定义的Annotation是可以被继承的
/*指示注释类型被自动继承。如果在注释类型声明中存在 Inherited 元注释，并且用户在某一类声明中查询该注释类型，
* 同时该类声明中没有此类型的注释，则将在该类的超类中自动查询该注释类型。此过程会重复进行，直到找到此类型的注释
* 或到达了该类层次结构的顶层 (Object) 为止。如果没有超类具有该类型的注释，则查询将指示当前类没有这样的注释。

注意，如果使用注释类型注释类以外的任何事物，此元注释类型都是无效的。还要注意，此元注释仅促成从超类继承注释；对已实现接口的注释无效。
*/
public @interface MyInherit {
String value();
}

package annotations;

@MyInherit("test class")
public class Parent {
@MyInherit("test method")  
    public void doSomething(){  
        System.out.println("hello");  
    } 
}

package annotations;

public class Child extends Parent {

}

package annotations;
import java.lang.reflect.*;

public class TestInherit {

/**
* @param args
*/
public static void main(String[] args) throws Exception{
// TODO Auto-generated method stub
Class< Child > clazz = Child.class;  
        if(clazz.isAnnotationPresent(MyInherit.class)){  
            MyInherit myInherit = clazz.getAnnotation(MyInherit.class);  
            System.out.println(myInherit.value());  
        }  
          
        Method method = clazz.getMethod("doSomething", new Class[]{});  
        if(method.isAnnotationPresent(MyInherit.class)){  
            MyInherit myInherit = method.getAnnotation(MyInherit.class);  
            System.out.println(myInherit.value());  
        }  
}
    /*@Inherit指示注释类型被自动继承。如果在注释类型声明中存在 Inherited 元注释，并且用户在某一类声明中查询该注释类型，
     * 同时该类声明中没有此类型的注释，则将在该类的超类中自动查询该注释类型。此过程会重复进行，直到找到此类型的注释或到达了
     * 该类层次结构的顶层 (Object) 为止.   Parent类上使用了注释@MyIherit,Parent的派生类Child将继承类上的注释@MyHerit (这就是@Inherit在@MyInherit上的作用).

     注解@MyInherit用于方法Parent.doSomething()上，这个带指定注解@MyInherit的“***方法doSomething()***”
     是否可以被Parent的派生类Child所继承到（@MyInherit不管有没有@Inherit，带有注解@MyInherit的方法
     doSomething都可以被继承到），方法doSomething确实是被Child{}继承到了，自然方法上的注解是可以被得到的。*/
}