java注解详解及示例

本文简单介绍java的注解原理与示例。
这是在CSDN发布的第100篇文章。

---

一、基本语法

1、声明注解与元注解

我们先来看看前面的org.junit.Test注解是如何声明的

//声明Test注解
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Test {
 static class None extends Throwable {
    private static final long serialVersionUID = 1L;
    private None() {
    }
}

Class<? extends Throwable> expected() default None.class;
	long timeout() default 0L;
} 

说明：

• 使用了@interface声明了Test注解，并使用@Target注解传入ElementType.METHOD参数来标明@Test只能用于方法上，
• @Retention(RetentionPolicy.RUNTIME)则用来表示该注解生存期是运行时，从代码上看注解的定义很像接口的定义，确实如此，毕竟在编译后也会生成Test.class文件。
• 对于@Target和@Retention是由Java提供的元注解，所谓元注解就是标记其他注解的注解。

1）、@Target

@Target用来约束注解可以应用的地方（如方法、类或字段），其中ElementType是枚举类型，其定义如下，也代表可能的取值范围

public enum ElementType {
    /**标明该注解可以用于类、接口（包括注解类型）或enum声明*/
    TYPE,
    /** 标明该注解可以用于字段(域)声明，包括enum实例 */
    FIELD,
    /** 标明该注解可以用于方法声明 */
    METHOD,
    /** 标明该注解可以用于参数声明 */
    PARAMETER,
    /** 标明注解可以用于构造函数声明 */
    CONSTRUCTOR,
    /** 标明注解可以用于局部变量声明 */
    LOCAL_VARIABLE,
    /** 标明注解可以用于注解声明(应用于另一个注解上)*/
    ANNOTATION_TYPE,
    /** 标明注解可以用于包声明 */
    PACKAGE,
    /**
     * 标明注解可以用于类型参数声明（1.8新加入）
     * @since 1.8
     */
    TYPE_PARAMETER,
    /**
     * 类型使用声明（1.8新加入)
     * @since 1.8
     */
    TYPE_USE
}

当注解未指定Target值时，则此注解可以用于任何元素之上，多个值使用{}包含并用逗号隔开，如下：

@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE}

2）、@Retention

@Retention用来约束注解的生命周期，分别有三个值，源码级别（source），类文件级别（class）或者运行时级别（runtime），其含有如下：

• SOURCE：注解将被编译器丢弃（该类型的注解信息只会保留在源码里，源码经过编译后，注解信息会被丢弃，不会保留在编译好的class文件里）
• CLASS：注解在class文件中可用，但会被VM丢弃（该类型的注解信息会保留在源码里和class文件里，在执行的时候，不会加载到虚拟机中），请注意，当注解未定义Retention值时，默认值是CLASS，如Java内置注解，@Override、@Deprecated、@SuppressWarnning等
• RUNTIME：注解信息将在运行期(JVM)也保留，因此可以通过反射机制读取注解的信息（源码、class文件和执行的时候都有注解的信息），如SpringMvc中的@Controller、@Autowired、@RequestMapping等。

2、注解元素及其数据类型

通过上述对@Test注解的定义，我们了解了注解定义的过程，如果@Test内部没有定义其他元素， @Test也称为标记注解（marker annotation），但在自定义注解中，一般都会包含一些元素以表示某些值，方便处理器使用，这点在下面的例子将会看到：

@Target(ElementType.TYPE)//只能应用于类上
@Retention(RetentionPolicy.RUNTIME)//保存到运行时
public @interface User {
    String name() default "";
}

声明一个String类型的name元素，其默认值为空字符，但是必须注意到对应任何元素的声明应采用方法的声明方式，同时可选择使用default提供默认值，@User使用方式如下：

//在类上使用该注解
@User(name = "MEMBER")
public class Member {
    //.......
}

关于注解支持的元素数据类型除了上述的String，还支持如下数据类型：

