Java 反射机制编程详解

JAVA反射机制介绍：
     JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
Java反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。
1. 得到某个对象的属性

public Object getProperty(Object owner, String fieldName) throws Exception {
 Class ownerClass = owner.getClass();
 
 Field field = ownerClass.getField(fieldName);
 Object property = field.get(owner);
 return property;
}

 

Class ownerClass = owner.getClass()：得到该对象的Class。

Field field = ownerClass.getField(fieldName)：通过Class得到类声明的属性。

Object property = field.get(owner)：通过对象得到该属性的实例，如果这个属性是非公有的，这里会报IllegalAccessException。

2. 得到某个类的静态属性

public Object getStaticProperty(String className, String fieldName)
  throws Exception {
 Class ownerClass = Class.forName(className);
 Field field = ownerClass.getField(fieldName);
 Object property = field.get(ownerClass);
 return property;
}

 

Class ownerClass = Class.forName(className) ：首先得到这个类的Class。

Field field = ownerClass.getField(fieldName)：和上面一样，通过Class得到类声明的属性。

Object property = field.get(ownerClass) ：这里和上面有些不同，因为该属性是静态的，所以直接从类的Class里取。

3. 执行某对象的方法

public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {
 Class ownerClass = owner.getClass();
 Class[] argsClass = new Class[args.length];
 for (int i = 0, j = args.length; i < j; i++) {
  argsClass[i] = args[i].getClass();
 }
 Method method = ownerClass.getMethod(methodName, argsClass);
 return method.invoke(owner, args);
}

 
Class owner_class = owner.getClass() ：首先还是必须得到这个对象的Class。

5～9行：配置参数的Class数组，作为寻找Method的条件。

Method method = ownerClass.getMethod(methodName, argsClass)：通过Method名和参数的Class数组得到要执行的Method。

method.invoke(owner, args)：执行该Method，invoke方法的参数是执行这个方法的对象，和参数数组。返回值是Object，也既是该方法的返回值。

4. 执行某个类的静态方法

public Object invokeStaticMethod(String className, String methodName,
  Object[] args) throws Exception {
 Class ownerClass = 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 = ownerClass.getMethod(methodName, argsClass);
 return method.invoke(null, args);
}

 

基本的原理和实例3相同，不同点是最后一行，invoke的一个参数是null，因为这是静态方法，不需要借助实例运行。

5. 新建实例

public Object newInstance(String className, Object[] args) throws Exception {
 Class newoneClass = 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 = newoneClass.getConstructor(argsClass);
 return cons.newInstance(args);
}

 

这里说的方法是执行带参数的构造函数来新建实例的方法。如果不需要参数，可以直接使用newoneClass.newInstance()来实现。

Class newoneClass = Class.forName(className)：第一步，得到要构造的实例的Class。

第5～第9行：得到参数的Class数组。

Constructor cons = newoneClass.getConstructor(argsClass)：得到构造子。

cons.newInstance(args)：新建实例。

6. 判断是否为某个类的实例

public boolean isInstance(Object obj, Class cls) {
 return cls.isInstance(obj);
}

 

7. 得到数组中的某个元素

public Object getByArray(Object array, int index) {
 return Array.get(array,index);
}

 

###=================================================================###

 

