java反射机制

反射机制:所谓的反射机制就是java语言在运行时拥有一项自观的能力。通过这种能力可以彻底的了解自身的情况为下一步的动作做准备。下面具体介绍一下java的反射机制。这里你将颠覆原来对java的理解。
Java 的反射机制的实现要借助于4个类：class，Constructor，Field，Method；其中class代表的时类对象，Constructor－类的构造器对象，Field－类的属性对象，Method－类的方法对象。通过这四个对象我们可以粗略的看到一个类的各个组成部分。

Class：程序运行时，java运行时系统会对所有的对象进行运行时类型的处理。这项信息记录了每个对象所属的类，虚拟机通常使用运行时类型信息选择正确的方法来执行（摘自：白皮书）。但是这些信息我们怎么得到啊，就要借助于class类对象了啊。在Object类中定义了getClass()方法。我们可以通过这个方法获得指定对象的类对象。然后我们通过分析这个对象就可以得到我们要的信息了。

比如：ArrayList arrayList;

Class clazz = arrayList.getClass();

然后我来处理这个对象clazz。

当然了Class类具有很多的方法，这里重点将和Constructor，Field，Method类有关系的方法。

Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。Java 的这一能力在实际应用中也许用得不是很多，但是个人认为要想对java有个更加深入的了解还是应该掌握的。

1．检测类：

reflection的工作机制

考虑下面这个简单的例子，让我们看看 reflection 是如何工作的。

 1 import java.lang.reflect.*;
 2 
 3 public class DumpMethods {
 4 
 5     public static void main(String args[]) {
 6     
 7         try {
 8         
 9             Class c = Class.forName(args[0]);
10             
11             Method m[] = c.getDeclaredMethods();
12             
13             for (int i = 0; i < m.length; i++)
14             
15             System.out.println(m[i].toString());
16         
17         } catch (Throwable e) {
18         
19             System.err.println(e);
20         
21         }
22     
23     }
24 
25 }

按如下语句执行：

java DumpMethods java.util.ArrayList

这个程序使用 Class.forName 载入指定的类，然后调用 getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描述某个类中单个方法的一个类。

Java类反射中的主要方法

对于以下三类组件中的任何一类来说 -- 构造函数、字段和方法 -- java.lang.Class 提供四种独立的反射调用，以不同的方式来获得信息。调用都遵循一种标准格式。以下是用于查找构造函数的一组反射调用：

Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的公共构造函数，

Constructor[] getConstructors() -- 获得类的所有公共构造函数

Constructor getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(与接入级别无关)

Constructor[] getDeclaredConstructors() -- 获得类的所有构造函数(与接入级别无关)

获得字段信息的Class 反射调用不同于那些用于接入构造函数的调用，在参数类型数组中使用了字段名：

Field getField(String name) -- 获得命名的公共字段

Field[] getFields() -- 获得类的所有公共字段

Field getDeclaredField(String name) -- 获得类声明的命名的字段

Field[] getDeclaredFields() -- 获得类声明的所有字段

用于获得方法信息函数：

Method getMethod(String name, Class[] params) -- 使用特定的参数类型，获得命名的公共方法

Method[] getMethods() -- 获得类的所有公共方法

Method getDeclaredMethod(String name, Class[] params) -- 使用特写的参数类型，获得类声明的命名的方法

Method[] getDeclaredMethods() -- 获得类声明的所有方法

使用 Reflection：

用于 reflection 的类，如 Method，可以在 java.lang.relfect 包中找到。使用这些类的时候必须要遵循三个步骤：第一步是获得你想操作的类的 java.lang.Class 对象。在运行中的 Java 程序中，用 java.lang.Class 类来描述类和接口等。

下面就是获得一个 Class 对象的方法之一：

Class c = Class.forName("java.lang.String");

这条语句得到一个 String 类的类对象。还有另一种方法，如下面的语句：

Class c = int.class;

或者

Class c = Integer.TYPE;

它们可获得基本类型的类信息。其中后一种方法中访问的是基本类型的封装类 (如 Intege ) 中预先定义好的 TYPE 字段。

第二步是调用诸如 getDeclaredMethods 的方法，以取得该类中定义的所有方法的列表。

一旦取得这个信息，就可以进行第三步了——使用 reflection API 来操作这些信息，如下面这段代码：

