java 代理机制

需求

我们一般在书写功能函数的时候，需要在代码外围加入特定的代码，如日志记录，事务控制，但是增加这类枝节的代码会带来以下问题:

1. 枝节性代码游离在功能性代码之外，它下是函数的目的，这是对OO是一种破坏
2. 枝节性代码会造成功能性代码对其它类的依赖，加深类之间的耦合，而这是OO系统所竭 力避免的
3. 枝节性代码带来的耦合度会造成功能性代码移植困难，可重用性降低
4. 从法理上说，枝节性代码应该`监视'着功能性代码，然后采取行动，而不是功能性代码 `通知'枝节性代码采取行动，这好比吟游诗人应该是主动记录骑士的功绩而不是骑士主 动要求诗人记录自己的功绩

反思

怎么在函数执行块外围加一些功能型的代码，而又不影响程序函数本身，遵循oo的原则呢？能不能通过组合的形式，一个对象(真实对象)作为另一个类(代理类)的属性传入，然后调用传入对象的方法，然后本实例的函数执行所谓的外围代码(事务，日志)，而不把整个功能分开。好吧，这是一种解决方法，也就是今天要学习的代理机制。

定义

毫无疑问，枝节性代码和功能性代码需要分开来才能降低耦合程度，符合现代OO系统的要 求，我们可以使用代理模式完成这个要求。

代理模式的作用是：为其它对象提供一种代理以控制对这个对象的访问。在某些情况下，一 个客户不想直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介作用。 代理模式一般涉及到三个角色：

1. 抽象角色：声明真实对象和代理对象的共同接口
2. 代理角色：代理对象内部包含有真实角色的引用，从而可以操作真实角色，同时代理对象 与真实对象有相同的接口，能在任何时候代替真实对象，同时代理对象可以在执行真实对 象前后加入特定的逻辑以实现功能的扩展。
3. 真实角色：代理角色所代表的真实对象，是我们最终要引用的对象

常见的代理有:

1. 远程代理(Remote Proxy)：对一个位于不同的地址空间对象提供一个局域代表对象，如RMI中的stub
2. 虚拟代理(Virtual Proxy)：根据需要将一个资源消耗很大或者比较复杂的对象，延迟加 载，在真正需要的时候才创建
3. 保护代理(Protect or Access Proxy)：控制对一个对象的访问权限。
4. 智能引用(Smart Reference Proxy)：提供比目标对象额外的服务和功能。

通过代理类这一中间层，能够有效控制对实际委托类对象的直接访问，也可以很好地隐藏和 保护实际对象，实施不同的控制策略，从而在设计上获得了更大的灵活性。

实现

代理模式UML图

代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。 代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后 续处理。

 

以下以《Java与模式》中的示例为例：

 

// 抽象角色：abstract public class Subject {    abstract public void  request();}// 真实角色：实现了Subject的request()方法public class  RealSubject  extends  Subject  {  public  RealSubject()  { }  public void  request()  {     System.out.println( " From real subject. " );    }}// 代理角色：public class  ProxySubject  extends  Subject  {  // 以真实角色作为代理角色的属性  private  Subject realSubject;  public  ProxySubject(Subject realSubject)  {this.realSubject = realSubject }  // 该方法封装了真实对象的request方法  public void  request()  {     preRequest();     realSubject.request();  // 此处执行真实对象的request方法     postRequest();  }  ...}// 客户端调用：RealSubject real = new RealSubject();Subject sub = new  ProxySubject(real);Sub.request();

 

问题

Sub上述是实现了加入外围代码，但是问题又出现了。如果这样实现代理的话，我们具体的一个对象就要使用一个代理类，那程序如果N多个使用代理的话，程序就显得很笨拙和臃肿。那么怎么解决呢？当然，java为我们提供了动态代理。

动态代理

1.java动态代理定义

所谓Dynamic Proxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一 组interface给它，然后该class就宣称它实现了这些 interface。你当然可以把该class的实 例当作这些interface中的任何一个来用。当然啦，这个Dynamic Proxy其实就是一个Proxy， 它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工 作。

 java动态代理UML图

 

java动态代理类位于java.lang.reflect包下，一般主要涉及到以下两个类：

1. Interface InvocationHandler：该接口中仅定义了一个方法Object：invoke(Object obj,Method method, Object[] args)。在实际使用时，第一个参数obj一般是指代理 类，method是被代理的方法，如上例中的request()，args为该方法的参数数组。 这个抽 象方法在代理类中动态实现。
2. Proxy：该类即为动态代理类，作用类似于上例中的ProxySubject。
3. Protected Proxy(InvocationHandler h)：构造函数，估计用于给内部的h赋值。
4. Static Class getProxyClass (ClassLoader loader, Class[] interfaces)：获得一个 代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。
5. Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)：返回代理类的一个实例，返回后的代理类可以当作被代理类使用 (可使用被代理类的在Subject接口中声明过的方法)。

在使用动态代理类时，我们必须实现InvocationHandler接口，以第一节中的示例为例：

// 抽象角色(之前是抽象类，此处应改为接口)：public  interface Subject {  abstract  public  void request();}// 具体角色RealSubject：public  class RealSubject implements Subject {  public RealSubject() {}  public  void request() {    System.out.println( " From real subject. " ); }}// 代理处理器：import java.lang.reflect.Method;import java.lang.reflect.InvocationHandler;public  class DynamicSubject implements InvocationHandler {  private Object sub;  public DynamicSubject() {}  public DynamicSubject(Object obj) {    sub = obj;  }  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {    System.out.println( " before calling "  + method);    method.invoke(sub,args);    System.out.println( " after calling "  + method);    return  null ;  }}

该代理类的内部属性为Object类，实际使用时通过该类的构造函数DynamicSubject(Object obj)对其赋值；此外，在该类还实现了invoke方法，该方法中的

method.invoke(sub,args);

其实就是调用被代理对象的将要被执行的方法，方法参数sub是实际的被代理对象，args为执 行被代理对象相应操作所需的参数。通过动态代理类，我们可以在调用之前或之后执行一些 相关操作。

// 客户端：import java.lang.reflect.InvocationHandler;import java.lang.reflect.Proxy;import java.lang.reflect.Constructor;import java.lang.reflect.Method;public class Client {  static public void main(String[] args) throws Throwable {   RealSubject rs = new RealSubject(); // 在这里指定被代理类   InvocationHandler ds = new DynamicSubject(rs);   Class cls = rs.getClass();   // 以下是一次性生成代理   Subject subject = (Subject) Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(),ds );   subject.request();  }}// 程序运行结果：before calling public abstract void Subject.request()From real subject.after calling public abstract void Subject.request()

通过这种方式，被代理的对象(RealSubject)可以在运行时动态改变，需要控制的接口 (Subject接口)可以在运行时改变，控制的方式(DynamicSubject类)也可以动态改变，从而实 现了非常灵活的动态代理关系。

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