Java 高新技术之动态代理

 

 

 

用了一下午的时间把代理又复习了一遍，下面我对有关代理的相关知识做一下总结汇总。主要归结为以下几个主要问题：

 

1、什么是动态代理?
2、为什么使用动态代理?
3、使用它有哪些好处?
4、哪些地方需要动态代理?

 

首先，先来介绍一下代理模式

 

代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。

 
按照代理的创建时期，代理类可以分为两种。 
静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。 
动态代理：在程序运行时，运用反射机制动态创建而成。 

 

动态代理： 

和动态代理有关的有两个类
1.interface InvocationHandler
Object invoke(Object proxy, Method method, Object[] args)

2.class Proxy
真正表示动态代理的类，提供两个静态方法:

Class<?> getProxyClass(ClassLoader loader, Class<?>[] interface)
用来产生代理类，参数要提供interface数组，它会生成这些interface的“虚拟实现”，
用来冒充真实的对象。

Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
用来产生代理对象，多了InvocationHandler参数(只是InvocationHandler接口的实现类)，
它与代理对象关联，当请求分发到代理对象后，会自动执行h.invoke(...)方法，

 

看完与动态代理有关的两个类后，大致明白动态代理的含义：

A接口有c方法，类B实现A接口，原本应该是执行B类中的c方法，现在可以不这样做；
先声明产生B类的代理类B',由它来冒充B类的“兄弟”并“实现”A接口，
对外界来说B'应该也有c方法，可当真正调用它的时候，
它会去执行与它关联InvocationHandler的invoke()方法，
在这个方法里面你可以做很多事情。这样，这个请求就被“代理”到其它地方去了。

 

下面是根据对动态代理的理解所画出的一个原理图 ：

 

动态代理事例：
 

package proxy;

public interface Hello {
	//打招呼
	void sayHello(String str);  
	//打印输出
	void print(String str); 
}

 

 

它的实现类：

 

package proxy;

public class HelloImpl implements Hello {

	@Override
	public void sayHello(String str) {
		// TODO Auto-generated method stub
		System.out.println("Say hello to" + str);
	}

	@Override
	public void print(String str) {
		// TODO Auto-generated method stub
		System.out.println("Print:" + str);
	}
}

 

 

下面生成与代理类相关联的InvocationHandler对象 ：

 

package proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class LogHandler implements InvocationHandler {
	private Object obj; 
	
	public LogHandler(Object obj) {  
		this.obj= obj;  
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		// TODO Auto-generated method stub
		doBefore();  
		//在这里可以做任何事情
		Object result = method.invoke(obj, args);  
		after();  
		return result;
	}
	
	private void doBefore() {  
		System.out.println("...before...");  
	}  
	
	private void after() {  
		System.out.println("...after...");  
	}  
}

 

 

最后编写一个测试类，代码如下：

 

package proxy;

import java.lang.reflect.Proxy;

public class ProxyTest {

    public static void main(String[] args) {
        HelloImpl impl = new HelloImpl();
        LogHandler handler = new LogHandler(impl);
        //这里把handler与impl新生成的代理类相关联
        Hello hello = (Hello) Proxy.newProxyInstance(impl.getClass().getClassLoader(), 
        		impl.getClass().getInterfaces(), handler);
        
        //这里无论访问哪个方法，都是会把请求转发到handler.invoke
        hello.print("正在测试");
        hello.sayHello("Chu");
    }

}

 

 

【运行结果】如下：

 

...before...
Print:正在测试
...after...
...before...
Say hello toChu
...after...

 

 

最后我们来回答本文开始时提出的几个总结性问题:

1、什么是动态代理?
一种用于转发请求，进行特殊处理的机制，“动态”应该指的是“运行期”。

2、为什么使用动态代理?
可以对请求进行任何处理(如事务，日志等，这都是网上说的，我当然可以做任何处理) ；动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。

3、使用它有哪些好处?
可以对请求进行任何处理(如事务，日志等，这都是网上说的，我当然可以做任何处理) ；与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。

 

4.哪些地方需要，动态代理?
不允许直接访问某些类；对访问要做特殊处理的时候就要用到代理。

 

 最后的总结：

 

1、如果想声明产生B类的代理类，那个B类必须要实现接口，如果没有接口，代理类就不能伪装成B类的“兄弟”，也就没有存在的意思， 其实也可以伪装成B类的“孩子”。

2、当请求代理类的方法时，这个请求会被转到执行与代理类关联InvocationHandler
的invoke方法。

 

InvocationHandler可以这样理解:
它用来处理方法的调用，实现类也有同样的意义；与代理类对象相关联，它就是负责处理代理类应该有的动作，把所有的方法请求分发到 invoke 这个方法上。

 

由Proxy类的静态方法创建的动态代理类具有以下特点：

动态代理类是public、final和非抽象类型的；
动态代理类继承了java.lang.reflect.Proxy类；
动态代理类的名字以“$Proxy”开头；
动态代理类实现 getProxyClass() 和 newProxyInstance() 方法中参数 interfaces 指定的所有接口；

Proxy 类的isProxyClass(Class<?> cl)静态方法可用来判断参数指定的类是否为动态代理类。只有通过Proxy类创建的类才是动态代理类；

动态代理类都具有一个public 类型的构造方法，该构造方法有一个InvocationHandler 类型的参数。

 

由Proxy类的静态方法创建的动态代理类的实例具有以下特点：

1、假定变量foo 是一个动态代理类的实例，并且这个动态代理类实现了Foo 接口，那么“foo instanceof Foo”的值为true。把变量foo强制转换为Foo类型是合法的：
(Foo) foo //合法

2、每个动态代理类实例都和一个InvocationHandler 实例关联。Proxy 类的getInvocationHandler(Object proxy)静态方法返回与参数proxy指定的代理类实例所关联的InvocationHandler 对象。

3、假定Foo接口有一个amethod()方法，那么当程序调用动态代理类实例foo的amethod()方法时，该方法会调用与它关联的InvocationHandler 对象的invoke()方法。

InvocationHandler 接口为方法调用接口，它声明了负责调用任意一个方法的invoke()方法：
Object invoke(Object proxy,Method method,Object[] args) throws Throwable

参数proxy指定动态代理类实例，参数method指定被调用的方法，参数args 指定向被调用方法传递的参数，invoke()方法的返回值表示被调用方法的返回值。