设计模式回顾——代理模式

1. 代理模式的定义
代理模式：为其他对象提供一种代理以控制对这个对象的访问。
使用代理模式创建代理对象，让代理对象控制目标对象的访问，目标对象可以是远程的对象、创建开销比较大的对象或需要安全控制的对象，另外还可以在不改变目标对象的情况下添加一些额外的功能。举个例子，比如歌手和经纪人，实际唱歌的是歌手，但要歌手参加演出需要通过经纪人，由经纪人安排歌手演出，这里歌手是目标对象，经济人是代理对象，这个场景也可以添加一些额外的功能，比如歌手出场时穿的服装可以是某某赞助商的（又可以收一笔钱）。

2. 代理模式的类图：

详细说明如下：
Subject：抽象主题角色，是一个接口。该接口是对象和它的代理共用的接口。
RealSubject：真实主题角色，是实现抽象主题接口的类。
Proxy：代理角色，内部含有对真实对象RealSubject的引用，从而可以操作真实对象。代理对象提供与真实对象相同的接口，以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。
代理主要分为两类，静态代理和动态代理。

3. 静态代理
静态代理比较简单，是由程序员编写的代理类，并在程序运行前就编译好的，而不是由程序动态产生代理类，这就是所谓的静态，以上面经纪人和艺人的例子，实现静态代理：

/**
 * 抽象的艺人借口，艺人可以唱歌跳舞
 * 
 */
public interface Actor {
    public void sing();

    public void dance();
}

/**
 * 真实的艺人，具有唱歌、跳舞的技能
 */
public class MichaelJackson implements Actor {

    public void sing() {
        System.out.println("五千年的风和雨啊藏了多少梦…………");
    }

    public void dance() {
        System.out.println("滴滴答…………滴滴答…………");
    }

}

/**
 * 经纪人作为艺人的代理人，经纪人不会唱歌跳舞，由经纪人安排艺人来唱歌跳舞
 * 
 */
public class Agent implements Actor {

    private Actor subject;

    public Agent(Actor subject) {
        this.subject = subject;
    }

    public void sing() {
        System.out.println("before sing......");
        subject.sing();
        System.out.println("after sing......");
    }

    public void dance() {
        System.out.println("before dance......");
        subject.dance();;
        System.out.println("after dance......");
    }
}

4. 动态代理
静态代理模式的特点是一个主题类与一个代理类一一对应，但是，也存在这样的情况，有多个主题类，但是代理类中的“前处理、后处理”都是一样的，仅调用主题不同。也就是说，多个主题类对应一个代理类，共享“前处理，后处理”功能，动态调用所需主题，大大减小了程序规模， 动态代理中，代理类并不是在Java代码中实现，而是在运行时期生成，相比静态代理，动态代理可以很方便的对委托类的方法进行统一处理。

JDK的动态代理机制有两个重要的类或接口，一个是 InvocationHandler(Interface)、另一个则是 Proxy(Class)，这一个类和接口是实现我们动态代理所必须用到的，首先我们先来看看InvocationHandler：
每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。我们来看看InvocationHandler这个接口的唯一一个方法 invoke 方法：

Object invoke(Object proxy, Method method, Object[] args) throws Throwable

三个参数的含义如下：

• proxy：指代我们所代理的那个真实对象
• method：指代的是我们所要调用真实对象的某个方法的Method对像
• args：指代的是调用真实对象某个方法时接受的参数

接下来我们来看看Proxy这个类：Proxy这个类的作用就是用来动态创建一个代理对象的类，它提供了许多的方法，但是我们用的最多的就是 newProxyInstance 这个方法：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,  InvocationHandler h)  throws IllegalArgumentException

三个参数的含义如下：

• loader：一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载
• interfaces：一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了
• h：一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上

现在来看看实际的例子，动态代理类：

public class DynamicProxy implements InvocationHandler {
    // 　这个就是我们要代理的真实对象
    private Object subject;

    // 构造方法，给我们要代理的真实对象赋初值
    public DynamicProxy(Object subject) {
        this.subject = subject;
    }

    public Object invoke(Object object, Method method, Object[] args)
            throws Throwable {
        //在代理真实对象前我们可以添加一些自己的操作, 也可以用method.getName()方法获取不动的方法名字，做特殊处理
        System.out.println("before method " + method.getName());

        //当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
        method.invoke(subject, args);

        //在代理真实对象后我们也可以添加一些自己的操作
        System.out.println("after method " + method.getName());
        return null;
    }
}

测试代码：

    @Test
    public void TestDynamicProxy() {
        // 我们要代理的真实对象
        Actor jackson = new MichaelJackson();

        // 我们要代理哪个真实对象，就将该对象传进去，最后是通过该真实对象来调用其方法的
        InvocationHandler handler = new DynamicProxy(jackson);

        /*
         * 通过Proxy的newProxyInstance方法来创建我们的代理对象，我们来看看其三个参数
         *  第一个参数handler.getClass().getClassLoader() 我们这里使用handler这个类的ClassLoader对
         *  象来加载我们的代理对象
         * 
         * 第二个参数realSubject.getClass().getInterfaces()，我们这里为代理对象提供的接口是真实对象所实行的接口，
         * 表示我要代理的是该真实对象，这样我就能调用这组接口中的方法了 
         * 
         * 第三个参数handler， 我们这里将这个代理对象关联到了上方的InvocationHandler 这个对象上
         */
        Actor actor = (Actor) Proxy.newProxyInstance(handler.getClass()
                .getClassLoader(), jackson.getClass().getInterfaces(),
                handler);

        System.out.println(actor.getClass().getName());
        actor.sing();
        actor.dance();
    }

5. 代理模式的应用形式

• 远程代理(Remote Proxy)：可以隐藏一个对象存在于不同地址空间的事实。也使得客户端可以访问在远程机器上的对象，远程机器可能具有更好的计算性能与处理速度，可以快速响应并处理客户端请求。
• 虚拟代理(Virtual Proxy) ：允许内存开销较大的对象在需要的时候创建。只有我们真正需要这个对象的时候才创建。
• 写入时复制代理(Copy-On-Write Proxy)：用来控制对象的复制，方法是延迟对象的复制，直到客户真的需要为止。是虚拟代理的一个变体。
• 保护代理(Protection (Access)Proxy)：为不同的客户提供不同级别的目标对象访问权限
• 缓存代理(Cache Proxy) ：为开销大的运算结果提供暂时存储，它允许多个客户共享结果，以减少计算或网络延迟。
• 防火墙代理(Firewall Proxy) ：控制网络资源的访问，保护主题免于恶意客户的侵害。
• 同步代理(SynchronizationProxy)：在多线程的情况下为主题提供安全的访问。
• 智能引用代理(Smart ReferenceProxy)：当一个对象被引用时，提供一些额外的操作，比如将对此对象调用的次数记录下来等。
• 复杂隐藏代理(Complexity HidingProxy) ：用来隐藏一个类的复杂集合的复杂度，并进行访问控制。有时候也称为外观代理(Façade
  Proxy)，这不难理解。复杂隐藏代理和外观模式是不一样的，因为代理控制访问，而外观模式是不一样的，因为代理控制访问，而外观模式只提供另一组接口。