Dynamic Proxy是这样一种class:它是在运行时生成的class,在生成它时你必须提供一组interface给它,然后该class就宣称它实现了这些 interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然啦,这个Dynamic Proxy其实就是一个Proxy,它不会替你作实质性的工作,在生成它的实例时你必须提供一个handler,由它接管实际的工作 。
动态代理的定义:一个动态代理类在运行期implements一组interface,使得interface实现类的方法调用被分派至其他的类(另外的interface实现类或者任意的类)的方法。讲得更通俗一些,要了解动态代理,我们就要知道什么东西动态了,代理了什么?首先,一个Proxy代理了一组interface的方法。注意,代理的是interface,而不是Class,也不是abstract Class;其次,Proxy具有的型别由绑定的interface所决定的,动态就体现在此。
实例:
java 代码
- package cn.feigme.dynamicProxy;
- /**
- * @author Feigme
- *
- */
- public interface IOperation {
- void operationA();
- void operationB();
- }
java 代码
- package cn.feigme.dynamicProxy;
- /**
- * @author Feigme
- *
- */
- public class OperationResource implements IOperation {
- /* (non-Javadoc)
- * @see cn.feigme.dynamicProxy.IOperation#operationA()
- */
- public void operationA() {
- System.out.println("OperationResource.operationA()-->do!");
- }
- /* (non-Javadoc)
- * @see cn.feigme.dynamicProxy.IOperation#operationB()
- */
- public void operationB() {
- System.out.println("OperationResource.operationB()-->do!");
- }
- }
java 代码
- package cn.feigme.dynamicProxy;
- import java.lang.reflect.InvocationHandler;
- import java.lang.reflect.Method;
- import java.lang.reflect.Proxy;
- /**
- * @author Feigme
- *
- */
- public class OperationDynamicProxy implements InvocationHandler {
- private IOperation iOperation;
- public OperationDynamicProxy() {
- }
- public IOperation bind(IOperation iOperation) {
- this.iOperation = iOperation;
- IOperation proxyIOperation = (IOperation)Proxy.newProxyInstance(iOperation
- .getClass().getClassLoader(), iOperation.getClass()
- .getInterfaces(), this);
- return proxyIOperation;
- }
- /*
- * (non-Javadoc)
- *
- * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object,
- * java.lang.reflect.Method, java.lang.Object[])
- */
- public Object invoke(Object obj, Method method, Object[] args)
- throws Throwable {
- Object o = null;
- if("operationA".equals(method.getName())){
- System.out.println("DynamicProxy.invoke()-->proxy operationA >do");
- }else{
- o = method.invoke(iOperation, args);
- }
- return o;
- }
- }
测试
java 代码
- package cn.feigme.dynamicProxy;
- import org.junit.After;
- import org.junit.Before;
- import org.junit.Test;
- /**
- * @author Feigme
- *
- */
- public class TestProxy {
- @Test
- public void DynamicProxyTest() {
- OperationDynamicProxy proxy = new OperationDynamicProxy();
- IOperation iOperation = proxy.bind(new OperationResource());
- iOperation.operationA();
- iOperation.operationB();
- }
- }
阅读上述代码:
上述就是一个简单的动态代理的例子。我们可以看到Dynamic Proxy并没有实现IOperation这个接口,但是包含了IOperation接口实现类的实例;在Dynamic Proxy的bind方法中,通过调用Proxy.newProxyInstance创建一个Proxy,并将该Proxy与IOperation接口绑定,最后将Proxy显式类型转换成IOperation接口类型并返回,这样调用者就可以通过Proxy调用interface定义的方法了;由于 Proxy与IOperation接口绑定了,对IOperation接口的方法调用,都会交由Proxy的invoke方法去处理。而invoke方法会根据不同的方法,或给以全新的实现,或直接将方法调用交给Proxy中包含的IOperation接口实现类的实例去处理。综合上面所说的,作为一个Dynamic Proxy,它必须满足以下三个条件:
1、实现了InvocationHandler接口,实现接口中定义的invoke方法;
2、包含接口实现类的实例;
3、通过Proxy.newProxyInstance方法实现Proxy与接口之间的绑定。