Java反射技术

一、反射的概念：

反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。其中LEAD/LEAD++、OpenC++、MetaXa和OpenJava等就是基于反射机制的语言。最近，反射机制也被应用到了视窗系统、操作系统和文件系统中。

反射本身并不是一个新概念，它可能会使我们联想到光学中的反射概念，尽管计算机科学赋予了反射概念新的含义，但是，从现象上来说，它们确实有某些相通之处，这些有助于我们的理解。在计算机科学领域，反射是指一类应用，它们能够自描述和自控制。也就是说，这类应用通过采用某种机制来实现对自己行为的描述（self-representation）和监测（examination），并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。可以看出，同一般的反射概念相比，计算机科学领域的反射不单单指反射本身，还包括对反射结果所采取的措施。所有采用反射机制的系统（即反射系统）都希望使系统的实现更开放。可以说，实现了反射机制的系统都具有开放性，但具有开放性的系统并不一定采用了反射机制，开放性是反射系统的必要条件。一般来说，反射系统除了满足开放性条件外还必须满足原因连接（Causally-connected）。所谓原因连接是指对反射系统自描述的改变能够立即反映到系统底层的实际状态和行为上的情况，反之亦然。开放性和原因连接是反射系统的两大基本要素。13700863760

Java中，反射是一种强大的工具。它使您能够创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代表链接。反射允许我们在编写与执行时，使我们的程序代码能够接入装载到JVM中的类的内部信息，而不是源代码中选定的类协作的代码。这使反射成为构建灵活的应用的主要工具。但需注意的是：如果使用不当，反射的成本很高。

二、Java中的类反射：

Reflection是Java程序开发语言的特征之一，它允许运行中的Java程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。Java的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。例如，Pascal、C或者C++中就没有办法在程序中获得函数定义相关的信息。

1．检测类：

1.1reflection的工作机制

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

importjava.lang.reflect.*;
publicclassDumpMethods{
publicstaticvoidmain(Stringargs[]){
try{
Classc=Class.forName(args[0]);
Methodm[]=c.getDeclaredMethods();
for(inti=0;i<m.length;i++)
System.out.println(m[i].toString());
}catch(Throwablee){
System.err.println(e);
}
}
}

按如下语句执行：

javaDumpMethodsjava.util.Stack

它的结果输出为：

publicjava.lang.Objectjava.util.Stack.push(java.lang.Object)

publicsynchronizedjava.lang.Objectjava.util.Stack.pop()

publicsynchronizedjava.lang.Objectjava.util.Stack.peek()

publicbooleanjava.util.Stack.empty()

publicsynchronizedintjava.util.Stack.search(java.lang.Object)

这样就列出了java.util.Stack类的各方法名以及它们的限制符和返回类型。

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

1.2Java类反射中的主要方法

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

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

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

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

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

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

lFieldgetField(Stringname)--获得命名的公共字段

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

lFieldgetDeclaredField(Stringname)--获得类声明的命名的字段

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

用于获得方法信息函数：

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

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

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

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

1.3开始使用Reflection：

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

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

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

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

Classc=int.class;

或者

Classc=Integer.TYPE;

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

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

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

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

Methodm[]=c.getDeclaredMethods();

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

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

2．处理对象：

如果要作一个开发工具像debugger之类的，你必须能发现filedvalues,以下是三个步骤:

a.创建一个Class对象
b.通过getField创建一个Field对象
c.调用Field.getXXX(Object)方法(XXX是Int,Float等，如果是对象就省略；Object是指实例).

例如：
importjava.lang.reflect.*;
importjava.awt.*;

classSampleGet{

publicstaticvoidmain(String[]args){
Rectangler=newRectangle(100,325);
printHeight(r);

}

staticvoidprintHeight(Rectangler){
FieldheightField;
IntegerheightValue;
Classc=r.getClass();
try{
heightField=c.getField("height");
heightValue=(Integer)heightField.get(r);
System.out.println("Height:"+heightValue.toString());
}catch(NoSuchFieldExceptione){
System.out.println(e);
}catch(SecurityExceptione){
System.out.println(e);
}catch(IllegalAccessExceptione){
System.out.println(e);
}
}
}

三、安全性和反射：

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

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

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

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

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

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

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

publicclassReflectSecurity{

publicstaticvoidmain(String[]args){

try{

TwoStringts=newTwoString("a","b");

Fieldfield=clas.getDeclaredField("m_s1");

//field.setAccessible(true);

System.out.println("Retrievedvalueis"+

field.get(inst));

}catch(Exceptionex){

ex.printStackTrace(System.out);

}

}

}

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

