一篇全面介绍Java注解的文章(转自codekongs博客)

java高级特性-----注解(Annotation)

一、java中的常见注解:

1 . jdk自带的注解。 

@Override —— 必须被覆盖的方法

@Deprecated —— 被废弃的方法

@SuppressWarnings —— 忽略警告

上面这些都是我们在java中常见的注解

2 . 第三方的常见注解

在Spring等框架中都使用了第三方的注解。

二、注解的分类

按照运行机制分类

1 . 源码注解。注解只存在于源码中，在.class文件中不存在。

2 . 编译时注解。注解在源码和.class文件中都存在。

3 . 运行时注解。注解在运行阶段还会起作用，甚至会影响运行逻辑。

按照来源分类

1 . 来自JDK的注解

2 . 来自第三方的注解

3 . 我们自定义的注解

这里再补充一个概念：

元注解

 , 即给注解注解，是注解的注解

三、自定义注解的语法要求

1 . 使用

@interface

关键字定义注解.

2 . 成员以无参数无异常的方式声明.

3 . 可以用

default

为成员指定默认值.

4 . 成员的类型是受限制的.

合法的类型包括java的基本数据类型以及

String，Class，Annotation，Enumeration

5 . 如果注解只有一个成员,则成员名必须取为

value()

,在使用时可以忽略成员名和

=

.

6 . 注解类可以没有成员,没有成员的注解类叫做

标识注解

.

package com.codekong.test;