• 所有基本类型（int,float,boolean,byte,double,char,long,short）
• String
• Class
• enum
• Annotation
• 上述类型的数组
  倘若使用了其他数据类型，编译器将会丢出一个编译错误，注意，声明注解元素时可以使用基本类型但不允许使用任何包装类型，同时还应该注意到注解也可以作为元素的类型，也就是嵌套注解，下面的代码演示了上述类型的使用过程：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Reference{
    boolean next() default false;
}

public @interface AnnotationElementDemo {
    //枚举类型
    enum Status {FIXED,NORMAL};
    //声明枚举
    Status status() default Status.FIXED;
    //布尔类型
    boolean showSupport() default false;
    //String类型
    String name()default "";
    //class类型
    Class<?> testCase() default Void.class;
    //注解嵌套
    Reference reference() default @Reference(next=true);
    //数组类型
    long[] value();
}

3、编译器对默认值的限制

首先，元素不能有不确定的值。也就是说，元素必须要么具有默认值，要么在使用注解时提供元素的值。
其次，对于非基本类型的元素，无论是在源代码中声明，还是在注解接口中定义默认值，都不能以null作为值，这就是限制，没有什么利用可言，但造成一个元素的存在或缺失状态，因为每个注解的声明中，所有的元素都存在，并且都具有相应的值，为了绕开这个限制，只能定义一些特殊的值，例如空字符串或负数，表示某个元素不存在。

4、注解不支持继承

注解是不支持继承的，因此不能使用关键字extends来继承某个@interface，因为注解在编译后，编译器会自动继承java.lang.annotation.Annotation接口。我们反编译前面定义的User注解

import java.lang.annotation.Annotation;
//反编译后的代码
public interface User extends Annotation
{
    public abstract String name();
}

即使Java的接口可以实现多继承，但定义注解时依然无法使用extends关键字继承@interface。

5、快捷方式

所谓的快捷方式就是注解中定义了名为value的元素，并且在使用该注解时，如果该元素是唯一需要赋值的一个元素，那么此时无需使用key=value的语法，而只需在括号内给出value元素所需的值即可。这可以应用于任何合法类型的元素，记住，这限制了元素名必须为value，简单案例如下

//定义注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface IntegerVaule{
    int value() default 0;
    String name() default "";
}
 
//使用注解
public class QuicklyWay {
    //当只想给value赋值时,可以使用以下快捷方式
    @IntegerVaule(20)
    public int age;
    //当name也需要赋值时必须采用key=value的方式赋值
    @IntegerVaule(value = 10000,name = "MONEY")
    public int money;
}

6、Java内置注解与其它元注解

Java提供的内置注解，主要有3个，如下

1）、@Override

用于标明此方法覆盖了父类的方法，源码如下

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

2）、@Deprecated

用于标明已经过时的方法或类，源码如下，关于@Documented稍后分析

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
public @interface Deprecated {

}

3）、@SuppressWarnnings

用于有选择的关闭编译器对类、方法、成员变量、变量初始化的警告，其实现源码如下

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

其内部有一个String数组，主要接收值如下：

• deprecation：使用了不赞成使用的类或方法时的警告；
• unchecked：执行了未检查的转换时的警告，例如当使用集合时没有用泛型 (Generics) 来指定集合保存的类型;
• fallthrough：当 Switch 程序块直接通往下一种情况而没有 Break 时的警告;
• path：在类路径、源文件路径等中有不存在的路径时的警告;
• serial：当在可序列化的类上缺少 serialVersionUID 定义时的警告;
  f- inally：任何 finally 子句不能正常完成时的警告;
• all：关于以上所有情况的警告。

//注明该类已过时，不建议使用
@Deprecated
class A{
    public void A(){ }
    //注明该方法已过时，不建议使用
    @Deprecated()
    public void B(){ }
}
 
class B extends A{
    @Override //标明覆盖父类A的A方法
    public void A() {
        super.A();
    }
    //去掉检测警告
    @SuppressWarnings({"uncheck","deprecation"})
    public void C(){ }
    //去掉检测警告
    @SuppressWarnings("uncheck")
    public void D(){ }
}