四、反射性能：

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

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

程序如下：

publicintaccessSame(intloops){

m_value=0;

for(intindex=0;index<loops;index++){

m_value=(m_value+ADDITIVE_VALUE)*

MULTIPLIER_VALUE;

}

returnm_value;

}

publicintaccessReference(intloops){

TimingClasstiming=newTimingClass();

for(intindex=0;index<loops;index++){

timing.m_value=(timing.m_value+ADDITIVE_VALUE)*

MULTIPLIER_VALUE;

}

returntiming.m_value;

}

publicintaccessReflection(intloops)throwsException{

TimingClasstiming=newTimingClass();

try{

Fieldfield=TimingClass.class.

getDeclaredField("m_value");

for(intindex=0;index<loops;index++){

intvalue=(field.getInt(timing)+

ADDITIVE_VALUE)*MULTIPLIER_VALUE;

field.setInt(timing,value);

}

returntiming.m_value;

}catch(Exceptionex){

System.out.println("Errorusingreflection");

throwex;

}

}

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

图1：字段接入时间：

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

如果为为创建使用反射的对象编写了类似的计时测试程序，我们会发现这种情况下的差异不象字段和方法调用情况下那么显著。使用newInstance()调用创建一个简单的java.lang.Object实例耗用的时间大约是在Sun1.3.1JVM上使用newObject()的12倍，是在IBM1.4.0JVM的四倍，只是Sun1.4.1JVM上的两部。使用Array.newInstance(type,size)创建一个数组耗用的时间是任何测试的JVM上使用newtype[size]的两倍，随着数组大小的增加，差异逐步缩小。

结束语：

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

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

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

例子（好好看看哦）：

package org.chuanqi.Test;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

/**

*Java Reflection

*@author closewubq

*@version 1.0

*/

public class OwnReflection {

/**

* 得到某类的静态公共属性

* @param className

* 类名

* @param fieldName

* 属性名称

* @return 该属性对象

* @throws Exception

*/

@SuppressWarnings("unchecked")

public Object getStaticField(String className, String fieldName)

throws Exception {

Class obj = Class.forName(className);

Field field = obj.getField(fieldName);

Object property = field.get(obj);

return property;

}

/**

* 执行某对象方法

* @param obj

* 对象的Class

* @param methodName

* 方法名

* @param args

* 参数

* @return 方法返回值

* @throws Exception

*/

@SuppressWarnings("unchecked")

public Object invokeMethod(String className, String methodName, Object[]args)

throws Exception {

Class objClass =Class.forName(className);

Class[] argsClass = new Class[args.length];

for (int i = 0, j = args.length; i < j; i++) {

argsClass[i] = args[i].getClass();

}

Method method = objClass.getMethod(methodName, argsClass);

return method.invoke(objClass.newInstance(), args);

}

/**

* 执行某类的静态方法

* @param className

* 类名

* @param methodName

* 方法名

* @param args

* 参数数组

* @return 执行方法返回的结果

* @throws Exception

*/

@SuppressWarnings("unchecked")

public Object invokeStaticMethod(String className, String methodName,

Object[] args) throws Exception {

Class objclass = Class.forName(className);

Class[] argsClass = new Class[args.length];

for (int i = 0, j = args.length; i < j; i++) {

argsClass[i] = args[i].getClass();

}

Method method = objclass.getMethod(methodName, argsClass);

return method.invoke(null, args);

}

/**

* 根据类名创建实例

* @param className

* 类名

* @param args

* 构造函数的参数

* @return Object

* 新建的实例

* @throws Exception

*/

@SuppressWarnings("unchecked")

public Object newInstance(String className, Object[] args) throwsException {

Class objcass = Class.forName(className);

Class[] argsClass = new Class[args.length];

for (int i = 0, j = args.length; i < j; i++) {

argsClass[i] = args[i].getClass();

}

Constructor cons = objcass.getConstructor(argsClass);

return cons.newInstance(args);

}

/**

* 判断一个对象是不是某个类的实例

* @param obj

* 某个对象

* @param objclass

* 某个类

* @return boolean

* 如果 obj 是此类的实例，则返回 true

*/

@SuppressWarnings("unchecked")

public boolean isInstance(Object obj, Class objclass) {

return objclass.isInstance(obj);

}

}