Java类反射中的主要方法
　　对于以下三类组件中的任何一类来说 -- 构造函数、字段和方法 -- java.lang.Class 提供四种独立的反射调用，以不同的方式来获得信息。调用都遵循一种标准格式。以下是用于查找构造函数的一组反射调用：
　　l Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的公共构造函数，
　　l Constructor[] getConstructors() -- 获得类的所有公共构造函数
　　l Constructor getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(与接入级别无关)
　　l Constructor[] getDeclaredConstructors() -- 获得类的所有构造函数(与接入级别无关)
　　获得字段信息的Class 反射调用不同于那些用于接入构造函数的调用，在参数类型数组中使用了字段名：
　　l Field getField(String name) -- 获得命名的公共字段
　　l Field[] getFields() -- 获得类的所有公共字段
　　l Field getDeclaredField(String name) -- 获得类声明的命名的字段
　　l Field[] getDeclaredFields() -- 获得类声明的所有字段
　　用于获得方法信息函数：
　　l Method getMethod(String name, Class[] params) -- 使用特定的参数类型，获得命名的公共方法
　　l Method[] getMethods() -- 获得类的所有公共方法
　　l Method getDeclaredMethod(String name, Class[] params) -- 使用特写的参数类型，获得类声明的命名的方法
　　l Method[] getDeclaredMethods() -- 获得类声明的所有方法
　　1.3开始使用 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;
　　它们可获得基本类型的类信息。其中后一种方法中访问的是基本类型的封装类 (如 Integer) 中预先定义好的 TYPE 字段。
　　第二步是调用诸如 getDeclaredMethods 的方法，以取得该类中定义的所有方法的列表。
　　一旦取得这个信息，就可以进行第三步了——使用 reflection API 来操作这些信息，如下面这段代码：
　　Class c = Class.forName("java.lang.String");
　　Method m[] = c.getDeclaredMethods();
　　System.out.println(m[0].toString());
　　它将以文本方式打印出 String 中定义的第一个方法的原型。
　　2．处理对象：
　　如果要作一个开发工具像debugger之类的，你必须能发现filed values,以下是三个步骤:
　　a.创建一个Class对象
　　b.通过getField 创建一个Field对象
　　c.调用Field.getXXX(Object)方法(XXX是Int,Float等，如果是对象就省略；Object是指实例).
　　例如：

import java.lang.reflect.*;
import java.awt.*;
class SampleGet {
	public static void main(String[] args) {
		Rectangle r = new Rectangle(100, 325);
		printHeight(r);
	}
	static void printHeight(Rectangle r) {
		Field heightField;
		Integer heightValue;
		Class c = r.getClass();
		try {
			heightField = c.getField("height");
			heightValue = (Integer) heightField.get(r);
			System.out.println("Height: " + heightValue.toString());
		} catch (NoSuchFieldException e) {
			System.out.println(e);
		} catch (SecurityException e) {
			System.out.println(e);
		} catch (IllegalAccessException e) {
			System.out.println(e);
		}
	}
}

 

　　三、安全性和反射：
　　在处理反射时安全性是一个较复杂的问题。反射经常由框架型代码使用，由于这一点，我们可能希望框架能够全面接入代码，无需考虑常规的接入限制。但是，在其它情况下，不受控制的接入会带来严重的安全性风险，例如当代码在不值得信任的代码共享的环境中运行时。
　　由于这些互相矛盾的需求，Java编程语言定义一种多级别方法来处理反射的安全性。基本模式是对反射实施与应用于源代码接入相同的限制：
　　n 从任意位置到类公共组件的接入
　　n 类自身外部无任何到私有组件的接入
　　n 受保护和打包（缺省接入）组件的有限接入
　　不过至少有些时候，围绕这些限制还有一种简单的方法。我们可以在我们所写的类中，扩展一个普通的基本类java.lang.reflect.AccessibleObject 类。这个类定义了一种setAccessible方法，使我们能够启动或关闭对这些类中其中一个类的实例的接入检测。唯一的问题在于如果使用了安全性管理器，它将检测正在关闭接入检测的代码是否许可了这样做。如果未许可，安全性管理器抛出一个例外。
　　下面是一段程序，在TwoString 类的一个实例上使用反射来显示安全性正在运行：

public class ReflectSecurity {
	public static void main(String[] args) {
		try {
			TwoString ts = new TwoString("a", "b");
			Field field = clas.getDeclaredField("m_s1");
			// field.setAccessible(true);
			System.out.println("Retrieved value is " +
			field.get(inst));
		} catch (Exception ex) {
			ex.printStackTrace(System.out);
		}
	}
}

 