Class c = Class.forName("java.lang.String");

Method m[] = c.getDeclaredMethods();

System.out.println(m[0].toString());

它将以文本方式打印出 String 中定义的第一个方法的原型。

处理对象：

a.创建一个Class对象

b.通过getField 创建一个Field对象

c.调用Field.getXXX(Object)方法(XXX是Int,Float等，如果是对象就省略；Object是指实例).

例如：

 1 import java.lang.reflect.*;
 2 
 3 import java.awt.*;
 4 
 5 class SampleGet {
 6 
 7     public static void main(String[] args) {
 8 
 9         Rectangle r = new Rectangle(100, 325);
10 
11         printHeight(r);
12 
13     }
14 
15     static void printHeight(Rectangle r) {
16 
17         Field heightField;
18 
19         Integer heightValue;
20 
21         Class c = r.getClass();
22 
23         try {
24 
25             heightField = c.getField("height");
26 
27             heightValue = (Integer) heightField.get(r);
28 
29             System.out.println("Height: " + heightValue.toString());
30 
31         } catch (NoSuchFieldException e) {
32 
33             System.out.println(e);
34 
35         } catch (SecurityException e) {
36 
37             System.out.println(e);
38 
39         } catch (IllegalAccessException e) {
40 
41             System.out.println(e);
42 
43         }
44 
45     }
46 
47 }

安全性和反射：

在处理反射时安全性是一个较复杂的问题。反射经常由框架型代码使用，由于这一点，我们可能希望框架能够全面接入代码，无需考虑常规的接入限制。但是，在其它情况下，不受控制的接入会带来严重的安全性风险，例如当代码在不值得信任的代码共享的环境中运行时。

由于这些互相矛盾的需求，Java编程语言定义一种多级别方法来处理反射的安全性。基本模式是对反射实施与应用于源代码接入相同的限制：

从任意位置到类公共组件的接入

类自身外部无任何到私有组件的接入

受保护和打包（缺省接入）组件的有限接入

不过至少有些时候，围绕这些限制还有一种简单的方法。我们可以在我们所写的类中，扩展一个普通的基本类 java.lang.reflect.AccessibleObject 类。这个类定义了一种setAccessible方法，使我们能够启动或关闭对这些类中其中一个类的实例的接入检测。唯一的问题在于如果使用了安全性管理器，它将检测正在关闭接入检测的代码是否许可了这样做。如果未许可，安全性管理器抛出一个例外。

下面是一段程序，在TwoString 类的一个实例上使用反射来显示安全性正在运行：

 1 public class ReflectSecurity {
 2 
 3     public static void main(String[] args) {
 4 
 5         try {
 6 
 7             TwoString ts = new TwoString("a", "b");
 8 
 9             Field field = clas.getDeclaredField("m_s1");
10 
11             // field.setAccessible(true);
12 
13             System.out.println("Retrieved value is " +
14 
15             field.get(inst));
16 
17         } catch (Exception ex) {
18 
19             ex.printStackTrace(System.out);
20 
21         }
22 
23     }
24 
25 }

如果我们编译这一程序时，不使用任何特定参数直接从命令行运行，它将在field .get(inst)调用中抛出一个IllegalAccessException异常。如果我们不注释 field.setAccessible(true)代码行，那么重新编译并重新运行该代码，它将编译成功。最后，如果我们在命令行添加了JVM参数 -Djava.security.manager以实现安全性管理器，它仍然将不能通过编译，除非我们定义了ReflectSecurity类的许可权限。

反射性能：（转录别人的啊）

反射是一种强大的工具，但也存在一些不足。一个主要的缺点是对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于只直接执行相同的操作。

下面的程序是字段接入性能测试的一个例子，包括基本的测试方法。每种方法测试字段接入的一种形式 -- accessSame 与同一对象的成员字段协作，accessOther 使用可直接接入的另一对象的字段，accessReflection 使用可通过反射接入的另一对象的字段。在每种情况下，方法执行相同的计算 -- 循环中简单的加/乘顺序。

