Java 反射是Java语言的一个很重要的特征。它允许运行中的 Java 程序对自身进行检查,并能直接操作程序的内部属性。例如,使用它能获得Java 类中各成员的名称并显示出来。
Java 反射机制主要提供了以下功能:
a.在运行时判断任意一个对象所属的类。
b.在运行时构造任意一个类的对象。
c.在运行时判断任意一个类所具有的成员变量和方法。
d.在运行时调用任意一个对象的方法。
在JDK中,主要由以下类来实现Java反射机制,这些类在java.lang.reflect包中:
Class类:代表一个类。
Field 类:代表类的成员变量(成员变量也称为类的属性)。
Method类:代表类的方法。
Constructor 类:代表类的构造方法。
Array类:提供了动态创建数组,以及访问数组的元素的静态方法。
下面写了一个程序:设计了一个POJO类。所谓POJO类,本人粗浅的理解即和JavaBean类似,只有字段和setter/getter方法。然后在主函数通过反射,在控制台打印该POJO类的所有字段和方法。
本人设计的POJO类为WorkerPOJO.java,然后另一个测试类为POJOReflection.java,在main函数中负责打印该类的所有字段和方法。程序见下:
WorkerPOJO.java:
1
package com.xpec.landon.trainjava.annotation;
2
/** *//**
3
* POJO类,和JavaBean相似
4
* @author landon
5
*
6
*/
7
public class WorkerPOJO
{
8
private String name;
9
private int age;
10
11
/** *//**
12
* 用Annotation修饰
13
* @return 姓名
14
*/
15
@WorkerPOJOAnnotation(name = "landon",age = 22)
16
public String getName()
{
17
return name;
18
}
19
public void setName(String name)
{
20
this.name = name;
21
}
22
public int getAge()
{
23
return age;
24
}
25
public void setAge(int age)
{
26
this.age = age;
27
}
28
29
}
30
31
POJOReflection.java:
1
package com.xpec.landon.trainjava.annotation;
2
import java.lang.reflect.Field;
3
import java.lang.reflect.Modifier;
4
import java.lang.reflect.Method;
5
6
7
/** *//**
8
* 运用Java的反射机制,输出POJO类的字段和方法(新增了Annotation的修饰)
9
* @author landon
10
*
11
*/
12
public class POJOReflectionTest
{
13
public static void main(String[] args)
14
{
15
try
16
{
17
//加载WorkPOJO,注意这里一定要写全类名,包括包名,因为包名是类名的一部分
18
Class pojo = Class.forName("com.xpec.landon.trainjava.annotation.WorkerPOJO");
19
//获取域的数组
20
Field []fieldList = pojo.getDeclaredFields();
21
//获取方法的数组
22
Method []methodList = pojo.getDeclaredMethods();
23
24
System.out.println("WorkerPOJO类的所有字段:");
25
System.out.println("修饰符" + " " + "类型" + " " + "字段名");
26
27
for(int i = 0;i < fieldList.length;i++)
28
{
29
Field field = fieldList[i];
30
//用下面的形式获取具体的修饰符
31
System.out.println(Modifier.toString(field.getModifiers()) + " " + field.getType() + " " + field.getName());
32
}
33
34
System.out.println();
35
System.out.println("WorkerPOJO类的所有方法(不包括annotation修饰的方法):");
36
37
for(int j = 0;j < methodList.length;j++)
38
{
39
Method method = methodList[j];
40
//判断方法是否被Annotation修饰
41
boolean methodAnnotation = method.isAnnotationPresent(WorkerPOJOAnnotation.class);
42
43
//如果被annotation修饰,则过滤掉该方法,即不输出
44
if(methodAnnotation)
45
{
46
continue;
47
}
48
//获取方法参数列表
49
Class parameters[] = method.getParameterTypes();
50
51
System.out.print(Modifier.toString(method.getModifiers()) + " " + method.getReturnType() + " " + method.getName() + " (");
52
53
for(int k = 0;k < parameters.length;k++)
54
{
55
System.out.print(parameters[k].toString());
56
}
57
58
System.out.println(")");
59
}
60
}
61
catch(ClassNotFoundException exception1)
62
{
63
exception1.printStackTrace();
64
}
65
66
}
67
68
}
69
70
下面是程序的一个运行截图:

可以看到,在WorkerPOJO类中引入了Annotation。下面,我们详细介绍一下Annotation:
在使用JUnit4中,我们可以看到在每个测试方法前面都有一个@Test标记,这就是传说中的Annotation。
Annotation 提供了一条与程序元素关联任何信息或者任何元数据(metadata)的途径。从某些方面看,annotation就像修饰符一样被使用,并应用于包、类型、构造方法、方法、成员变量、参数、本地变量的声明中。这些信息被存储在annotation的“name=value”结构对中。 annotation类型是一种接口,能够通过java反射API的方式提供对其信息的访问。
annotation能被用来为某个程序元素(类、方法、成员变量等)关联任何的信息。需要注意的是,这里存在着一个基本的潜规则:annotaion不能影响程序代码的执行,无论增加、删除 annotation,代码都始终如一的执行。另外,尽管一些annotation通过java的反射api方法在运行时被访问,而java语言解释器在工作时忽略了这些annotation。正是由于java虚拟机忽略了annotation,导致了annotation类型在代码中是“不起作用”的;只有通过某种配套的工具才会对annotation类型中的信息进行访问和处理。
annotation是与一个程序元素相关联信息或者元数据的标注。它从不影响
ava程序的执行,但是对例如编译器警告或者像文档生成器等辅助工具产生影响。
我的理解是:Annotation是继承自java.lang.annotation.Annotation的类,用于向程序分析工具或虚拟机提供package class field methed 等方面的信息,它和其他类没什么区别,除了使用方式。
下面写了一个简单的Annotation:WorkerPOJOAnnotation.java
1
package com.xpec.landon.trainjava.annotation;
2
import java.lang.annotation.Documented;
3
import java.lang.annotation.ElementType;
4
import java.lang.annotation.Retention;
5
import java.lang.annotation.RetentionPolicy;
6
import java.lang.annotation.Target;
7
8
/** *//**
9
* 修饰WorkerPOJO类方法的一个Annotation
10
* @author landon
11
*
12
*/
13
14
@Target(ElementType.METHOD)
15
@Retention(RetentionPolicy.RUNTIME)
16
@Documented
17
public @interface WorkerPOJOAnnotation
{
18
String name();
19
int age();
20
21
}
22
23
其中@Target里面的ElementType是用来指定Annotation类型可以用在哪一些元素上的,包括TYPE(类型),METHOD(方法),FIELD(字段),PARAMETER(参数)等。其中TYPE是指可以用在Class,Interface等类型上。下面给出用jad反编译出的ElementType中的静态变量的截图:

另外@Retention中的RetentionPolicy是指Annotation中的信息保留方式,分别是SOURCE,CLASS 和 RUNTIME. SOURCE代表的是这个Annotation类型的信息只会保留在程序源码里,源码如果经过了编译之后,Annotation的数据就会消失,并不会保留在编译好的.class文件里面。 ClASS的意思是这个Annotation类型的信息保留在程序源码里,同时也会保留在编译好的.class文件里面,在执行的时候,并不会把这一些信息加载到虚拟机(JVM)中去.注意一下,当你没有设定一个Annotation类型的Retention值时,系统默认值是CLASS. 第三个,是RUNTIME,表示在源码、编译好的.class文件中保留信息,在执行的时候会把这一些信息加载到JVM中去的.
下面给出用jad反编译出的RetentionPolicy中的静态变量的截图

最后的一个Annotation@Documented是指目的就是让这一个Annotation类型的信息能够显示在Java API说明文档上。
下面将上面自己设计的WorkerPOJOAnnotation应用在了WorkerPOJO类的一个方法前面:
然后在控制台输出了没有被Annotation注释的字段和方法,运行后可以看到不包括getName方法。
最后我们可以用Junit4书写一个测试用例: POJOReflectionJunit4Test.java
1
package com.xpec.landon.trainjava.annotation;
2
import java.lang.reflect.Field;
3
import java.lang.reflect.Method;
4
5
import javax.activation.FileDataSource;
6
7
import junit.framework.Assert;
8
9
import org.junit.After;
10
import org.junit.Before;
11
import org.junit.Test;
12
13
/** *//**
14
* 关于Java反射以及Annotation的一个TestCase
15
* @author landon
16
*
17
*/
18
19
public class POJOReflectionJunit4Test
{
20
private Class pojo;
21
private Field []fieldList;
22
private Method[] methodList;
23
24
@Before
25
public void setUp() throws Exception
{
26
//加载类WorkPOJO
27
pojo = Class.forName("com.xpec.landon.trainjava.annotation.WorkerPOJO");
28
//获取域的数组
29
fieldList = pojo.getDeclaredFields();
30
//获取方法的数组
31
methodList = pojo.getDeclaredMethods();
32
}
33
34
//测试字段和方法的个数
35
@Test
36
public void testSize()
37
{
38
Assert.assertEquals(2, fieldList.length);
39
Assert.assertEquals(4, methodList.length);
40
}
41
42
//测试字段是否带有annotations
43
@Test
44
public void isFieldAnnotation()
45
{
46
for(int i = 0;i < fieldList.length;i++)
47
{
48
Assert.assertEquals(false, fieldList[i].isAnnotationPresent(WorkerPOJOAnnotation.class));
49
}
50
}
51
52
//测试方法是否带有annotations
53
@Test
54
public void isMethodAnnotation()
55
{
56
for(int i = 0;i < methodList.length;i++)
57
{
58
Assert.assertEquals(false, methodList[i].isAnnotationPresent(WorkerPOJOAnnotation.class));
59
}
60
}
61
62
@After
63
public void tearDown() throws Exception
{
64
}
65
66
}
67
posted on 2010-07-14 12:19
landon 阅读(2680)
评论(0) 编辑 收藏 所属分类:
Program