java的反射机制
在Java运行时环境中，对于任意一个类，能否知道这个类有哪些属性和方法？对于任意一个对象，能否调用它的任意一个方法？答案是肯定的。这种动态获取类的信息，以及动态调用对象的方法的功能来自于Java语言的反射（Reflection）机制。Java反射机制主要提供了以下功能：
1.在运行时判断任意一个对象所属的类；
2.在运行时构造任意一个类的对象；
3.在运行时判断任意一个类所具有的成员变量和方法；
4.在运行时调用任意一个对象的方法；
5.生成动态代理。
Reflection 是 Java 被视为动态（或准动态）语言的关键，允许程序于执行期利用Reflection APIs 取得任何已知名称之 class 的內部信息，包括 package、type、parameters、superclass、implemented interfaces、inner classes、 outer class、fields、constructors、methods、modifiers，並可于执行期生成instances、变更 fields 內容或唤起 methods。
Java Reflection API简介
在JDK中，主要由以下类来实现Java反射机制，这些类都位于java.lang.reflect包中。
◆ Class类：代表一个类。
◆ Field类：代表类的成员变量（成员变量也称为类的属性）。
◆ Method类：代表类的方法。
◆ Constructor类：代表类的构造方法。
◆ Array类：提供了动态创建数组，以及访问数组元素的静态方法。
| Field类： |
提供有关类或接口的属性的信息，以及对它的动态访问权限。反射的字段可能是一个类（静态）属性或实例属性，简单的理解可以把它看成一个封装反射类的属性的类。 |
| Constructor类： | 提供关于类的单个构造方法的信息以及对它的访问权限。这个类和Field类不同，Field类封装了反射类的属性，而Constructor类则封装了反射类的构造方法。 |
| Method类： | 提供关于类或接口上单独某个方法的信息。所反映的方法可能是类方法或实例方法（包括抽象方法）。 这个类不难理解，它是用来封装反射类方法的一个类。 |
| Class类： | 类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类，注释是一种接口。每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。 |
| Object类： | 每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。 |
Java的反射类能做什么
一些简单的小例子来说明它。我们来看一下通过Java的反射机制我们能得到些什么。
1
.
import
java.awt.event.ActionListener;
2
.
import
java.awt.event.ActionEvent;
3
.
class
A
extends
Object
implements
ActionListener{
4
.
private
int
a
=
3
;
5
.
public
Integer b
=
new
Integer(
4
);
6
.
public
A(){}
7
.
public
A(
int
id,String name){}
8
.
public
int
abc(
int
id,String name){
return
0
;}
9
.
public
void
actionPerformed(ActionEvent e){}
10
. }
你可能被我这个类弄糊涂了，你看不出我要做什么，那就不要看这个类了，这个类是用来测试的，你知道知道它继承了Object类，有一个接口是ActionListener，两个属性int和Integer,两个构造方法和两个方法，这就足够了。下面我们把A这个类作为一个反射类，来过去A类中的一些信息，首先我们先来过去一下反射类中的属性和属性值。
1
.
import
java.lang.reflect.
*
;
2
.
class
B{
3
.
public
static
void
main(String args[]){
4
. A r
=
new
A();
5
. Class temp
=
r.getClass();
6
.
try
{
7
. System.out.println(
"
反射类中所有公有的属性
"
);
8
. Field[] fb
=
temp.getFields();
9
.
for
(
int
j
=
0
;j
<
fb.length;j
++
){
10
. Class cl
=
fb[j].getType();
11
. System.out.println(
"
fb:
"
+
cl);
12
. }
13
.
14
. System.out.println(
"
反射类中所有的属性
"
);
15
. Field[] fa
=
temp.getDeclaredFields();
16
.
for
(
int
j
=
0
;j
<
fa.length;j
++
){
17
. Class cl
=
fa[j].getType();
18
. System.out.println(
"
fa:
"
+
cl);
19
. }
20
. System.out.println(
"
反射类中私有属性的值
"
);
21
. Field f
=
temp.getDeclaredField(
"
a
"
);
22
. f.setAccessible(
true
);
23
. Integer i
=
(Integer)f.get(r);
24
. System.out.println(i);
25
. }
catch
(Exception e){
26
. e.printStackTrace();
27
. }
28
. }
29
. }
这里用到了两个方法，getFields()、getDeclaredFields()，它们分别是用来获取反射类中所有公有属性和反射类中所有的属性的方 法。另外还有getField(String)和getDeclaredField(String)方法都是用来过去反射类中指定的属性的方法，要注意的 是getField方法只能取到反射类中公有的属性，而getDeclaredField方法都能取到。
这里还用到了Field 类的setAccessible方法，它是用来设置是否有权限访问反射类中的私有属性的，只有设置为true时才可以访问，默认为false。另外 Field类还有set(Object AttributeName,Object value)方法，可以改变指定属性的值。
下面我们来看一下如何获取反射类中的构造方法。
<p>
下面我们再来获取一下反射类的父类（超类）和接口
1
.
import
java.io.
*
;
2
.
import
java.lang.reflect.
*
;
3
.
4
.
public
class
SampleInterface {
5
.
public
static
void
main(String[] args)
throws
Exception {
6
. A raf
=
new
A();
7
. printInterfaceNames(raf);
8
. }
9
.
10
.
public
static
void
printInterfaceNames(Object o) {
11
. Class c
=
o.getClass();
12
.
//
获取反射类的接口
13
. Class[] theInterfaces
=
c.getInterfaces();
14
.
for
(
int
i
=
0
; i
<
theInterfaces.length; i
++
)
15
. System.out.println(theInterfaces[i].getName());
16
.
//
获取反射类的父类（超类）
17
. Class theSuperclass
=
c.getSuperclass();
18
. System.out.println(theSuperclass.getName());
19
. }
20
. }
这 个例子也很简单，只是用Class类的getInterfaces()方法获取反射类的所有接口，由于接口可以有多个，所以它返回一个 Class数组。用getSuperclass()方法来获取反射类的父类（超类），由于一个类只能继承自一个类，所以它返回一个Class对象。
下面我们来获取一下反射类的方法
1
.
import
java.lang.reflect.
*
;
2
.
public
class
SampleMethod {
3
.
4
.
public
static
void
main(String[] args) {
5
. A p
=
new
A();
6
. printMethods(p);
7
. }
8
.
9
.
public
static
void
printMethods(Object o) {
10
. Class c
=
o.getClass();
11
. String className
=
c.getName();
12
. Method[] m
=
c.getMethods();
13
.
for
(
int
i
=
0
; i
<
m.length; i
++
) {
14
.
//
输出方法的返回类型
15
. System.out.print(m[i].getReturnType().getName());
16
.
//
输出方法名
17
. System.out.print(
"
"
+
m[i].getName()
+
"
(
"
);
18
.
//
获取方法的参数
19
. Class[] parameterTypes
=
m[i].getParameterTypes();
20
.
for
(
int
j
=
0
; j
<
parameterTypes.length; j
++
){
21
. System.out.print(parameterTypes[j].getName());
22
.
if
(parameterTypes.length
>
j
+
1
){
23
. System.out.print(
"
,
"
);
24
. }
25
. }
26
.
27
. System.out.println(
"
)
"
);
28
. }
29
.
30
. }
31
.
32
. }
这个例子并不难，它只是获得了反射类的所有方法，包括继承自它父类的方法。然后获取方法的返回类型、方法名和方法参数。
接下来让我们回过头来想一想，我们获取了反射类的属性、构造方法、父类、接口和方法，可这些东西能帮我们做些什么呢！！
下面我写一个比较完整的小例子，来说明Java的反射类能做些什么吧！！
1
.
import
java.lang.reflect.Constructor;
2
.
import
java.lang.reflect.Method;
3
.
4
.
public
class
LoadMethod {
5
.
public
Object Load(String cName,String MethodName,String[] type,String[] param){
6
. Object retobj
=
null
;
7
.
try
{
8
.
//
加载指定的Java类
9
. Class cls
=
Class.forName(cName);
10
.
11
.
//
获取指定对象的实例
12
. Constructor ct
=
cls.getConstructor(
null
);
13
. Object obj
=
ct.newInstance(
null
);
14
.
15
.
//
构建方法参数的数据类型
16
. Class partypes[]
=
this
.getMethodClass(type);
17
.
18
.
//
在指定类中获取指定的方法
19
. Method meth
=
cls.getMethod(MethodName, partypes);
20
.
21
.
//
构建方法的参数值
22
. Object arglist[]
=
this
.getMethodObject(type,param);
23
.
24
.
//
调用指定的方法并获取返回值为Object类型
25
. retobj
=
meth.invoke(obj, arglist);
26
.
27
. }
28
.
catch
(Throwable e) {
29
. System.err.println(e);
30
. }
31
.
return
retobj;
32
. }
33
.
34
.
//
获取参数类型Class[]的方法
35
.
public
Class[] getMethodClass(String[] type){
36
. Class[] cs
=
new
Class[type.length];
37
.
for
(
int
i
=
0
; i
<
cs.length; i
++
) {
38
.
if
(
!
type[i].trim().equals(
""
)
||
type[i]
!=
null
){
39
.
if
(type[i].equals(
"
int
"
)
||
type[i].equals(
"
Integer
"
)){
40
. cs[i]
=
Integer.TYPE;
41
. }
else
if
(type[i].equals(
"
float
"
)
||
type[i].equals(
"
Float
"
)){
42
. cs[i]
=
Float.TYPE;
43
. }
else
if
(type[i].equals(
"
double
"
)
||
type[i].equals(
"
Double
"
)){
44
. cs[i]
=
Double.TYPE;
45
. }
else
if
(type[i].equals(
"
boolean
"
)
||
type[i].equals(
"
Boolean
"
)){
46
. cs[i]
=
Boolean.TYPE;
47
. }
else
{
48
. cs[i]
=
String.
class
;
49
. }
50
. }
51
. }
52
.
return
cs;
53
. }
54
.
55
.
//
获取参数Object[]的方法
56
.
public
Object[] getMethodObject(String[] type,String[] param){
57
. Object[] obj
=
new
Object[param.length];
58
.
for
(
int
i
=
0
; i
<
obj.length; i
++
) {
59
.
if
(
!
param[i].trim().equals(
""
)
||
param[i]
!=
null
){
60
.
if
(type[i].equals(
"
int
"
)
||
type[i].equals(
"
Integer
"
)){
61
. obj[i]
=
new
Integer(param[i]);
62
. }
else
if
(type[i].equals(
"
float
"
)
||
type[i].equals(
"
Float
"
)){
63
. obj[i]
=
new
Float(param[i]);
64
. }
else
if
(type[i].equals(
"
double
"
)
||
type[i].equals(
"
Double
"
)){
65
. obj[i]
=
new
Double(param[i]);
66
. }
else
if
(type[i].equals(
"
boolean
"
)
||
type[i].equals(
"
Boolean
"
)){
67
. obj[i]
=
new
Boolean(param[i]);
68
. }
else
{
69
. obj[i]
=
param[i];
70
. }
71
. }
72
. }
73
.
return
obj;
74
. }
75
. }
这是我在工作中写的一个实现Java在运行时加载指定的类，并调用指定方法的一个小例子。这里没有main方法，你可以自己写一个。
Load方法接收的五个参数分别是，Java的类名，方法名，参数的类型和参数的值。
结束语：
Java 语言反射提供一种动态链接程序组件的多功能方法。它允许程序创建和控制任何类的对象，无需提前硬编码目标类。这些特性使得反射特别适用于创建以非常普通的 方式与对象协作的库。Java reflection 非常有用，它使类和数据结构能按名称动态检索相关信息，并允许在运行着的程序中操作这些信息。Java 的这一特性非常强大，并且是其它一些常用语言，如 C、C++、Fortran 或者 Pascal 等都不具备的。
但反射有两个缺点。第一个是性能问题。用于字段和方法接入时反射要远 慢于直接代码。性能问题的程度取决于程序中是如何使用反射的。如果它作为程序运行中相对很少涉及的部分，缓慢的性能将不会是一个问题。即使测试中最坏情况 下的计时图显示的反射操作只耗用几微秒。仅反射在性能关键的应用的核心逻辑中使用时性能问题才变得至关重要。
转自：http://www.cnblogs.com/bingoidea/archive/2009/06/21/1507889.html
参看：http://expert.51cto.com/art/200702/40213.htm 节选自《Java网络编程精解》