程序如下：

 1 public int accessSame(int loops) {
 2 
 3     m_value = 0;
 4 
 5     for (int index = 0; index < loops; index++) {
 6     
 7         m_value = (m_value + ADDITIVE_VALUE) *MULTIPLIER_VALUE;
 8     
 9     }
10 
11     return m_value;
12 
13 }
14 
15 public int accessReference(int loops) {
16 
17     TimingClass timing = new TimingClass();
18 
19     for (int index = 0; index < loops; index++) {
20     
21         timing.m_value = (timing.m_value + ADDITIVE_VALUE) *MULTIPLIER_VALUE;
22     
23     }
24 
25     return timing.m_value;
26 
27 }
28 
29 public int accessReflection(int loops) throws Exception {
30 
31     TimingClass timing = new TimingClass();
32     
33     try {
34     
35         Field field = TimingClass.class.
36         
37         getDeclaredField("m_value");
38         
39         for (int index = 0; index < loops; index++) {
40         
41             int value = (field.getInt(timing) +
42             
43             ADDITIVE_VALUE) * MULTIPLIER_VALUE;
44             
45             field.setInt(timing, value);
46             
47         }
48         
49         return timing.m_value;
50     
51     } catch (Exception ex) {
52     
53         System.out.println("Error using reflection");
54     
55         throw ex;
56     
57     }
58 
59 }

在上面的例子中，测试程序重复调用每种方法，使用一个大循环数，从而平均多次调用的时间衡量结果。平均值中不包括每种方法第一次调用的时间，因此初始化时间不是结果中的一个因素。下面的图清楚的向我们展示了每种方法字段接入的时间：

图 1：字段接入时间：

我们可以看出：在前两副图中(Sun JVM)，使用反射的执行时间超过使用直接接入的1000倍以上。通过比较，IBM JVM可能稍好一些，但反射方法仍旧需要比其它方法长700倍以上的时间。任何JVM上其它两种方法之间时间方面无任何显著差异，但IBM JVM几乎比Sun JVM快一倍。最有可能的是这种差异反映了Sun Hot Spot JVM的专业优化，它在简单基准方面表现得很糟糕。反射性能是Sun开发1.4 JVM时关注的一个方面，它在反射方法调用结果中显示。在这类操作的性能方面，Sun 1.4.1 JVM显示了比1.3.1版本很大的改进。

如果为为创建使用反射的对象编写了类似的计时测试程序，我们会发现这种情况下的差异不象字段和方法调用情况下那么显著。使用newInstance()调用创建一个简单的java.lang.Object实例耗用的时间大约是在Sun 1.3.1 JVM上使用new Object()的12倍，是在IBM 1.4.0 JVM的四倍，只是Sun 1.4.1 JVM上的两部。使用Array.newInstance(type, size)创建一个数组耗用的时间是任何测试的JVM上使用new type[size]的两倍，随着数组大小的增加，差异逐步缩小。随着jdk6.0的推出，反射机制的性能也有了很大的提升。期待中….

总结：

Java 语言反射提供一种动态链接程序组件的多功能方法。它允许程序创建和控制任何类的对象(根据安全性限制)，无需提前硬编码目标类。这些特性使得反射特别适用于创建以非常普通的方式与对象协作的库。例如，反射经常在持续存储对象为数据库、XML或其它外部格式的框架中使用。Java reflection 非常有用，它使类和数据结构能按名称动态检索相关信息，并允许在运行着的程序中操作这些信息。Java 的这一特性非常强大，并且是其它一些常用语言，如 C、C++、Fortran 或者 Pascal 等都不具备的。

但反射有两个缺点。第一个是性能问题。用于字段和方法接入时反射要远慢于直接代码。性能问题的程度取决于程序中是如何使用反射的。如果它作为程序运行中相对很少涉及的部分，缓慢的性能将不会是一个问题。即使测试中最坏情况下的计时图显示的反射操作只耗用几微秒。仅反射在性能关键的应用的核心逻辑中使用时性能问题才变得至关重要。

许多应用中更严重的一个缺点是使用反射会模糊程序内部实际要发生的事情。程序人员希望在源代码中看到程序的逻辑，反射等绕过了源代码的技术会带来维护问题。反射代码比相应的直接代码更复杂，正如性能比较的代码实例中看到的一样。解决这些问题的最佳方案是保守地使用反射——仅在它可以真正增加灵活性的地方 ——记录其在目标类中的使用。

一下是对应各个部分的例子：

具体的应用：