　　如果我们编译这一程序时，不使用任何特定参数直接从命令行运行，它将在field .get(inst)调用中抛出一个IllegalAccessException异常。如果我们不注释field.setAccessible(true)代码行，那么重新编译并重新运行该代码，它将编译成功。最后，如果我们在命令行添加了JVM参数-Djava.security.manager以实现安全性管理器，它仍然将不能通过编译，除非我们定义了ReflectSecurity类的许可权限。
　　四、反射性能：
　　反射是一种强大的工具，但也存在一些不足。一个主要的缺点是对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于只直接执行相同的操作。
　　下面的程序是字段接入性能测试的一个例子，包括基本的测试方法。每种方法测试字段接入的一种形式 -- accessSame 与同一对象的成员字段协作，accessOther 使用可直接接入的另一对象的字段，accessReflection 使用可通过反射接入的另一对象的字段。在每种情况下，方法执行相同的计算 -- 循环中简单的加/乘顺序。
　　程序如下：

public int accessSame(int loops) {
	m_value = 0;
	for (int index = 0; index < loops; index++) {
		m_value = (m_value + ADDITIVE_VALUE) * MULTIPLIER_VALUE;
	}
	return m_value;
}
public int accessReference(int loops) {
	TimingClass timing = new TimingClass();
	for (int index = 0; index < loops; index++) {
		timing.m_value = (timing.m_value + ADDITIVE_VALUE) * MULTIPLIER_VALUE;
	}
	return timing.m_value;
}
public int accessReflection(int loops) throws Exception {
	TimingClass timing = new TimingClass();
	try {
		Field field = TimingClass.class.
		getDeclaredField("m_value");
		for (int index = 0; index < loops; index++) {
			int value = (field.getInt(timing) + ADDITIVE_VALUE) * MULTIPLIER_VALUE;
			field.setInt(timing, value);
		}
		return timing.m_value;
	} catch (Exception ex) {
		System.out.println("Error using reflection");
		throw ex;
	}
}

 

　　在上面的例子中，测试程序重复调用每种方法，使用一个大循环数，从而平均多次调用的时间衡量结果。平均值中不包括每种方法第一次调用的时间，因此初始化时间不是结果中的一个因素。下面的图清楚的向我们展示了每种方法字段接入的时间：
　　图 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]的两倍，随着数组大小的增加，差异逐步缩小。
　　结束语：
　　Java语言反射提供一种动态链接程序组件的多功能方法。它允许程序创建和控制任何类的对象(根据安全性限制)，无需提前硬编码目标类。这些特性使得反射特别适用于创建以非常普通的方式与对象协作的库。例如，反射经常在持续存储对象为数据库、XML或其它外部格式的框架中使用。Java reflection 非常有用，它使类和数据结构能按名称动态检索相关信息，并允许在运行着的程序中操作这些信息。Java 的这一特性非常强大，并且是其它一些常用语言，如 C、C++、Fortran 或者 Pascal 等都不具备的。
　　但反射有两个缺点。第一个是性能问题。用于字段和方法接入时反射要远慢于直接代码。性能问题的程度取决于程序中是如何使用反射的。如果它作为程序运行中相对很少涉及的部分，缓慢的性能将不会是一个问题。即使测试中最坏情况下的计时图显示的反射操作只耗用几微秒。仅反射在性能关键的应用的核心逻辑中使用时性能问题才变得至关重要。
　　许多应用中更严重的一个缺点是使用反射会模糊程序内部实际要发生的事情。程序人员希望在源代码中看到程序的逻辑，反射等绕过了源代码的技术会带来维护问题。反射代码比相应的直接代码更复杂，正如性能比较的代码实例中看到的一样。解决这些问题的最佳方案是保守地使用反射——仅在它可以真正增加灵活性的地方——记录其在目标类中的使用。
　　
　　利用反射实现类的动态加载
　　Bromon原创 请尊重版权
　　最近在成都写一个移动增值项目，俺负责后台server端。功能很简单，手机用户通过GPRS打开Socket与服务器连接，我则根据用户传过来的数据做出响应。做过类似项目的兄弟一定都知道，首先需要定义一个类似于MSNP的通讯协议，不过今天的话题是如何把这个系统设计得具有高度的扩展性。由于这个项目本身没有进行过较为完善的客户沟通和需求分析，所以以后肯定会有很多功能上的扩展，通讯协议肯定会越来越庞大，而我作为一个不那么勤快的人，当然不想以后再去修改写好的程序，所以这个项目是实践面向对象设计的好机会。
　　首先定义一个接口来隔离类：
　　

