java代理机制

一、一般情况下处理业务的方法

只要实现处理业务逻辑的代码就行了。比如下面的DoSomething中的doSomething()方法为模拟处理业务的代码。客户端只要调用DoSomething中doSomething()方法即可

处理业务代码DoSomething.java

import java.util.Random; 2  3 public class DoSomething { 4     public void doSomething(){ 5         System.out.println("doing something..."); 6         try { 7             Thread.sleep((new Random().nextInt(2000)));                                    //模拟处理需要时间 8         } catch (InterruptedException e) { 9             e.printStackTrace();10         }11     }12 }

客户端调用代码Client.java

public class Client {2     public static void main(String args[]){3         DoSomething doSomething = new DoSomething();4         doSomething.doSomething();5     }6 }

现在需要在控制台输出这个方法的执行时间，该怎么实现呢

直接在doSomething()方法中添加开始时间和结束时间的代码，输出执行时间。DoSomething.java代码如下所示

import java.util.Random; 2  3 public class DoSomething { 4     public void doSomething(){ 5         long startTime = System.currentTimeMillis(); 6         System.out.println("doing something..."); 7         try { 8             Thread.sleep((new Random().nextInt(2000)));                                    //模拟处理需要时间 9         } catch (InterruptedException e) {10             e.printStackTrace();11         }12         long endTime = System.currentTimeMillis();13         14         System.out.println("执行任务耗时:" + (endTime - startTime) + "毫秒");15     }16 }

从输出可以看到功能已经实现。

但是，这样代码耦合度会增加。如果我不需要输出执行时间，每一个方法都需要去修改。不利于代码重用

二、设计模式纸代理模式Proxy

上面为什么代码耦合度会高呢，主要是业务逻辑代码和分支代码混在一起。把这两个分开，即可解耦。这里可以利用设计模式里面的代理模式

下面是代理模式的UML图

从图中可以看出代理模式和实际业务处理共同实现了一个接口，这样在客户端就可以面向接口编程了。在ProxySubject中有RealSubject的引用，在代理中可以调用RealSubject的方法。同时，可以在调用RealSubject的方法时候进行其他处理。比如前面所说的计算所耗费的时间等...

将上面的的代码按照Proxy模式实现。先定义一个接口，接口中为RealSubject中所有的方法。这里就是上面DoSomething中的doSomething()方法。代理类和RealSubject分别实现这个接口。代理类添加RealSubject的引用。在客户端使用代理。

代码如下所示

IDoSomething.java对应上图中的Subject

public interface IDoSomething {2     public void doSomething();3 }

DoSomething.java对应上图中的RealSubject

public class DoSomething implements IDoSomething { 2  3     @Override 4     public void doSomething() { 5         System.out.println("doing something..."); 6         try { 7             Thread.sleep((new Random().nextInt(2000)));                                    //模拟处理需要时间 8         } catch (InterruptedException e) { 9             e.printStackTrace();10         }11 12     }13 14 }

Proxy.java对应上图中的ProxySubject

public class Proxy implements IDoSomething { 2     IDoSomething doSomething = new DoSomething();                                        //实际处理类引用 3      4      5     @Override 6     public void doSomething() { 7         long startTime = System.currentTimeMillis(); 8         doSomething.doSomething();                                                         //处理业务的方法 9         long endTime = System.currentTimeMillis();10         11         System.out.println("执行任务耗时:" + (endTime - startTime) + "毫秒");12 13     }14 15 }

Client.java

public class Client {2 3     public static void main(String[] args) {4         IDoSomething doSomeThingProxy = new Proxy();                        5         doSomeThingProxy.doSomething();                                                    //调用代理类的方法6     }7 8 }

这样就实现了两种代码的分离，降低代码耦合度

但是这样也有缺点。这里实现的Subject类型的代理，如果我有很多种类型呢。是不是需要为每一种类型写代理呢。java代理机制提供了一种解决方案。动态代理机制

三、java代理机制

首先，先看一下java代理机制的UML图

这里没有画出Client端。从上图中可以看出这里Proxy中没有直接引用RealSubject，而是引用了ProxyInHand对象。ProxyInHand中引用了RealSubject方法。（这里只是从UML中看出来的）

这里先直接给出实现步骤

首先让我们来了解一下如何使用 Java 动态代理。具体有如下四步骤：

1. 通过实现 InvocationHandler 接口创建自己的调用处理器；
2. 通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类；
3. 通过反射机制获得动态代理类的构造函数，其唯一参数类型是调用处理器接口类型；
4. 通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数被传入。

清单 3. 动态代理对象创建过程

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发// 其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用InvocationHandler handler = new InvocationHandlerImpl(..); // 通过 Proxy 为包括 Interface 接口在内的一组接口动态创建代理类的类对象Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... }); // 通过反射从生成的类对象获得构造函数对象Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class }); // 通过构造函数对象创建动态代理类实例Interface Proxy = (Interface)constructor.newInstance(new Object[] { handler });

实际使用过程更加简单，因为 Proxy 的静态方法 newProxyInstance 已经为我们封装了步骤 2 到步骤 4 的过程，所以简化后的过程如下

清单 4. 简化的动态代理对象创建过程

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发InvocationHandler handler = new InvocationHandlerImpl(..); // 通过 Proxy 直接创建动态代理类实例Interface proxy = (Interface)Proxy.newProxyInstance( classLoader,  new Class[] { Interface.class },  handler );

个人理解，先写好处理业务逻辑的代码RealSubject，实现InvocationHandler接口（java api） InvocationHandlerImpl,在InvocationHandlerImpl中调用RealSubject处理方法。通过

Interface proxy = (Interface)Proxy.newProxyInstance( classLoader,  new Class[] { Interface.class },  handler );方法生成代理类

 

参考：

http://www.cnblogs.com/machine/archive/2013/02/21/2921345.html

http://www.ibm.com/developerworks/cn/java/j-lo-proxy1/

http://blog.csdn.net/giserstone/article/details/17199755

源码：http://files.cnblogs.com/files/luckygxf/JavaDynProxy.zip