设计模式学习笔记（三、结构型-代理模式）

目录：

• 什么是代理模式
• 为什么要有代理模式
• 如何实现代理模式
• 代理模式应用场景

什么是代理模式

在不改变原始类（被代理类）代码的情况下，通过代理类给被代理类增强的一种模式，这种模式叫做代理模式。

为什么要有代理模式

代理模式可以让被代理类不变更的情况下，使其拥有更多附加功能，使其只关注核心功能，忽略掉附加功能。让代码更简洁，更易维护。

如何实现代理模式

1、静态代理：

首先我们先看一段代码

public class UserController {

    /**
     * 通过构造函数注入
     */
    private MetricsCollector metricsCollector;

    public void login(String mobile, String password) {
        long start = System.currentTimeMillis();
        // 这里是登录的业务逻辑
        long end = System.currentTimeMillis();
        long resTime = end - start;
        metricsCollector.record("/login", resTime);
    }

    public void register(String mobile, String password) {
        long start = System.currentTimeMillis();
        // 这里是注册的业务逻辑
        long end = System.currentTimeMillis();
        long resTime = end - start;
        metricsCollector.record("/register", resTime);
    }
}

上面这段代码包含了登录的注册逻辑，且他们都做了统计接口响应时间的逻辑。

很明显这两个接口都做了同意的附加功能，这样不仅会影响代码的可读性，也会在修改统计逻辑的时候花费较大的成本。

像这种情况我们可以通过代理模式很好的解决这个场景了，如下。

public interface IUserController {

    void login(String mobile, String password);

    void register(String mobile, String password);
}

public class UserController implements IUserController {

    /**
     * 通过构造函数注入
     */
    private MetricsCollector metricsCollector;

    @Override
    public void login(String mobile, String password) {
        // 这里是登录的业务逻辑
    }

    @Override
    public void register(String mobile, String password) {
        // 这里是注册的业务逻辑
    }
}

public class UserControllerProxy implements IUserController {

    private UserController userController;
    private MetricsCollector metricsCollector;

    public UserControllerProxy(UserController userController) {
        this.userController = userController;
        this.metricsCollector = new MetricsCollector();
    }

    @Override
    public void login(String mobile, String password) {
        long start = System.currentTimeMillis();
        userController.login(mobile, password);
        long end = System.currentTimeMillis();
        long resTime = end - start;
        metricsCollector.record("/login", resTime);
    }

    @Override
    public void register(String mobile, String password) {
        long start = System.currentTimeMillis();
        userController.register(mobile, password);
        long end = System.currentTimeMillis();
        long resTime = end - start;
        metricsCollector.record("/register", resTime);
    }
}

public class Test {

    public static void main(String[] args) {
        IUserController userController = new UserControllerProxy(new UserController());
    }
}

很简单，只需要新建一个IUserController，让业务类UserController和代理类UserControllerProxy实现它即可。

然后通过IUserController iUserController = new UserControllerProxy(new UserController())使用即可。

但并不是所有的接口都是自己维护的，可能你需要对第三方的功能进行扩展，此时不能定义接口来扩展了，那咋办嘛。其实只要使用继承就可以了，代码与上述类似，这里不再赘述。

———————————————————————————————————————————————————————

2、动态代理：

上述代理模式的实现方式是通过实现接口和继承的方式来达到代理的目的，但如果要需要对其它接口增加统计响应时间的功能，就需要新增代理类。

也就是每加一个被代理类就需要加一个代理类，这样非常麻烦，而且也不好维护。

上述的这种加代理类的方式，我们称之为静态代理。

针对静态代理的缺点，我们可以通过动态代理来解决，也就是在运行的过程中动态的创建代理类，替换掉原始类。

在Java中已经提供了动态代理的语法，所以很容易就能实现，如下：

public class MetricsCollectorProxy {

    private MetricsCollector metricsCollector;

    public MetricsCollectorProxy() {
        this.metricsCollector = new MetricsCollector();
    }

    /**
     * 创建代理类
     *
     * @param target 被代理类
     * @return 代理类
     */
    public Object createProxy(Object target) {
        ClassLoader classLoader = target.getClass().getClassLoader();
        Class<?>[] interfaces = target.getClass().getInterfaces();
        DynamicProxyHandler proxyHandler = new DynamicProxyHandler(target);
        return Proxy.newProxyInstance(classLoader, interfaces, proxyHandler);
    }

    private class DynamicProxyHandler implements InvocationHandler {
        private Object proxiedObject;

        DynamicProxyHandler(Object proxiedObject) {
            this.proxiedObject = proxiedObject;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            long start = System.currentTimeMillis();
            Object result = method.invoke(proxiedObject, args);
            long end = System.currentTimeMillis();
            long resTime = end - start;
            String apiName = proxiedObject.getClass().getName() + ":" + method.getName();
            metricsCollector.record(apiName, resTime);
            return result;
        }
    }
}

public class Test {

    public static void main(String[] args) {
        MetricsCollectorProxy metricsCollectorProxy = new MetricsCollectorProxy();
        IUserController proxy = (IUserController) metricsCollectorProxy.createProxy(new UserController());
    }
}

通过Proxy.newProxyInstance(classLoader, interfaces, proxyHandler)实现动态代理。

代理模式应用场景

1、业务系统中非功能性的开发，如监控、统计、鉴权、限流、事务、幂等、日志等。

2、接口缓存：两套代码，一套正常查库，一套走redis、内存这类的缓存，通过动态代理实现，让调用者选择模式。