`
feigme
  • 浏览: 153147 次
  • 性别: Icon_minigender_1
  • 来自: 球面世界
社区版块
存档分类
最新评论

试刀——DynamicProxy

    博客分类：
  • Java
Javajunit工作
阅读更多
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 代码
  1. package cn.feigme.dynamicProxy;   
  2.   
  3. /**  
  4.  * @author Feigme   
  5.  *  
  6.  */  
  7. public interface IOperation {   
  8.   
  9.     void operationA();   
  10.     void operationB();   
  11. }   
java 代码
  1. package cn.feigme.dynamicProxy;   
  2.   
  3. /**  
  4.  * @author Feigme   
  5.  *  
  6.  */  
  7. public class OperationResource implements IOperation {   
  8.   
  9.     /* (non-Javadoc)  
  10.      * @see cn.feigme.dynamicProxy.IOperation#operationA()  
  11.      */  
  12.     public void operationA() {   
  13.         System.out.println("OperationResource.operationA()-->do!");   
  14.   
  15.     }   
  16.   
  17.     /* (non-Javadoc)  
  18.      * @see cn.feigme.dynamicProxy.IOperation#operationB()  
  19.      */  
  20.     public void operationB() {   
  21.         System.out.println("OperationResource.operationB()-->do!");   
  22.   
  23.     }   
  24.   
  25. }   
java 代码
  1. package cn.feigme.dynamicProxy;   
  2.   
  3. import java.lang.reflect.InvocationHandler;   
  4. import java.lang.reflect.Method;   
  5. import java.lang.reflect.Proxy;   
  6.   
  7. /**  
  8.  * @author Feigme  
  9.  *   
  10.  */  
  11. public class OperationDynamicProxy implements InvocationHandler {   
  12.   
  13.     private IOperation iOperation;   
  14.   
  15.     public OperationDynamicProxy() {   
  16.     }   
  17.   
  18.     public IOperation bind(IOperation iOperation) {   
  19.         this.iOperation = iOperation;   
  20.         IOperation proxyIOperation = (IOperation)Proxy.newProxyInstance(iOperation   
  21.                 .getClass().getClassLoader(), iOperation.getClass()   
  22.                 .getInterfaces(), this);   
  23.         return proxyIOperation;   
  24.     }   
  25.   
  26.     /*  
  27.      * (non-Javadoc)  
  28.      *   
  29.      * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object,  
  30.      *      java.lang.reflect.Method, java.lang.Object[])  
  31.      */  
  32.     public Object invoke(Object obj, Method method, Object[] args)   
  33.             throws Throwable {   
  34.         Object o = null;   
  35.         if("operationA".equals(method.getName())){   
  36.             System.out.println("DynamicProxy.invoke()-->proxy operationA >do");   
  37.         }else{   
  38.             o = method.invoke(iOperation, args);   
  39.         }   
  40.         return o;   
  41.     }   
  42.   
  43. }  
测试
java 代码
  1. package cn.feigme.dynamicProxy;   
  2.   
  3. import org.junit.After;   
  4. import org.junit.Before;   
  5. import org.junit.Test;   
  6.   
  7. /**  
  8.  * @author Feigme  
  9.  *   
  10.  */  
  11. public class TestProxy {   
  12.   
  13.     @Test  
  14.     public void DynamicProxyTest() {   
  15.         OperationDynamicProxy proxy = new OperationDynamicProxy();   
  16.         IOperation iOperation = proxy.bind(new OperationResource());   
  17.         iOperation.operationA();   
  18.         iOperation.operationB();   
  19.     }   
  20.   
  21. }   

阅读上述代码：

上述就是一个简单的动态代理的例子。我们可以看到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与接口之间的绑定。

分享到：
| 查树结构的一条SQL语句
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

Magicbox
Global site tag (gtag.js) - Google Analytics