package org.xiangxji.reflect;
public interface Operator
{
	public java.util.List act(java.util.List params)
}

 
　　根据设计模式的原理，我们可以为不同的功能编写不同的类，每个类都继承Operator接口，客户端只需要针对Operator接口编程就可以避免很多麻烦。比如这个类：
　　

package org.xiangxji.reflect;
public class Success implements Operator
{
	public java.util.List act(java.util.List params)
	{
		List result=new ArrayList();
		result.add(new String(“操作成功”));
		return result;
	}
}

 
　　我们还可以写其他很多类，但是有个问题，接口是无法实例化的，我们必须手动控制具体实例化哪个类，这很不爽，如果能够向应用程序传递一个参数，让自己去选择实例化一个类，执行它的act方法，那我们的工作就轻松多了。
　　很幸运，我使用的是Java，只有Java才提供这样的反射机制，或者说内省机制，可以实现我们的无理要求。编写一个配置文件emp.properties:
　　#成功响应
　　1000=Success
　　#向客户发送普通文本消息
　　2000=Load
　　#客户向服务器发送普通文本消息
　　3000=Store
　　文件中的键名是客户将发给我的消息头，客户发送1000给我，那么我就执行Success类的act方法，类似的如果发送2000给我，那就执行Load类的act方法，这样一来系统就完全符合开闭原则了，如果要添加新的功能，完全不需要修改已有代码，只需要在配置文件中添加对应规则，然后编写新的类，实现act方法就ok，即使我弃这个项目而去，它将来也可以很好的扩展。这样的系统具备了非常良好的扩展性和可插入性。
　　下面这个例子体现了动态加载的功能，程序在执行过程中才知道应该实例化哪个类：
　　

package org.xiangxji.reflect;
import java.lang.reflect.*;

public class TestReflect
{
	//加载配置文件,查询消息头对应的类名
	private String loadProtocal(String header)
	{
		String result=null;
		try
		{
			Properties prop=new Properties();
			FileInputStream fis=new FileInputStream("emp.properties");
			prop.load(fis);
			result=prop.getProperty(header);
			fis.close();
		}catch(Exception e)
		{
			System.out.println(e);
		}
		return result;
	}
	//针对消息作出响应,利用反射导入对应的类
	public String response(String header,String content)
	{
		String result=null;
		String s=null;
		try 
		{
			/*
			* 导入属性文件emp.properties,查询header所对应的类的名字
			* 通过反射机制动态加载匹配的类,所有的类都被Operator接口隔离
			* 可以通过修改属性文件、添加新的类(继承MsgOperator接口)来扩展协议
			*/
			s="org.xiangxji.reflect."+this.loadProtocal(header);
			//加载类
			Class c=Class.forName(s);
			//创建类的事例
			Operator mo=(Operator)c.newInstance();
			//构造参数列表
			Class params[]=new Class[1];
			params[0]=Class.forName("java.util.List");
			//查询act方法
			Method m=c.getMethod("act",params);
			Object args[]=new Object[1];
			args[0]=content;
			//调用方法并且获得返回
			Object returnObject=m.invoke(mo,args);
		}catch(Exception e)
		{
			System.out.println("Handler-response:"+e);
		}
		return result;
	}
	public static void main(String args[])
	{
		TestReflect tr=new TestReflect();
		tr.response(args[0],”消息内容”);
	}
}

 
　　测试一下：java TestReflect 1000
　　这个程序是针对Operator编程的，所以无需做任何修改，直接提供Load和Store类，就可以支持2000、3000做参数的调用。