1、模仿instanceof 运算符号

 1 class A {
 2 }
 3 
 4 public class instance1 {
 5 
 6     public static void main(String args[])
 7 
 8     {
 9 
10         try {
11 
12             Class cls = Class.forName("A");
13 
14             boolean b1
15 
16             = cls.isInstance(new Integer(37));
17 
18             System.out.println(b1);
19 
20             boolean b2 = cls.isInstance(new A());
21 
22             System.out.println(b2);
23 
24         }
25 
26         catch (Throwable e) {
27 
28             System.err.println(e);
29 
30         }
31 
32     }
33 
34 }

2、在类中寻找指定的方法，同时获取该方法的参数列表，例外和返回值

 1 import java.lang.reflect.*;
 2 
 3 public class method1 {
 4 
 5 private int f1(Object p, int x) throws NullPointerException{
 6 
 7     if (p == null)
 8     
 9     throw new NullPointerException();
10     
11     return x;
12 
13 }
14 
15 public static void main(String args[]){
16 
17         try {
18         
19             Class cls = Class.forName("method1");
20             
21             Method methlist[]= cls.getDeclaredMethods();
22             
23             for (int i = 0; i < methlist.length;i++){
24                 Method m = methlist[i];
25                 
26                 System.out.println("name= " + m.getName());
27                 
28                 System.out.println("decl class = " +
29                 
30                 m.getDeclaringClass());
31                 
32                 Class pvec[] = m.getParameterTypes();
33                 
34                 for (int j = 0; j < pvec.length; j++){
35                     
36                     System.out.println("param #" + j + " " + pvec[j]);
37                     
38                 }
39                 
40                 
41                 
42                 Class evec[] = m.getExceptionTypes();
43                 
44                 for (int j = 0; j < evec.length; j++){
45                     System.out.println("exc #" + j+ " " + evec[j]);
46                 }
47                 
48                 
49                 
50                 System.out.println("return type = " +m.getReturnType());
51                 
52                 System.out.println("-----");
53                 
54                 }
55             
56             
57             
58     
59         }catch (Throwable e) {
60         
61             System.err.println(e);
62         
63         }
64 
65     }
66 
67 }

3、获取类的构造函数信息，基本上与获取方法的方式相同

 1 import java.lang.reflect.*;
 2 
 3 public class constructor1 {
 4 
 5     public constructor1(){
 6     
 7     }
 8     
 9     protected constructor1(int i, double d)
10     
11     {
12     
13     }
14     
15     public static void main(String args[])
16     
17     {
18     
19         try {
20         
21             Class cls = Class.forName("constructor1");
22             
23             Constructor ctorlist[]= cls.getDeclaredConstructors();
24             
25             for (int i = 0; i < ctorlist.length; i++) {
26             
27             Constructor ct = ctorlist[i];
28             
29             System.out.println("name= " + ct.getName());
30             
31             System.out.println("decl class = " +ct.getDeclaringClass());
32             
33             Class pvec[] = ct.getParameterTypes();
34             
35             for (int j = 0; j < pvec.length; j++)
36             
37             System.out.println("param #"+ j + " " + pvec[j]);
38             
39             Class evec[] = ct.getExceptionTypes();
40             
41             for (int j = 0; j < evec.length; j++)
42             
43             System.out.println("exc #" + j + " " + evec[j]);
44             
45             System.out.println("-----");
46             
47             }
48         
49         }catch (Throwable e) {
50         
51             System.err.println(e);
52         
53         }
54     
55     }
56 
57 }

4、获取类中的各个数据成员对象，包括名称。类型和访问修饰符号

 1 import java.lang.reflect.*;
 2 
 3 public class field1 {
 4 
 5     private double d;
 6 
 7     public static final int i = 37;
 8 
 9     String s = "testing";
10 
11     public static void main(String args[])
12 
13     {
14 
15         try {
16 
17             Class cls = Class.forName("field1");
18 
19             Field fieldlist[] = cls.getDeclaredFields();
20 
21             for (int i = 0; i < fieldlist.length; i++) {
22 
23                 Field fld = fieldlist[i];
24 
25                 System.out.println("name= " + fld.getName());
26 
27                 System.out.println("decl class = " + fld.getDeclaringClass());
28 
29                 System.out.println("type= " + fld.getType());
30 
31                 int mod = fld.getModifiers();
32 
33                 System.out.println("modifiers = " +
34 
35                 Modifier.toString(mod));
36 
37                 System.out.println("-----");
38 
39             }
40 
41         }
42 
43         catch (Throwable e) {
44 
45             System.err.println(e);
46 
47         }
48 
49     }
50 
51 }