前面我们分析了两种元注解，@Target和@Retention，除了这两种元注解，Java还提供了另外两种元注解，@Documented和@Inherited，下面分别介绍：

4）、@Documented

被修饰的注解会生成到javadoc中

@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DocumentA {
}
 
//没有使用@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DocumentB {
}
 
//使用注解
@DocumentA
@DocumentB
public class DocumentDemo {
    public void A(){
    }
}

可以发现使用@Documented元注解定义的注解(@DocumentA)将会生成到javadoc中,而@DocumentB则没有在doc文档中出现，这就是元注解@Documented的作用。

5）、@Inherited

可以让注解被继承，但这并不是真的继承，只是通过使用@Inherited，可以让子类Class对象使用getAnnotations()获取父类被@Inherited修饰的注解，如下：

@Inherited
@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DocumentA {
}
 
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DocumentB {
}
 
@DocumentA
class A{ }
 
class B extends A{ }
 
@DocumentB
class C{ }
 
class D extends C{ }
 
//测试
public class DocumentDemo {
    public static void main(String... args){
        A instanceA=new B();
        System.out.println("已使用的@Inherited注解:"+Arrays.toString(instanceA.getClass().getAnnotations()));
 
        C instanceC = new D();
 
        System.out.println("没有使用的@Inherited注解:"+Arrays.toString(instanceC.getClass().getAnnotations()));
    }
 
    /**
     * 运行结果:
     已使用的@Inherited注解:[@annotationdemo.DocumentA()]
     没有使用的@Inherited注解:[]
     */
}

二、 注解与反射机制

Java使用Annotation接口代表注解元素，该接口是所有Annotation类型的父接口。同时为了运行时能准确获取到注解的相关信息，Java在java.lang.reflect 反射包下新增了AnnotatedElement接口，它主要用于表示目前正在 VM 中运行的程序中已使用注解的元素，通过该接口提供的方法可以利用反射技术地读取注解的信息，如反射包的Constructor类、Field类、Method类、Package类和Class类都实现了AnnotatedElement接口，它简要含义如下

• Class：类的Class对象定义
• Constructor：代表类的构造器定义
• Field：代表类的成员变量定义
• Method：代表类的方法定义
• Package：代表类的包定义
  下面是AnnotatedElement中相关的API方法，以上5个类都实现以下的方法
  

@DocumentA
class A{ }
 
//继承了A类
@DocumentB
public class DocumentDemo extends A{
    public static void main(String... args){
        Class<?> clazz = DocumentDemo.class;
        //根据指定注解类型获取该注解
        DocumentA documentA=clazz.getAnnotation(DocumentA.class);
        System.out.println("A:"+documentA);
 
        //获取该元素上的所有注解，包含从父类继承
        Annotation[] an= clazz.getAnnotations();
        System.out.println("an:"+ Arrays.toString(an));
        //获取该元素上的所有注解，但不包含继承！
        Annotation[] an2=clazz.getDeclaredAnnotations();
        System.out.println("an2:"+ Arrays.toString(an2));
 
        //判断注解DocumentA是否在该元素上
        boolean b=clazz.isAnnotationPresent(DocumentA.class);
        System.out.println("b:"+b);
 
        /**
         * 执行结果:
         A:@ annotationdemo.DocumentA()
         an:[@ annotationdemo.DocumentA(), @annotationdemo.DocumentB()]
         an2:@ annotationdemo.DocumentB()
         b:true
         */
    }
}

1、示例

通过注解的方式自动生成创建表结构的SQL语句，本例中只定义两种类型，即int和string型。以mysql数据库为测试对象。

@Target(ElementType.TYPE)//只能应用于类上
@Retention(RetentionPolicy.RUNTIME)//保存到运行时
public @interface Table {
    String name() default "tableName";

    String engine() default "InnoDB";

    String charset() default "utf8";

    int auto_incr_num() default 2;
}