//使用@interface关键字定义注解
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface AnnTest1 {
//成员以无参数无异常的方式声明
String desc();
String author();
//可以用default为成员指定默认值
int age() default 18;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

上面的代码中我们可以看到

元注解

,就是下面的这一段:

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented

1
2
3
4

1 . 

Target

是表示注解的作用域

该作用域的列表有

构造方法声明(CONSTRUCTOR)

、

字段的声明(FIELD)

、

局部变量声明(LOCAL_VARIABLE)

、

方法声明(METHOD)

、

包声明(PACKAGE)

、

参数声明(PARAMETER)

、

类接口(TYPE)

。上面的例子中就是声明了方法声明和类接口。

2 . 

Retention

是表示注解的生命周期

此处的生命周期我们可以看前面的

注解按运行机制分类

。包括

SOURCE(只在源码显示,编译时会丢弃)

、

CLASS(编译时会记录到class中,运行时会丢弃)

、

RUNTIME(运行时存在,可以通过反射读取)

上面的例子给出的是运行时注解。

3 . 

Inherited

是标识型的元注解.例子中的注解表示允许子类继承

4 . 

Documented

表示生成javadoc时会包含注解信息.

四、使用自定义注解

使用注解的语法如下:

@<注解名>(<成员名1>=<成员值1>,<成员名2>=<成员值2>,...)

1

下面的代码就是在一个方法上使用我们上面定义的注解

@AnnTest1(desc="yes class",author="moer class",age=20)
public class AnnTestDemo {
@AnnTest1(desc="yes method",author="moer method",age=20)
public String bing() {
return "mo";
}
}

1
2
3
4
5
6
7

五、解析注解

我们在前面定义了注解,也使用了注解,那我们如何拿到使用注解时传入的值呢,这里我们就需要解析注解,下面我们在前面程序的基础上解析注解,主要分为以下几个步骤.

1 . 使用类加载器加载类

2 . 判断类上面是否有我们自定义的注解

3 . 拿到类上面我们自定义的注解的实例

4 . 拿到给定类所包含的方法

5 . 遍历所有的方法,拿到方法上的注解

下面是具体的代码

public class ParseAnn {
public static void main(String[] args) {

try {
//1.使用类加载器加载类
Class c = Class.forName("com.codekong.test.AnnTestDemo");
//2.找到类上面的注解
//先判断AnnTestDemo类上面有没有AnnTest1这样的注解
boolean isExist = c.isAnnotationPresent(AnnTest1.class);
if(isExist){
//3.拿到类上的注解实例
AnnTest1 ann = (AnnTest1) c.getAnnotation(AnnTest1.class);
System.out.println(ann.author());
}
//4.找到方法上的注解
//拿到给定类所包含的方法
Method []methods = c.getMethods();
//遍历方法
for(Method m : methods){
boolean isMExist = m.isAnnotationPresent(AnnTest1.class);
if(isMExist){
//拿到每一个方法上的注解
AnnTest1 annm = m.getAnnotation(AnnTest1.class);
System.out.println(annm.author());
}
}
//另外一种解析方法
//遍历所有的方法
for(Method m : methods){
//拿到每个方法上的注解
Annotation[] as = m.getAnnotations();
for (Annotation a : as) {
if(a instanceof AnnTest1){
AnnTest1 ann = (AnnTest1) a;
System.out.println(ann.author());
}
}
}
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

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

运行结果

moer class
moer method
moer method

1
2
3

注:如果我们在第三步定义自己的注解的时候,将

@Retention(RetentionPolicy.RUNTIME)

改为

@Retention(RetentionPolicy.SOURCE)

或者

@Retention(RetentionPolicy.CLASS)

,运行上面的程序是不会出现任何结果.因为只有运行时注解可以通过反射获取,其他两种注解在运行时已经被丢弃了.

六、注解实战

上面说了那么多,下面我们通过一个实际的例子来练习一下直接的使用

这个例子中我们要求利用注解,我们传入要查询的bean对象,最终输出对应的拼接好的sql语句。

例如:我们定义一个User类,其中有字段

username

和

password

,我们new一个对象

User
user = new User("sss", "123aaa");

 

传入user对象，最终输出

select * from user where 1=1 and user_name='sss' and password='123aaa'

下面我们开始一步步做

1 . 新建

Filter.java

类.其中的代码如下

package com.codekong.test;

@Table("user")
public class Filter {
@Columns("user_name")
private String username;
@Columns("password")
private String password;

public void setUsername(String username) {
this.username = username;
}

public void setPassword(String password) {
this.password = password;
}

public String getUsername() {
return username;
}

public String getPassword() {
return password;
}
}

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

其实就是一个bean,定义两个字段

username

和

password

,我们利用注解把数据表的表名

user

和表中的对应的字段的名称加上去.

2 . 我们定义

Table.java

和

Columns

两个注解类.代码如下

package com.codekong.test;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.TYPE})     //类注解
@Retention(RetentionPolicy.RUNTIME)  //运行时注解
@Inherited                           //允许类或接口继承
@Documented                          //生成javadoc是包含注解
public @interface Table {
//如果注解只有一个成员,则成员名必须取为value(),在使用时可以忽略成员名和=
String value();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

package com.codekong.test;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.FIELD})            //字段名注解
@Retention(RetentionPolicy.RUNTIME)  //运行时注解
@Inherited                           //允许类或接口继承
@Documented                          //生成javadoc是包含注解
public @interface Columns {
//如果注解只有一个成员,则成员名必须取为value(),在使用时可以忽略成员名和=
String value();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

上面最主要的要注意,

@Target

注解是根据注解的作用域定义,

Table

是类的注解,

Columns

是字段的注解,并且由于我们要在后面利用反射取到定义的值,所以生命周期为运行时注解.

3 . 定义

TestDemo.java

这个测试类,并且其中最主要的是

query()

方法.代码如下

package com.codekong.test;

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

public class TestDemo {
public static void main(String[] args) {

Filter f1 = new Filter();
f1.setUsername("moer");

Filter f2 = new Filter();
f2.setUsername("bing");
f2.setPassword("123a");

System.out.println(query(f1));
System.out.println(query(f2));
}

/**
* 传入Filter对象,返回对应的sql查询语句
* @param f
* @return
*/
private static String query(Filter f) {
//用来拼接字符串
StringBuilder sb = new StringBuilder();
sb.append("select * from ");
String tableName = null;
//获得Filter类的类类型(加载类)
Class<? extends Filter> filter = f.getClass();

//是否存在我们需要找的注解
boolean isExist = filter.isAnnotationPresent(Table.class);
if(!isExist){
return null;
}else{
//拿到注解的实例
Table t = (Table) filter.getAnnotation(Table.class);
//拿到表名
tableName = t.value();
}

sb.append(tableName).append(" where 1=1");

//取出所有的字段
Field[] fields = filter.getDeclaredFields();
for (Field field : fields) {
//处理每个字段对应的sql
//先拿到字段名和字段值再拼装
boolean ismExist = field.isAnnotationPresent(Columns.class);
if(!ismExist){
continue;
}

//拿到字段注解的实例
Columns col = (Columns) field.getAnnotation(Columns.class);
//拿到sql的列名
String columnValue = col.value();

//拿到字段名
String fieldName = field.getName();
//拼接出每个字段的get方法(例如: getUsername)
String getMethodName = "get" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
String fieldValue = null;

try {
//通过反射获得get方法
Method getMethod = filter.getMethod(getMethodName);
//通过反射执行get方法拿到字段的值
fieldValue = (String) getMethod.invoke(f);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if(fieldValue != null){
//拼装sql
sb.append(" and ").append(columnValue).append("='").append(fieldValue).append("'");
}

}

return sb.toString();
}
}

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

最终的运行结果:

select * from user where 1=1 and user_name='moer'
select * from user where 1=1 and user_name='bing' and password='123a'

1
2

好了,以上就是有关注解的介绍,希望可以通过本篇文章帮助到需要的人。