第七章 代理模式 （Proxy）

代理模式的定义与特点

代理模式的定义：由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。

代理模式的主要优点有：

1. 代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用；
2. 代理对象可以扩展目标对象的功能；
3. 代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度；

其主要缺点

1. 在客户端和目标对象之间增加一个代理对象，会造成请求处理速度变慢；
2. 增加了系统的复杂度；

代理模式的结构与实现

代理模式的结构比较简单，主要是通过定义一个继承抽象主题的代理来包含真实主题，从而实现对真实主题的访问，下面来分析其基本结构和实现方法。

1. 模式的结构

代理模式的主要角色如下。
抽象主题（Subject）类：通过接口或抽象类声明真实主题和代理对象实现的业务方法。
真实主题（Real Subject）类：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。
代理（Proxy）类：提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能。

结构图如下所示：

2. 模式的代码实现

抽象主题类(委托类)：

public interface Subject {

    void print();
}

Subject接口定义类RealSubject和Proxy的共同接口，这样在任何使用RealSubject的地方都可以使用Proxy。

真实主题类：

public class RealSubject implements Subject {

    public void print() {
        System.out.println("被代理对象方法执行");
    }
}

RealSubject类定义了Proxy所代表的真实实体。

代理类：

public class Proxy implements Subject {

    private RealSubject realSubject;

    public Proxy() {
    }

    public Proxy(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    public void print() {
        System.out.println("进入代理类方法");

        if (realSubject == null) {
            realSubject = new RealSubject();
        }
        realSubject.print();

        System.out.println("代理类方法执行完毕");
    }
}

保存一个引用使得代理可以访问实体，并重写了Subject的方法，这样就可以使用代理类代替实体。

测试类:

public class ProxyTest {

    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();
        Proxy proxy = new Proxy(realSubject);

        proxy.print();
    }
}

测试结果：

进入代理类方法
被代理对象方法执行
代理类方法执行完毕

Process finished with exit code 0

代理模式的应用

前面分析了代理模式的结构与特点，现在来分析以下的应用场景。

1. 远程代理，这种方式通常是为了隐藏目标对象存在于不同地址空间的事实，方便客户端访问。例如，用户申请某些网盘空间时，会在用户的文件系统中建立一个虚拟的硬盘，用户访问虚拟硬盘时实际访问的是网盘空间。
2. 虚拟代理，这种方式通常用于要创建的目标对象开销很大时。例如，下载一幅很大的图像需要很长时间，因某种计算比较复杂而短时间无法完成，这时可以先用小比例的虚拟代理替换真实的对象，消除用户对服务器慢的感觉。
3. 安全代理，这种方式通常用于控制不同种类客户对真实对象的访问权限。
4. 智能指引，主要用于调用目标对象时，代理附加一些额外的处理功能。例如，增加计算真实对象的引用次数的功能，这样当该对象没有被引用时，就可以自动释放它。
5. 延迟加载，指为了提高系统的性能，延迟对目标的加载。例如，Hibernate 中就存在属性的延迟加载和关联表的延时加载。

代理模式的扩展

在前面介绍的代理模式中，代理类中包含了对真实主题的引用，这种方式存在两个缺点。

1. 真实主题（委托类实现类）与代理主题（代理类）一一对应，增加真实主题也要增加代理。
2. 设计代理以前真实主题（委托类实现类）必须事先存在，不太灵活。采用动态代理模式可以解决以上问题。

动态代理

代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。

按照代理的创建时期，代理类可以分为两种。

• 静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。
• 动态代理：在程序运行时，运用反射机制动态创建而成。 实现方式包含jdk和cglib两种方式。

动态代理部分，摘抄自https://www.cnblogs.com/jqyp/archive/2010/08/20/1805041.html

JDK动态代理

与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。

委托类接口：

public interface Subject {

    void sayHello();
}

具体委托类：

public class RealSubject implements Subject {

