简简单单的代码让你轻松学会动态代理


前言：

最近一直在分析Hadoop的RPC机制。在hadoop中，DataNode和NameNode之间的控制信息的交流是通过RPC机制完成的，采用的是动态代理和Java NIO(参考： ) 的方式。DataNode端是通过获得NameNode的代理，通过该代理和NameNode进行通信的，为了更好的分析hadoop的RPC机制我想先分析一下动态代理是怎么实现。下面就是动态代理的最最简单的代码实现，我们一起来看看吧。

代码如下：

  1. package cn.xiaolu;   
  2.   
  3. import java.lang.reflect.InvocationHandler;   
  4. import java.lang.reflect.Method;   
  5. import java.lang.reflect.Proxy;   
  6.   
  7. /**  
  8.  * 动态代理类使用到了一个接口InvocationHandler和一个代理类Proxy ，这两个类配合使用实现了动态代理的功能。  
  9.  * 那么什么是动态代理呢？  
  10.  * 我们平常说的代理类是指： 给每个具体类写一个代理类，以后要使用某个具体类时，只要创建它的代理类的对象，然后调用代理类的方法就可以了。  
  11.  * 可是如果现在有许多的具体类，那就需要有许多的代理类才可以，这样很显然不合适。所以动态代理就应运而生了，我们只要写一个类实现  
  12.  * InvocationHandler 并实现它的invoke方法，然后再用Proxy的工厂方法newProxyInstance（）创建一个代理对象，这个对象同样可以实现对具体类的代理功能。  
  13.  * 而且想代理哪个具体类，只要给Handler（以下代码中的Invoker）的构造器传入这个具体对象的实例就可以了。感觉是不是自己为该具体类造了一个代理类呢？呵呵~  
  14.  */  
  15.   
  16. //接口类   
  17. interface AbstractClass {   
  18.   
  19.     public void show();   
  20.   
  21. }   
  22.   
  23. // 具体类A   
  24. class ClassA implements AbstractClass {   
  25.   
  26.     @Override  
  27.     public void show() {   
  28.         // TODO Auto-generated method stub   
  29.         System.out.println("我是A类！");   
  30.     }   
  31. }   
  32.   
  33. // 具体类B   
  34. class ClassB implements AbstractClass {   
  35.   
  36.     @Override  
  37.     public void show() {   
  38.         // TODO Auto-generated method stub   
  39.         System.out.println("我是B类！");   
  40.     }   
  41. }   
  42. //动态代理类，实现InvocationHandler接口   
  43. class Invoker implements InvocationHandler {   
  44.     AbstractClass ac;   
  45.   
  46.     public Invoker(AbstractClass ac) {   
  47.         this.ac = ac;   
  48.     }   
  49.   
  50.     @Override  
  51.     public Object invoke(Object proxy, Method method, Object[] arg)   
  52.             throws Throwable {   
  53.         //调用之前可以做一些处理   
  54.         method.invoke(ac, arg);   
  55.         //调用之后也可以做一些处理   
  56.         return null;   
  57.     }   
  58. }   
  59.   
  60. /**  
  61.  * 测试类  
  62.  * @author 小路  
  63.  */  
  64. class DynamicProxyTest {   
  65.   
  66.     public static void main(String[] args) {   
  67.         //创建具体类ClassB的处理对象   
  68.         Invoker invoker1=new Invoker(new ClassA());   
  69.         //获得具体类ClassA的代理   
  70.         AbstractClass ac1 = (AbstractClass) Proxy.newProxyInstance(   
  71.                 AbstractClass.class.getClassLoader(),   
  72.                 new Class[] { AbstractClass.class }, invoker1);   
  73.         //调用ClassA的show方法。   
  74.         ac1.show();   
  75.            
  76.            
  77.         //创建具体类ClassB的处理对象   
  78.         Invoker invoker2=new Invoker(new ClassB());   
  79.         //获得具体类ClassB的代理   
  80.         AbstractClass ac2 = (AbstractClass) Proxy.newProxyInstance(   
  81.                 AbstractClass.class.getClassLoader(),   
  82.                 new Class[] { AbstractClass.class }, invoker2);   
  83.         //调用ClassB的show方法。   
  84.         ac2.show();   
  85.   
  86.     }   
  87. }  

程序运行后的结果如下：

  1. 我是A类！   
  2. 我是B类！  
很快我会写一篇关于hadoop RPC机制分析的文章，见： ，希望大家继续关注。

相关内容