结构型模式：代理模式(Proxy Pattern)

一、设计模式的分类

(如果以前看过关于设计模式的分类的话，这部分可以忽略！)

经过很多大神的总结，目前Java中一共23种经典的设计模式！

按照目的，设计模式可以分为以下三种用途：

1.创建型模式：用来处理对象的创建过程

2.结构型模式：用来处理类或者对象的组合

3.行为型模式：用来对类或对象怎样交互和怎样分配职责进行描述

创建型模式用来处理对象的创建过程，主要包含以下5种设计模式：

 工厂方法模式（Factory Method Pattern）

 抽象工厂模式（Abstract Factory Pattern）

 建造者模式（Builder Pattern）

 原型模式（Prototype Pattern）

 单例模式（Singleton Pattern）

结构型模式用来处理类或者对象的组合，主要包含以下7种设计模式：

 适配器模式（Adapter Pattern）

 桥接模式（Bridge Pattern）

 组合模式（Composite Pattern）

 装饰者模式（Decorator Pattern）

 外观模式（Facade Pattern）

 享元模式（Flyweight Pattern）

 代理模式（Proxy Pattern）

行为型模式用来对类或对象怎样交互和怎样分配职责进行描述，主要包含以下11种设计模式：

 责任链模式（Chain of Responsibility Pattern）

 命令模式（Command Pattern

 解释器模式（Interpreter Pattern）

 迭代器模式（Iterator Pattern）

 中介者模式（Mediator Pattern）

 备忘录模式（Memento Pattern）

 观察者模式（Observer Pattern）

 状态模式（State Pattern）

 策略模式（Strategy Pattern）

 模板方法模式（Template Method Pattern）

 访问者模式（Visitor Pattern） 

本篇文章主要为讲解一下代理模式（Proxy Pattern）！

注：概念性的东西可以忽略不看，可以在看完例子以后再看概念，这样更有利于理解！

二、代理模式概述

1、概述：

定义：代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。

好处：在一些情况下，一个客户不想或者不能够直接引用一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

思想：代理模式的思想是为了提供额外的处理或者不同的操作而在实际对象与调用者之间插入一个代理对象。这些额外的操作通常需要与实际对象进行 通信。

2、代理模式类图：

3、代理模式中的角色：

　　●抽象对象角色：声明了目标对象和代理对象使用的共同接口，这样一来在任何可以使用目标对象的地方都可以使用代理对象。

　　●目标对象角色：定义了代理对象所代表的目标对象。

　　●代理对象角色：代理对象内部含有目标对象的引用，从而可以在任何时候操作目标对象；代理对象和目标对象实现相同的接口，以便可以在任何时候替代目标对象。代理对象通常在客户端调用传递给目标对象之前或之后去执行某个操作，而不是单纯地将调用传递给目标对象。

4、静态代理的具体实现：

下面只是一个简单的例子，方便大家理解，实际有很多复杂的代理模式，比如：动态代理、远程代理、虚拟代理、保护代理等等，有很多种代理模式的变体。

抽象对象角色：

public abstract class AbstractObject {
    public abstract void operation();
}

　　目标对象角色：

public class RealObject extends AbstractObject {
    @Override
    public void operation() {
        System.out.println("一些操作");
    }
}

　　代理对象角色：

public class ProxyObject extends AbstractObject{
    RealObject realObject = new RealObject();
    @Override
    public void operation() {
        System.out.println("before");        
        realObject.operation();        
        System.out.println("after");
    }
}

　　客户端：

public class Client {
    public static void main(String[] args) {
        AbstractObject obj = new ProxyObject();
        obj.operation();
    }
}

　　从例子中可以看出代理对象将客户端的调用委派给目标对象，在调用目标对象的方法之前跟之后都可以执行特定的操作。

不过，如果要按照上述的方法使用代理模式(静态代理)，那么真实角色必须是事先已经存在的，并将其作为代理对象的内部属性。但是实际使用时，一个真实角色必须对应一个代理角色，如果大量使用会导致类的急剧膨胀；此外，如果事先并不知道真实角色，该如何使用代理呢？这个问题可以通过Java的动态代理类来解决。

5、动态代理的具体实现：

Java动态代理类位于Java.lang.reflect包下，一般主要涉及到以下两个类：
1、接口==》Interface InvocationHandler：

该接口中仅定义了一个方法Object：invoke(Object obj,Method method, Object[] args)。

在实际使用时，第一个参数obj一般是指代理类，method是被代理的方法，如上例中的request()，args为该方法的参数数组。对应的抽象方法是在代理类中动态实现的。

2、类==》Proxy：

该类就是动态代理类，作用类似于上例中的ProxyObject，它主要包含以下内容：
Protected Proxy(InvocationHandler invocationHandler )：构造函数，估计用于给内部的invocationHandler赋值。
Static Class getProxyClass (ClassLoader loader, Class[] interfaces)：获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。
Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler invocationHandler)：返回代理类的一个实例，返回后的代理类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法)。

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

在使用动态代理类时，我们必须实现InvocationHandler接口： 

抽象角色：

public interface Subject{
     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(Object sub){            
           this.sub = sub;
     }
     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 sub)对其赋值；此外，在该类还实现了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();
  //以下是分解步骤
  /**
   *  Class c = Proxy.getProxyClass(cls.getClassLoader(),cls.getInterfaces());
   * Constructor ct=c.getConstructor(new Class[]{InvocationHandler.class});
   * Subject subject =(Subject) ct.newInstance(new Object[]{ds});
   */