    public void sayHello() {
        System.out.println("hello，这是jdk动态代理");
    }
}

public class AnotherRealSubject implements Subject {

    public void sayHello() {
        System.out.println("hello，另一个jdk动态代理");
    }
}

动态代理类：

public class DynamicProxy implements InvocationHandler {

    //被代理对象的引用
    private Object target;

    public Object bind(Object target) {
        this.target = target;

        //限制了委托类必须实现接口
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;

        System.out.println("事务开始========");
        result = method.invoke(target, args);
        System.out.println("事务结束========");

        return result;
    }
}

测试类：

public class JdkProxyTest {

    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();

        DynamicProxy dynamicProxy = new DynamicProxy();
        Subject subject = (Subject) dynamicProxy.bind(realSubject);

        subject.sayHello();

        System.out.println("====================================");

        AnotherRealSubject anotherRealSubject = new AnotherRealSubject();

        Subject anotherSubject = (Subject) dynamicProxy.bind(anotherRealSubject);

        anotherSubject.sayHello();

    }
}

测试结果：

事务开始========
hello，这是jdk动态代理
事务结束========

====================================
事务开始========
hello，另一个jdk动态代理
事务结束========

Process finished with exit code 0

动态代理和静态代理最明显的区别就是代理类只有一个，一个代理类可以代理多个委托类，比如上面的DynamicProxy可以同时代理RealSubject和AnotherRealSubject。静态代理的话是委托类和代理类一一对应。并且代理类不需要实现与委托类相同的接口。DynamicProxy类需要实现InvocationHandler接口。并重写invoke()方法，在其中调用委托类的方法，完成委托的职责。bind()方法则是用过Proxy类生成代理类对象，参数是被代理的委托类对象。

Cglib动态代理

JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。

更多cglib的解释可参考https://blog.csdn.net/jiaotuwoaini/article/details/51675684

委托类：

 public class Subject {

    public void sayHello() {
        System.out.println("hello，这是cglib动态代理");
    }
}

public class AnotherSubject {

    public void sayHello(String name) {
        System.out.println("hello " + name + "，这是另一个cglib动态代理");
    }
}

委托类并没有实现接口。

代理类：

public class DynamicProxy implements MethodInterceptor {

    //委托类引用
    private Object target;

    public Object getInstance(Object target) {
        this.target = target;

        //1. 创建核心类
        Enhancer enhancer = new Enhancer();
        //2. 设置父类。cglib是通过继承委托类的方式实现代理
        enhancer.setSuperclass(this.target.getClass());
        //3.回调方法
        //需要传入MethodInterceptor|NoOp|LazyLoader|Dispatcher|InvocationHandler|FixedValue的实现类
        enhancer.setCallback(this);
        //4.创建代理对象
        return enhancer.create();
    }

    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("事务开始======");
        methodProxy.invokeSuper(o, objects);
        System.out.println("事务结束======");
        return null;
    }
}

代理类需要实现MethodInterceptor接口，重写其中的itercept方法，并通过methodProxy.invokeSuper(o, objects)调用委托类的方法。DynamicProxy中包含了委托类的引用，并通过Enhancer创建代理类对象。

测试类：

public class CglibProxyTest {

    public static void main(String[] args) {
        Subject subject = new Subject();

        DynamicProxy dynamicProxy = new DynamicProxy();
        Subject subjectAfterProxy = (Subject) dynamicProxy.getInstance(subject);

        subjectAfterProxy.sayHello();

        System.out.println("====================================");

        AnotherSubject anotherSubject = new AnotherSubject();
        AnotherSubject anotherSubjectAfterProxy = (AnotherSubject) dynamicProxy.getInstance(anotherSubject);

        anotherSubjectAfterProxy.sayHello("jack");

    }
}

测试结果：

事务开始======
hello，这是cglib动态代理
事务结束======

====================================
事务开始======
hello jack，这是另一个cglib动态代理
事务结束======

Process finished with exit code 0