va注解应用实例

本文介绍了java的自定义注解及注解类编写的规则, 并通过实例来说明下如何使用java的注解. 实例演示了注解在类,构造方法,方法和字段的使用. 可以从这里下载到完成的工程代码: http://dl.iteye.com/topics/download/f74972df-234f-30c9-aadd-ca2ed1376bc2

自定义注解类编写的一些规则:

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. 注解也可以没有定义成员, 不过这样注解就没啥用了

自定义注解类时, 可以指定目标 (类、方法、字段, 构造函数等) , 注解的生命周期(运行时,class文件或者源码中有效), 是否将注解包含在javadoc中及是否允许子类继承父类中的注解, 具体如下:

1. @Target 表示该注解目标,可能的 ElemenetType 参数包括:

ElemenetType.CONSTRUCTOR 构造器声明
ElemenetType.FIELD 域声明(包括 enum 实例) 
ElemenetType.LOCAL_VARIABLE 局部变量声明 
ElemenetType.METHOD 方法声明 
ElemenetType.PACKAGE 包声明 
ElemenetType.PARAMETER 参数声明 
ElemenetType.TYPE 类，接口(包括注解类型)或enum声明

2. @Retention 表示该注解的生命周期,可选的 RetentionPolicy 参数包括

RetentionPolicy.SOURCE 注解将被编译器丢弃 
RetentionPolicy.CLASS 注解在class文件中可用，但会被VM丢弃 
RetentionPolicy.RUNTIME VM将在运行期也保留注释，因此可以通过反射机制读取注解的信息

3. @Documented 指示将此注解包含在 javadoc 中

4. @Inherited 指示允许子类继承父类中的注解

好, 该介绍的介绍了, 看下自定义的注解应用实例:

1. 首先看下定义的注解类:

类注解定义, MyClassAnnotation.java:

package  com.ross.annotation;  
import  java.lang.annotation.*;  
/**  
 * Author: Jiangtao He; Email: ross.jiangtao.he@gmail.com  
 * Date: 2012-1-29  
 * Since: MyJavaExpert v1.0  
 * Description: class annotation  
 */   
@Retention (RetentionPolicy.RUNTIME)   
@Target (ElementType.TYPE)   
public   @interface  MyClassAnnotation   
{  
    String uri();  
    String desc();  
}

默认构造方法注解定义,MyConstructorAnnotation.java:

package  com.ross.annotation;  
import  java.lang.annotation.ElementType;  
import  java.lang.annotation.Retention;  
import  java.lang.annotation.RetentionPolicy;  
import  java.lang.annotation.Target;  
/**  
 * Author: Jiangtao He; Email: ross.jiangtao.he@gmail.com  
 * Date: 2012-1-29  
 * Since: MyJavaExpert v1.0  
 * Description: Constructor annotation  
 */   
@Retention (RetentionPolicy.RUNTIME)   
@Target (ElementType.CONSTRUCTOR)   
public   @interface  MyConstructorAnnotation   
{  
    String uri();  
    String desc();  
}

方法注解定义,MyMethodAnnotation.java:

package  com.ross.annotation;  
import  java.lang.annotation.ElementType;  
import  java.lang.annotation.Retention;  
import  java.lang.annotation.RetentionPolicy;  
import  java.lang.annotation.Target;  
/**  
 * Author: Jiangtao He; Email: ross.jiangtao.he@gmail.com  
 * Date: 2012-1-29  
 * Since: MyJavaExpert v1.0  
 * Description: method annotation  
 */   
@Retention (RetentionPolicy.RUNTIME)   
@Target (ElementType.METHOD)   
public   @interface  MyMethodAnnotation   
{  
    String uri();  
    String desc();  
}

字段注解定义, MyFieldAnnotation.java:

package  com.ross.annotation;  
import  java.lang.annotation.ElementType;  
import  java.lang.annotation.Retention;  
import  java.lang.annotation.RetentionPolicy;  
import  java.lang.annotation.Target;  
/**  
 * Author: Jiangtao He; Email: ross.jiangtao.he@gmail.com  
 * Date: 2012-1-29  
 * Since: MyJavaExpert v1.0  
 * Description: field annotation  
 */   