@Target(ElementType.FIELD)//只能应用在字段上
@Retention(RetentionPolicy.RUNTIME)
public @interface SQLConstraints {
    //判断是否作为主键约束
    boolean primaryKey() default false;

    //判断是否允许为null
    boolean allowNull() default true;

    //判断是否唯一
    boolean unique() default false;

    //判断是否自增
    boolean auto_incr() default false;
   
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)//保存到运行时
public @interface SQLInteger {
    //数据库表列名
    String name() default "fieldNameInt";
    //嵌套注解
    SQLConstraints constraint() default @SQLConstraints;
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)//保存到运行时
public @interface SQLString {
    //数据库表列名
    String name() default "fieldNameString";

    //列类型分配的长度
    int value() default 0;

    //嵌套注解
    SQLConstraints constraint() default @SQLConstraints;
}

@Table(auto_incr_num = 20)
public class User {
    @SQLString(name = "name",value = 30, constraint = @SQLConstraints(allowNull = false))
    private String name;
    @SQLInteger(name = "age")
    private Integer age;
    @SQLInteger(name = "id", constraint = @SQLConstraints(primaryKey = true, unique = true,allowNull = false,auto_incr=true))
    private Integer id;
public class TableCreator {
    private static String getConstraints(SQLConstraints con) {
        String constraints = "";
        if (!con.allowNull())
            constraints += " NOT NULL";
        if (con.primaryKey())
            constraints += " PRIMARY KEY";
        if (con.unique())
            constraints += " UNIQUE";
        if (con.auto_incr()) {
            constraints += " AUTO_INCREMENT";
        }
        return constraints;
    }

    public static String createTableSql(String className) throws ClassNotFoundException {
        Class<?> clazz = Class.forName(className);
        Table table = clazz.getAnnotation(Table.class);
        //如果没有表注解，直接返回
        if (table == null) {
            System.out.println("No Table annotations in class " + className);
            return null;
        }
        String tableName = table.name();

        // If the name is empty, use the Class name:
        if (tableName.length() < 1) {
            tableName = clazz.getName().toUpperCase();
        }
        List<String> columnDefs = new ArrayList<String>();
        //通过Class类API获取到所有成员字段
        for (Field field : clazz.getDeclaredFields()) {
            String columnName = null;
            //获取字段上的注解
            Annotation[] anns = field.getDeclaredAnnotations();
            if (anns.length < 1)
                continue; // Not a db table column

            //判断注解类型
            if (anns[0] instanceof SQLInteger) {
                SQLInteger sInt = (SQLInteger) anns[0];
                //获取字段对应列名称，如果没有就是使用字段名称替代
                if (sInt.name().length() < 1)
                    columnName = field.getName().toUpperCase();
                else
                    columnName = sInt.name();
                //构建语句
                columnDefs.add("'" + columnName + "' INT" +
                        getConstraints(sInt.constraint()));
            }
            //判断String类型
            if (anns[0] instanceof SQLString) {
                SQLString sString = (SQLString) anns[0];
                // Use field name if name not specified.
                if (sString.name().length() < 1)
                    columnName = field.getName().toUpperCase();
                else
                    columnName = sString.name();
                columnDefs.add("'" + columnName + "' VARCHAR(" +
                        sString.value() + ")" +
                        getConstraints(sString.constraint()));
            }
        }
        //数据库表构建语句
        StringBuilder createCommand = new StringBuilder(
                "CREATE TABLE `" + tableName + "`  (");
        for (String columnDef : columnDefs) {
            createCommand.append("\n    " + columnDef + ",");
        }
        //
        String tableCreate = createCommand.substring(0, createCommand.length() - 1) + "\n) ENGINE=" + table.engine() + " AUTO_INCREMENT=" + table.auto_incr_num() + " DEFAULT CHARSET=" + table.charset() + ";";
        return tableCreate;
    }

    public static void main(String[] args) throws Exception {
        String[] arg = {"com.win.collection.annon.User"};
        for (String className : arg) {
            System.out.println("Table Creation SQL for " +
                    className + " is :\n" + createTableSql(className));
        }
    }
}