记录生活中的点点滴滴

0%

Java注解

发表于 Valine：

关于注解首先引入官方文档的一句话：Java 注解用于为 Java 代码提供元数据。作为元数据，注解不直接影响你的代码执行，但也有一些类型的注解实际上可以用于这一目的。Java 注解是从 Java5 开始添加到 Java 的。

理解注解

我们常用的 Test 方法，就会用到注解，如下：

1
2
3
4
@Test
public void Test1(){
    System.out.println("hello");
}

通过在方法上使用@Test注解后，在运行该方法时，测试框架会自动识别该方法并单独调用，@Test实际上是一种标记注解，起标记作用，运行时告诉测试框架该方法为测试方法。

基本语法

声明注解

我们先看看 @Test 这个注解是怎么声明的，看看它的源码如下：

1
2
3
4
5
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Test {
    ....
}

可以看到，我们可以使用 @interface 来声明注解。

对于 @Target 和 @Retention 是由 Java 提供的元注解，所谓元注解就是标记注解的注解。

1、使用@Target注解传入ElementType.METHOD参数来标明@Test只能用于方法上

2、@Retention(RetentionPolicy.RUNTIME)则用来表示该注解生存期是运行时

@Target 与 @Retention

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    public enum ElementType {
        /**标明该注解可以用于类、接口（包括注解类型）或enum声明*/
        TYPE,

        /** 标明该注解可以用于字段(域)声明，包括enum实例 */
        FIELD,

        /** 标明该注解可以用于方法声明 */
        METHOD,
        
    	......
    }

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

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

注解元素及其数据类型

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

1
2
3
4
5
6
7
8
9
/**
 * Created by wuzejian on 2017/5/18.
 * 对应数据表注解
 */
@Target(ElementType.TYPE)//只能应用于类上
@Retention(RetentionPolicy.RUNTIME)//保存到运行时
public @interface DBTable {
    String name() default "";
}

上述定义一个名为DBTable的注解，该用于主要用于数据库表与Bean类的映射（稍后会有完整案例分析），与前面Test注解不同的是，我们声明一个String类型的name元素，其默认值为空字符，但是必须注意到对应任何元素的声明应采用方法的声明方式，同时可选择使用default提供默认值，@DBTable使用方式如下：

1
2
3
4
5
//在类上使用该注解
@DBTable(name = "MEMBER")
public class Member {
    //.......
}

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

  • 所有基本类型（int,float,boolean,byte,double,char,long,short）
  • String
  • Class
  • enum
  • Annotation
  • 上述类型的数组

编译器对默认值的限制

首先，元素不能有不确定的值。也就是说：元素必须要么具有默认值，要么在使用注解时提供元素的值。

其次，对于非基本类型的元素，无论是在源代码中声明，还是在注解接口中定义默认值，都不能以null作为值。

注解不支持继承

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

快捷方式

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Target(ElementType.FIELD) //只能应用于类上
@Retention(RetentionPolicy.RUNTIME) //保存在运行时
public @interface MyDBTable {
    String name() default "";
    int value() default 6;
}
class MyDemo{
    //当只想给value赋值时,可以使用以下快捷方式
    @MyDBTable()
    public int age;

    //当name也需要赋值时必须采用key=value的方式赋值
    @MyDBTable(value = 100,name = "MONEY")
    public int money;
}