5、通过使用方法的名字调用方法

 1 import java.lang.reflect.*;
 2 
 3 public class method2 {
 4 
 5     public int add(int a, int b)
 6 
 7     {
 8 
 9         return a + b;
10 
11     }
12 
13     public static void main(String args[])
14 
15     {
16 
17         try {
18 
19             Class cls = Class.forName("method2");
20 
21             Class partypes[] = new Class[2];
22 
23             partypes[0] = Integer.TYPE;
24 
25             partypes[1] = Integer.TYPE;
26 
27             Method meth = cls.getMethod("add", partypes);
28 
29             method2 methobj = new method2();
30 
31             Object arglist[] = new Object[2];
32 
33             arglist[0] = new Integer(37);
34 
35             arglist[1] = new Integer(47);
36 
37             Object retobj = meth.invoke(methobj, arglist);
38 
39             Integer retval = (Integer) retobj;
40 
41             System.out.println(retval.intValue());
42 
43         }
44 
45         catch (Throwable e) {
46 
47             System.err.println(e);
48 
49         }
50 
51     }
52 
53 }

6、创建新的对象

 1 import java.lang.reflect.*;
 2 
 3 public class constructor2 {
 4 
 5     public constructor2()
 6 
 7     {
 8 
 9     }
10 
11     public constructor2(int a, int b)
12 
13     {
14 
15         System.out.println(
16 
17         "a = " + a + " b = " + b);
18 
19     }
20 
21     public static void main(String args[])
22 
23     {
24 
25         try {
26 
27             Class cls = Class.forName("constructor2");
28 
29             Class partypes[] = new Class[2];
30 
31             partypes[0] = Integer.TYPE;
32 
33             partypes[1] = Integer.TYPE;
34 
35             Constructor ct = cls.getConstructor(partypes);
36 
37             Object arglist[] = new Object[2];
38 
39             arglist[0] = new Integer(37);
40 
41             arglist[1] = new Integer(47);
42 
43             Object retobj = ct.newInstance(arglist);
44 
45         }
46 
47         catch (Throwable e) {
48 
49             System.err.println(e);
50 
51         }
52 
53     }
54 
55 }

7、变更类实例中的数据的值

 1 import java.lang.reflect.*;
 2 
 3 public class field2 {
 4 
 5     public double d;
 6 
 7     public static void main(String args[])
 8 
 9     {
10 
11         try {
12 
13             Class cls = Class.forName("field2");
14 
15             Field fld = cls.getField("d");
16 
17             field2 f2obj = new field2();
18 
19             System.out.println("d = " + f2obj.d);
20 
21             fld.setDouble(f2obj, 12.34);
22 
23             System.out.println("d = " + f2obj.d);
24 
25         }
26 
27         catch (Throwable e) {
28 
29             System.err.println(e);
30 
31         }
32 
33     }
34 
35 }

使用反射创建可重用代码：

1、对象工厂

 1 Object factory(String p) {
 2 
 3     Class c;
 4 
 5     Object o=null;
 6 
 7 try {
 8 
 9     c = Class.forName(p);// get class def
10     
11     o = c.newInstance(); // make a new one
12 
13 } catch (Exception e) {
14 
15     System.err.println("Can't make a " + p);
16 
17 }
18 
19 return o;
20 
21 }
22 
23 public class ObjectFoundry {
24 
25     public static Object factory(String p)throws ClassNotFoundException,InstantiationException,IllegalAccessException {
26     
27         Class c = Class.forName(p);
28         
29         Object o = c.newInstance();
30         
31         return o;
32     
33     }
34 
35 }

2、动态检测对象的身份，替代instanceof

 1 public static boolean isKindOf(Object obj, String type)throws ClassNotFoundException {
 2 
 3     // get the class def for obj and type
 4     
 5     Class c = obj.getClass();
 6     
 7     Class tClass = Class.forName(type);
 8     
 9     while ( c!=null ) {
10     
11         if ( c==tClass ) return true;
12         
13             c = c.getSuperclass();
14         
15     }
16     
17     return false;
18 
19 }