解析代理模式（Proxy）

前言

代理模式其实在生活中非常常见，就比如你想买火车票不一定要去火车站买。而是可以去附近的代售点或者是在手机上的12306App上买，这里的代售点和12306App就是代理类。

亦或是在外面租房子，当我们无法方便的找到房东直租时，可以直接委托租房中介帮助我们找房子。这里的租房中介便是代理类。

什么是代理模式

使用一个代理对象将原始对象包装起来，然后用该代理对象取代原始的对象。任何对原始对象的调用都需要经过代理对象。代理对象决定时候以及何时将方法调用转到原始对象上。

代理模式的结构

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

代理模式的主要角色如下：

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

其结构图如下所示：

在代码中，一般代理会被理解为代码增强，实际上就是在原代码逻辑前后增加一些代码逻辑，而使调用者无感知。

静态代理

在编译期间已经确定好了代理类，静态代理一个代理类只能服务一个特定的业务实现类。

package kk.java;

/**
 * <p>
 * 静态代理举例
 * </P>
 *
 * @author Kk
 * @since 2022/5/22 18:49
 */
//业务接口
interface ClothFactory {
    void produceCloth();
}

//被代理类
class NikeClothFactory implements ClothFactory {

    @Override
    public void produceCloth() {
        System.out.println("Nike工厂生产一批运动服");
    }
}

//代理类
class ProxyClothFactory implements ClothFactory {

    //被代理类对象
    private ClothFactory factory;

    //将被代理类对象进行实例化
    public ProxyClothFactory(ClothFactory factory) {
        this.factory = factory;
    }

    @Override
    public void produceCloth() {
        System.out.println("代理工厂做一些准备工作");
        factory.produceCloth();
        System.out.println("代理工厂做一些收尾工作");
    }
}


public class StaticProxyTest {
    public static void main(String[] args) {
        //创建被代理类对象
        NikeClothFactory nike = new NikeClothFactory();
        //创建代理类对象
        ProxyClothFactory proxyClothFactory = new ProxyClothFactory(nike);
        proxyClothFactory.produceCloth();
    }
}

 静态代理运行结果

代理工厂做一些准备工作
Nike工厂生产一批运动服
代理工厂做一些收尾工作

Process finished with exit code 0

 可以发现这里在并没有修改原本的业务实现类的基础上新增了新的功能。

很快我们就能发现上面做法的不足，一个代理类只能代理一个特定的业务实现类。

如果我们还有其他的业务实现类呢，那么还需要编写一个代理类来代理，这样导致扩展性极低需要编写许多代理类来实现。效率极低。

为了解决这个问题，那么就有了动态代理

动态代理

动态代理采用反射的机制，在运行时创建一个接口类的实例。在JDK的实现中，我们需要借助Proxy类和InvocationHandler接口类。

package kk.java;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * <p>
 * 动态代理举例
 * </P>
 *
 * @author Kk
 * @since 2022/5/22 19:04
 */
interface Human {
    String getBelief();

    void eat(String food);
}

//被代理类
class SuperMan implements Human {

    @Override
    public String getBelief() {
        return "没有情人的情人节~";
    }

    @Override
    public void eat(String food) {
        System.out.println("我喜欢吃" + food);
    }
}

/*
要想实现动态代理，需要解决什么问题？
问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类以及对象
问题二：当通过代理类的对象调用方法时，如何动态地去调用被代理类中的同名方法
 */
class DynamicProxyFactory {
    //调用此方法，返回一个代理类对象。解决问题一
    public Object getProxyInstance(Object obj) { //obj为被代理类的对象
        MyInvocationHandler handler = new MyInvocationHandler();
        handler.bind(obj);
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), handler);
    }
}

class MyInvocationHandler implements InvocationHandler {

    private Object obj; //需要使用被代理类的对象进行赋值

    public void bind(Object obj) {
        this.obj = obj;
    }

    //当我们通过代理类的对象调用方法a时，就会自动调用以下的invoke()方法。解决了问题二
    //将被代理类要执行的方法a的功能就声明在invoke()方法中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return method.invoke(obj, args);
    }
}

public class DynamicProxyTest {
    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();
        DynamicProxyFactory dynamicProxyFactory = new DynamicProxyFactory();
        Human proxyInstance = (Human) dynamicProxyFactory.getProxyInstance(superMan);
        System.out.println(proxyInstance.getBelief());
        proxyInstance.eat("火龙果");

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

        NikeClothFactory nike = new NikeClothFactory();
        ClothFactory nikeProxyInstance = (ClothFactory) dynamicProxyFactory.getProxyInstance(nike);
        nikeProxyInstance.produceCloth();
    }
}

没有情人的情人节~
我喜欢吃火龙果
------------------------------
Nike工厂生产一批运动服

Process finished with exit code 0

总结

代理模式通常有如下几种用途：

• 远程代理，这种方式通常是为了隐藏目标对象存在于不同地址空间的事实，方便客户端访问。例如，用户申请某些网盘空间时，会在用户的文件系统中建立一个虚拟的硬盘，用户访问虚拟硬盘时实际访问的是网盘空间。
• 虚拟代理，这种方式通常用于要创建的目标对象开销很大时。例如，下载一幅很大的图像需要很长时间，因某种计算比较复杂而短时间无法完成，这时可以先用小比例的虚拟代理替换真实的对象，消除用户对服务器慢的感觉。
• 保护代理，当对目标对象访问需要某种权限时，保护代理提供对目标对象的受控保护，例如，它可以拒绝服务权限不够的客户。
• 智能指引，主要用于调用目标对象时，代理附加一些额外的处理功能。例如，增加计算真实对象的引用次数的功能，这样当该对象没有被引用时，就可以自动释放它(C++智能指针)；例如上面的房产中介代理就是一种智能指引代理，代理附加了一些额外的功能，例如带看房等。

代理模式的主要优点有：

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

其主要缺点是：

• 静态代理模式会造成系统设计中类的数量增加，但动态代理可以解决这个问题；
• 在客户端和目标对象之间增加一个代理对象，会造成请求处理速度变慢；
• 增加了系统的复杂度；