//以下是一次性生成
  Subject subject = (Subject) Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(),ds);
  subject.request();
}
通过这种方式，被代理的对象(RealSubject)可以在运行时动态改变，需要控制的接口(Subject接口)可以在运行时改变，控制的方式(DynamicSubject类)也可以动态改变，从而实现了非常灵活的动态代理关系。

6、代理模式的应用形：

1、远程代理(Remote Proxy)：

可以隐藏一个对象存在于不同地址空间的事实。也使得客户端可以访问在远程机器上的对象，远程机器可能具有更好的计算性能与处理速度，可以快速响应并处理客户端请求。

2、虚拟代理(Virtual Proxy)：

允许内存开销较大的对象在需要的时候创建。只有我们真正需要这个对象的时候才创建。

3、写入时复制代理(Copy-On-Write Proxy)：

用来控制对象的复制，方法是延迟对象的复制，直到客户真的需要为止。是虚拟代理的一个变体。

4、保护代理(Protection (Access)Proxy)：

为不同的客户提供不同级别的目标对象访问权限

5、缓存代理(Cache Proxy)：

为开销大的运算结果提供暂时存储，它允许多个客户共享结果，以减少计算或网络延迟。

6、防火墙代理(Firewall Proxy)：

控制网络资源的访问，保护主题免于恶意客户的侵害。

7、同步代理(SynchronizationProxy)：

在多线程的情况下为主题提供安全的访问。

8、智能引用代理(Smart ReferenceProxy)：

当一个对象被引用时，提供一些额外的操作，比如将对此对象调用的次数记录下来等。

9、复杂隐藏代理(Complexity HidingProxy)：

用来隐藏一个类的复杂集合的复杂度，并进行访问控制。有时候也称为外观代理(Façade Proxy)，这不难理解。复杂隐藏代理和外观模式是不一样的，因为代理控制访问，而外观模式是不一样的，因为代理控制访问，而外观模式只提供另一组接口。

7、代理模式与装饰模式的区别：

装饰模式：以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案；

代理模式：给一个对象提供一个代理对象，并有代理对象来控制对原有对象的引用；

装饰模式应该为所装饰的对象增强功能；而代理模式对代理的对象施加控制，并不提供对象本身的增强功能。

两者的实现机制确实是一样的，可以看到他们的实例代码重复是很多的。但就语义上说，这两者的功能是相反的，模式的一个重要作用是简化其他程序员对你程序的理解，

你在一个地方写装饰，大家就知道这是在增加功能，你写代理，大家就知道是在限制，虽然代码很可能相同，但如果你都叫他们装饰，别人会很迷惑的。

学习AOP时，教材上面都说使用的是动态代理，可是在印象中代理模式一直都是控制访问什么的，怎么又动态增加行为了，动态增加行为不是装饰器模式吗？于是 找了很多资料，想弄清楚这两者之间到底有什么区别。结果发现这一篇英文文章讲的很清晰，就翻译一下，供参考。       

        首先，让我们先看一下下面的这两个UML类图，他们分别描述了装饰器模式和代理模式的基本实现。

1、装饰器模式：

                    

2、代理模式：

                     

从类图上看，对装饰器模式来说，装饰者（decorator）和被装饰者（decoratee）都实现同一个 接口。对代理模式来说，代理类（proxy class）和真实处理的类（real class）也都实现同一个接口。此外，不论我们使用哪一个模式，都可以很容易地在真实对象的方法前面或者后面加上自定义的方法。

        然而，实际上，在装饰器模式和代理模式之间还是有很多差别的。装饰器模式关注于在一个对象上动态的添加方法，然而代理模式关注于控制对对象的访问。换句话说，用代理模式，代理类（proxy class）可以对它的客户隐藏一个对象的具体信息。因此，当使用代理模式的时候，我们常常在一个代理类中创建一个对象的实例。然而，当我们使用装饰器模式的时候，我们通常的做法是将原始对象作为一个参数传给装饰者的构造器。

        我们可以用另外一句话来总结这些差别：使用代理模式，代理和真实对象之间的的关系通常在编译时就已经确定了，而装饰者能够在运行时递归地被构造。    

代理模式：

//代理模式
public class Proxy implements Subject{
       private Subject subject;
       public Proxy(){
             //关系在编译时确定
            subject = new RealSubject();
       }
       public void doAction(){
             ….
             subject.doAction();
             ….
       }
}

//代理的客户
public class Client{
        public static void main(String[] args){
             //客户不知道代理委托了另一个对象
             Subject subject = new Proxy();
             …
        }
}

装饰模式：

//装饰器模式
public class Decorator implements Component{
        private Component component;
        public Decorator(Component component){
            this.component = component
        }
       public void operation(){
            ….
            component.operation();
            ….
       }
}

//装饰器的客户
public class Client{
        public static void main(String[] args){
            //客户指定了装饰者需要装饰的是哪一个类
            Component component = new Decorator(new ConcreteComponent());
            …
        }
}

下面有马士兵老师的一个例子，表示个人感觉没看懂！大家可以看一下!

http://gongjiayun.iteye.com/blog/948778