Java内置注解与其它元注解

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

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

    1
    2
    3
    4
    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.SOURCE)
    	public @interface Override {
    }

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

    1
    2
    3
    4
    5
    6
    7
    @Documented
    @Retention(RetentionPolicy.RUNTIME)
    @Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, MODULE, PARAMETER, TYPE})
    public @interface Deprecated {
        String since() default "";
        boolean forRemoval() default false;
    }

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

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

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

  • @Documented：被它修饰的注解会生成到 javadoc 中

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    //注解DocumentA 会被@Inherited修饰
    @Inherited
    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface DocumentA {
    }

    //注解DocumentB 不会被@Inherited修饰
    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @interface DocumentB {
    }

    //被注解DocumentA修饰的AA类
    @DocumentA
    class AA{}

    //BB类继承AA类
    class BB extends AA{}

    //被注解DocumentB修饰的BB类
    @DocumentB
    class CC{}

    //DD类继承CC类
    class DD extends CC{}

    class ExtendDemo{
        public static void main(String[] args) {
            AA b = new BB();
            //[@cn.gs.annotation.DocumentA()] 说明了BB还有DocumentA注解
            System.out.println(Arrays.toString(b.getClass().getAnnotations()));

            CC c = new DD();
            //[]
            System.out.println(Arrays.toString(c.getClass().getAnnotations()));
        }
    }

    可以看出子类BB还可以通过使用反射来获取到父类被 @Inherited 修饰的注解。

写一个简单的SQL注解

下面我们写一个简单的 sql 注解，在我们的数据库中可能存在这样的一个数据表 Member，它有下面一些字段：

  1. id号，主键类型
  2. 姓名
  3. 年龄
  4. 个人描述，可以为空

我们可以通过我们学过的注解知识去描述这个数据表，具体代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
//表注解
@Target(ElementType.FIELD) //只能应用于类上
@Retention(RetentionPolicy.RUNTIME) //保存在运行时
@interface DBTable {
    String name() default "";
}
//注解Integer类型的字段
@interface SQLInteger{
    //该字段对应的数据库列名
    String name() default "";
    //嵌套注解
    Constraints constraint() default @Constraints;
}
//注解String类型的字段
@interface SQLString{
    //该字段对应的数据库列名
    String name() default "";
    //列类型分配的长度，如varchar(30)的30
    int size() default 30;
    //嵌套注解
    Constraints constraint() default @Constraints;
}
//约束注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Constraints{
    //判断是否作为主键约束
    boolean primaryKey() default false;
    //判断是否允许为null
    boolean allowNull() default false;
    //判断是否唯一
    boolean unique() default false;
}

//数据库表
public class Member {
    //主键id
    @SQLString(name = "ID",size = 50 ,constraint = @Constraints(primaryKey = true))
    private String id;
    //姓名
    @SQLString(name = "NAME",size = 30)
    private String name;
    //年龄
    @SQLInteger(name = "AGE")
    private int age;
    //个人描述
    @SQLString(name = "DESC",size = 100,constraint = @Constraints(allowNull = true))
    private String desc;
    //省略getter、setter等
}

上述定义4个注解，分别是 @DBTable(用于类上)、@Constraints(用于字段上)、@SQLString(用于字段上)、@SQLString(用于字段上) 并在 Member 类中使用这些注解，我们使用了嵌套注解 @Constraints，该注解主要用于判断字段是否为 null 或者字段是否唯一。必须清楚认识到上述提供的注解生命周期必须为@Retention(RetentionPolicy.RUNTIME)，即运行时，这样才可以使用反射机制获取其信息。之后我们可以通过反射编写注解处理器，就不写了。

元注解@Repeatable

元注解 @Repeatable 是 JDK1.8新加入的，它表示在同一个位置重复相同的注解。在没有该注解前，一般是无法在同一个类型上使用相同的注解的

1
2
3
4
//Java8前无法这样使用
@FilterPath("/web/update")
@FilterPath("/web/add")
public class A {}

Java 8前如果是想实现类似的功能，我们需要在定义 @FilterPath 注解时定义一个数组元素接收多个值如下

1
2
3
4
5
6
7
8
9
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface FilterPath {
    String [] value();
}

//使用
@FilterPath({"/update","/add"})
public class A { }123456789

但在 Java 8新增了 @Repeatable 注解后就可以采用如下的方式定义并使用了

1
2
3
4
5
6
7
8
9
10
11
12
13
//使用Java8新增@Repeatabl元注解
@Target({ElementType.FIELD,ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(FilterPaths.class)//参数指明接收的注解class
public @interface FilterPath {
    String value();
}

@Target({ElementType.FIELD,ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface FilterPaths {
    FilterPath[] value();
}