@Retention (RetentionPolicy.RUNTIME)   
@Target (ElementType.FIELD)   
public   @interface  MyFieldAnnotation   
{  
    String uri();  
    String desc();  
}

2. 再看下我们注解的应用和测试 MySample.java:

在类上面使用了MyClassAnnotation注解, 默认构造方法上使用了MyConstructorAnnotation注解, 自定义方法上使用了MyMethodAnnotation注解, 自定义字段上使用了MyFieldAnnotation注解, 在Mail函数中则实现了访问这些注解,并打印注解信息.

package  com.ross.annotation;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

import com.myinterface.MyClassAnnotation;
import com.myinterface.MyConstructorAnnotation;
import com.myinterface.MyFieldAnnotation;
import com.myinterface.MyMethodAnnotation;

/**
 * Author: Jiangtao He; Email: ross.jiangtao.he@gmail.com Date: 2012-1-29 Since:
 * MyJavaExpert v1.0 Description: This class is used to show how to use the
 * annotation of each level
 */
@MyClassAnnotation(uri = "com.ross.MySample", desc = "The class name")
public class MySample {
    @MyFieldAnnotation(uri = "com.ross.MySample#id", desc = "The class field")
    public String id;

    /**
     * Description: default constructor
     */
    @MyConstructorAnnotation(uri = "com.ross.MySample#MySample", desc = "The default constuctor")
    public MySample() {
    }

    /**
     * Description: normal method
     */
    @MyMethodAnnotation(uri = "com.ross.MySample#setId", desc = "The class method")
    public void setId(String id) {
        this.id = id;
    }

    /**
     * Description: MyAnnotation test
     * 
     * @throws NoSuchMethodException
     * @throws SecurityException
     * @throws NoSuchFieldException
     */
    public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException {
        MySample oMySample = new MySample();
        // get class annotation
        MyClassAnnotation oMyAnnotation = MySample.class.getAnnotation(MyClassAnnotation.class);
        System.out.println("Class's uri: " + oMyAnnotation.uri() + "; desc: " + oMyAnnotation.desc());

        // get constructor annotation
        Constructor oConstructor = oMySample.getClass().getConstructor();
        MyConstructorAnnotation oMyConstructorAnnotation = (MyConstructorAnnotation) oConstructor.getAnnotation(MyConstructorAnnotation.class);
        System.out.println("Constructor's uri: " + oMyConstructorAnnotation.uri() + "; desc: " + oMyConstructorAnnotation.desc());

        // get method annotation
        Method oMethod = oMySample.getClass().getDeclaredMethod("setId", String.class);
        MyMethodAnnotation oMyMethodAnnotation = oMethod.getAnnotation(MyMethodAnnotation.class);
        System.out.println("Method's uri: " + oMyMethodAnnotation.uri() + "; desc: " + oMyMethodAnnotation.desc());

        //use method reflect
        oMethod.invoke(sMySample);
        
        // get field annotation
        Field oField = oMySample.getClass().getDeclaredField("id");
        MyFieldAnnotation oMyFieldAnnotation = oField.getAnnotation(MyFieldAnnotation.class);
        System.out.println("Field's uri: " + oMyFieldAnnotation.uri() + "; desc: " + oMyFieldAnnotation.desc());

    }

}

控制台打印结果:

Class's uri: com.ross.MySample; desc: The class name  
Constructor's uri: com.ross.MySample#MySample; desc: The default constuctor  
Method's uri: com.ross.MySample#setId; desc: The class method  
Field's uri: com.ross.MySample#id; desc: The class field

至此本实例就完成了, 其实就是抓住两点一个是定义注解类,另外一个是如何访问注解, 就算是学会了.

完全引用自:

Java注解应用实例 - Annotation, 自定义注解, 注解类规则--http://hejiangtao.iteye.com/blog/1381225

MyJavaExpert_V1.0-java注解应用实例.rar (10.1 KB)