JAVA反射和动态代理
参考网址:http://developer.51cto.com/developer/javabook/images/10.pdf
在Java运行时环境中,对于任意的一个类,能否知道这个类的所有属性和方法?对于任意一个对象,能否调用它的任意一个方法?答案是肯定的。这种动态获得类的信息,以及动态调用对象的方法的功能来自于java语言的反射机制。Java的反射机制提供了以下功能:
1.在运行时获得任意对象所属的类; 2.在运行时构造任意一个类的对象;
3.在运行时得到任意一个对象的所有方法和属性; 4.在运行是动态的调用一个对象的任意方法; 5.生成动态代理。 一、反射API简介
在JDK中,主要由下面的类来完成java的反射机制,这些类都是在java.lang.reflect 包下:
Class:代表一个类,这是一个核心类,包含了对某个具体类的所有信息的描 述;
Field:代表类的成员变量(即属性); Method:代表类的成员方法;
Constructor:代表类的构造方法;
Array:提供了动态创建数组,以及访问数组元素的静态方法。 DumpMethods 类演示了Reflection API的基本作用,它读取命令行参数指定的类名,然 后打印这个类所具有的方法信息:
import java.lang.reflect.*; class DumpMethods {
public static void main(String[] args) throws Exception{ Class cl = Class.forName(args[0]);
Method[] methods = cl.getDeclaredMethods();
for(int i = 0; i < methods.length; i ++){
System.out.println(methods[i].toString()); } } }
示ReflectTester 类进一步演示了Reflection API 的基本使用方法。ReflectTester 类有一个copy(Object object)方法,这个方法能够创建一个和参数object同样类型的 对象,然后把object对象中的所有属性复制到新建的对象中,并将它返回。
这个例子只能复制简单的JavaBean,假定JavaBean的每个属性都有public类型的 getXXX()和setXXX()方法。
import java.lang.reflect.*; public class ReflcetTest{
public static Object copyObj(Object obj) throws Exception{ //获得obj的类
Class cl = obj.getClass();
//通过默认的构造函数构造实例对象
Object copyObj = cl.getConstructor(new Class[]{}).newInstance(new Object[]{});
//得到声明的属性
Field[] fields = cl.getDeclaredFields(); for(int i = 0; i < fields.length; i ++){ Field field = fields[i];
String fieldName = field.getName(); //得到属性名的第一个字母的大些形式
String firstLetter = fieldName.substring(0,1).toUpperCase();
String getMethodName = \fieldName.substring(1);
String setMethodName = \fieldName.substring(1);
//得到相应的get,set方法
Method setMethod = cl.getMethod(setMethodName,new Class[]{field.getType()});
Method getMethod = cl.getMethod(getMethodName,new Class[]{}); //得到原有对象的此属性的值
Object value = getMethod.invoke(obj,new Object[]{}); //将原有值设置到新对象中
setMethod.invoke(copyObj,new Object[]{value}); }
return copyObj; }
public static void main(String[] args) throws Exception{ Student s = new Student(); s.setName(\ s.setSex(\
Student s1 = (Student)ReflcetTest.copyObj(s);
System.out.println(s1.getName() + \ } }
class Student{
private String name ; private String sex;
public Student(){}
public void setName(String name){ this.name = name; }
public void setSex(String sex){ this.sex = sex; }
public String getName(){ return this.name; }
public String getSex(){ return this.sex; } }
java.lang.Array 类提供了动态创建和访问数组元素的各种静态方法。ArrayTester1 类的 main()方法创建了一个长度为20 的字符串数组,接着把索引位置为5 的元素设为 “luoxiaoyi”,然后再读取索引位置为5 的元素的值。
import java.lang.reflect.*; public class ArrayTester1{
public static void main(String[] args)throws Exception{ Class cl = Class.forName(\
Object arrayObj = Array.newInstance(cl,20); Array.set(arrayObj,4,\ String name = (String)Array.get(arrayObj,4); System.out.println(name); } }
ArrayTester2 类的main()方法创建了一个5×10×15 的整型数 组,并把索引位置为[3][5][10]的元素的值为设37。 import java.lang.reflect.*; public class ArrayTester2{
public static void main(String args[]) { int dims[] = new int[]{5, 10, 15};
Object array = Array.newInstance(Integer.TYPE, dims); //使arrayObj 引用array[3]
Object arrayObj = Array.get(array, 3);
Class cls = arrayObj.getClass().getComponentType(); System.out.println(cls);
//使arrayObj 引用array[3][5]
arrayObj = Array.get(arrayObj, 5); //把元素array[3][5][10]设为37 Array.setInt(arrayObj, 10, 37);
int arrayCast[][][] = (int[][][]) array; System.out.println(arrayCast[3][5][10]); } }
二、在远程方法调用中运用反射机制
1、假定在SimpleServer 服务器端创建了一个HelloServiceImpl对象,它具有getTime() 和print()方法。HelloServiceImpl类实现了HelloService接口。如src\\reflect\\remote 下HelloService接口和HelloServiceImpl类的源程序。
2、SimpleClient客户端如何调用服务器端的HelloServiceImpl对象的getTime()和echo()方
法呢?显然,SimpleClient客户端需要把调用的方法名、方法参数类型、方法参数值,以及方法所属的类名或接口名发送给SimpleServer,SimpleServer 再调用相关对象的方法,然后把方法的返回值发送给SimpleClient。为了便于按照面向对象的方式来处理客户端与服务器端的通信,可以把它们发送的信息用Call 类(src\\reflect\\remote)来表示。一个Call对象表示客户端发起的一个远程调用,它包括调用的类名或接口名、方法名、方法参数类型、方法参数值和方法执行结果。
3、SimpleClient 调用SimpleServer 端的HelloServiceImpl 对象的print()方法的流程如下。 (1)SimpleClient 创建一个Call 对象,它包含了调用HelloService 接口的print()方法 的信息。
(2)SimpleClient通过对象输出流把Call对象发送给SimpleServer。
(3)SimpleServer 通过对象输入流读取Call 对象,运用反射机制调用 HelloServiceImpl 对象的echo()方法,把echo()方法的执行结果保存到Call对象中。 (4)SimpleServer 通过对象输出流把包含了方法执行结果的Call 对象发送给 SimpleClient。
(5)SimpleClient通过对象输入流读取Call对象,从中获得方法执行结果。如 src\\reflect\\remote的SimpleServer 和SimpleClient 的源程序。 三、静态代理 四、动态代理:(例子程序:src\\reflect\\proxy)
与静态动态代理相比,动态代理类的字节码在程序运行时由java反射机制自动生成, 不需要程序员自行编写。动态代理不仅简化了程序的编码工作,而且提高了软件系统的 可扩展性,因为,java反射机制能生成任意类型的动态代理类。Java.lang.reflect 包下的Proxy类和InvocationHandler接口提供了生成动态代理类的能力;
Proxy类提供了创建动态代理类和动态代理类实例对象的静态方法: 1、getProxyClass()创建动态代理类,完整定义如下:
public static Class> getProxyClass(ClassLoader loader,
Class>[]interfaces);
loader: 被代理类的类装载器;
interfaces: 被代理类所实现的所有接口。
2、newProxyInstance()创建动态代理类的实例对象,完整定义如下:
public static Object newProxyInstance(Classloader loader,
Class>[] interfaces,InvocationHandler handler);
loader: 被代理类的类装载器;
interfaces: 被代理类所实现的所有接口,
handler: 指定与动态代理类关联的InvocationHandler对象。
以下两种方式都创建了实现Foo接口的动态代理类的实例: /**** 方式一****/
//创建InvocationHandler对象
InvocationHandler handler = newMyInvocationHandler(...); //创建动态代理类
Class proxyClass = Proxy.getProxyClass(Foo.class.getClassLoader(), new Class[] { Foo.class });
//创建动态代理类的实例
Foo foo=(Foo)proxyClass.getConstructor(new Class[]
{InvocationHandler.class }).newInstance(new Object[] { handler }); /**** 方式二****/
//创建InvocationHandler对象
InvocationHandler handler = newMyInvocationHandler(...); //直接创建动态代理类的实例
Foo foo = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
new Class[] { Foo.class },handler);
由Proxy类的静态方法创建的动态代理类具有以下特点: ? 动态代理类是public、final和非抽象类型的; ? 动态代理类继承了java.lang.reflect.Proxy类; ? 动态代理类的名字以“$Proxy”开头;
? 动态代理类实现getProxyClass()和newProxyInstance()方法中参数interfaces指定的所有接口;
? Proxy 类的isProxyClass(Class> cl)静态方法可用来判断参数指定的类是否为动态代理类。只有通过Proxy类创建的类才是动态代理类;
? 动态代理类都具有一个public 类型的构造方法,该构造方法有一个InvocationHandler 类型的参数。
由 Proxy类的静态方法创建的动态代理类的实例具有以下特点:
? 假定变量foo 是一个动态代理类的实例,并且这个动态代理类实现了Foo 接口,那么“foo instanceof Foo”的值为true。把变量foo强制转换为Foo类型 是合法的:
? 每个动态代理类实例都和一个InvocationHandler 实例关联。Proxy 类的
getInvocationHandler(Object proxy)静态方法返回与参数proxy指定的代理类实例所 关联的InvocationHandler 对象。
? 假定Foo接口有一个amethod()方法,那么当程序调用动态代理类实例foo的amethod() 方法时,该方法会调用与它关联的InvocationHandler 对象的invoke()方法。 InvocationHandler 接口为方法调用接口,它声明了负责调用任意一个方法的invoke() 方 法:
Object invoke(Object proxy,Method method,Object[] args) throws Throwable参数 proxy指定动态代理类实例,参数method指定被调用的方法,参数args 指定向被调用方 法传递的参数,invoke()方法的返回值表示被调用方法的返回值。 五、总结:
Java 反射机制是Java 语言的一个重要特性。考虑实现一个 newInstance(StringclassName)方法,它的作用是根据参数className 指定的类名,通 过该类的不带参数的构造方法创建这个类的对象,并将其返回。如果不运用Java 反射 机制,必须在newInstance()方法中罗列参数className所有可能的取值,然后创建相应 的对象:
public Object newInstance(String className) throws Exception{ if(className.equals(\return new HelloService1();
if(className.equals(\return new HelloService2();
if(className.equals(\return new HelloService3();
if(className.equals(\return new HelloService4(); ...
if(className.equals(\return new HelloService1000();
}
以上程序代码很冗长,而且可维护性差。如果在以后软件的升级版本中去除了一个elloService4类,或者增加了一个HelloService1001类,都需要修改以上newInstance()方法。如果运用反射机制,就可以简化程序代码,并且提高软件系统的可维护性和可扩展性:
public Object newInstance(String className) throws Exception{
Class classType=Class.forName(className); return classType.newInstance(); }
Java 反射机制在服务器程序和中间件程序中得到了广泛运用。在服务器端,往往需要根据客户的请求,动态调用某一个对象的特定方法(MVC或Struts中)。此外,有一种ORM(Object-Relation Mapping,对象-关系映射)中间件能够把任意一个JavaBean 持久化到关系数据库中。在ORM 中间件的实现中,运用Java 反射机制来读取任意一个JavaBean的所有属性,或者给这些属性赋值(Hibernate)。
在JDK类库中,主要由以下类来实现Java反射机制,这些类都位于java.lang.reflect包中。
??Class类:代表一个类。 ? Field类:代表类的属性。 ? Method类:代表类的方法。
? Constructor 类:代表类的构造方法。
? Array类:提供了动态创建数组,以及访问数组元素的静态方法。
? Proxy类和InvocationHandler 接口:提供了生成动态代理类及其实例的方法。