设计模式学习笔记 - 设计模式与范式 -结构型：1.代理模式：代理在RPC、缓存、监控等场景中的应用

陈建1112024-03-29 12:27

概述

前面几个章节，我们学习了设计模式中的创建型模式。创建型模式主要解决对象的创建问题，封装复杂的创建过程，解耦对象的创建代码和使用代码。

  • 单例模式用来创建全局唯一的对象。
  • 工厂模式用来创建不同但是相关类型的对象（继承同一父类或接口的一组子类），由给定的参数来决定创建哪种类型的对象。
  • 建造者模式是用来创建复杂对象，可以通过设置不同的可选参数，"定制化" 地创建不同的对象。
  • 原型模式针对创建成本比较大的对象，利用已有对象进行复制的方式进行创建，已达到节省创建时间的目的。

从本章开始，我们学习结构性模式。结构性模式主要总结了一些类或对象组合在一起的经典结构，这些经典的结构可以解决特定应用场景的问题。结构型模式包括：代理模式、桥接模式、装饰器模式、适配器模式、门面模式、组合模式、享元模式。

本章要讲解结构型模式中的代理模式。它也是在实际开发中经常被用到的一种设计模式。

代理模式的原理解析

代理模式的原理和代码实现都不难掌握。它在不改变原始类（也叫被代理类）代码的情况下，通过引入代理类来给原始类附加功能。我们通过一个例子来解释下这段话。

这个例子来自我们在《设计原则 - 10.实战：针对非业务的通用框架开发，如何做需求分析和设计及如何实现一个支持各种统计规则的性能计数器》和《设计原则与思想总结：2.运用学过的设计原则和思想完善之前性能计数器项目》中讲的性能计数器。当时我们开发了一个 MetricsCollector 类，用来收集请求的原始数据，比如访问时间、处理时长等。在业务系统重，我们采用如下方式来使用这个 MetricsCollector 类。

java 复制代码 
public class UserController {
    // 省略其他属性和方法...
    private MetricsCollector metricsCollector; // 依赖注入

    public UserVo register(UserVo user) {
        long startTimestamp = System.currentTimeMillis();
        // 省略register逻辑...
        long endTimestamp = System.currentTimeMillis();
        long responseTime = endTimestamp - startTimestamp;
        RequestInfo requestInfo = new RequestInfo("register", responseTime, startTimestamp);
        metricsCollector.recordRequest(requestInfo);
        // 返回UserVo数据...
        return null;
    }

    public UserVo login(String telephone, String password) {
        long startTimestamp = System.currentTimeMillis();
        // 省略login逻辑...
        long endTimestamp = System.currentTimeMillis();
        long responseTime = endTimestamp - startTimestamp;
        RequestInfo requestInfo = new RequestInfo("login", responseTime, startTimestamp);
        metricsCollector.recordRequest(requestInfo);
        // 返回UserVo数据...
        return null;
    }
}

很显然，上面的写法有两个问题。

  • 第一，性能计数器框架代码侵入到业务代码中，跟业务代码高度耦合。如果未来需要替换这个框架，那替换的成本会比较大。
  • 第二，收集接口请求的代码跟业务代码无关，本就不应该放到一个类中。业务类最好职责更加单一，只聚焦业务处理。

为了将框架和业务代码解耦，代理模式就派上用场了。代理类 UserControllerProxy 和 原始类 UserController 实现相同的接口 IUserController。UserController 类只负责业务功能。代理类 UserControllerProxy 负责在业务代码执行前后附加其他逻辑代码，并通过委托的方式调用原始类来执行业务代码。具体代码的实现如下：

java 复制代码 
public interface IUserController {
    UserVo login(String telephone, String password);
    UserVo register(UserVo user);
}

public class UserController implements IUserController {
    // 省略其他属性和方法...
    @Override
    public UserVo login(String telephone, String password) {
        // 省略login逻辑...
        // 返回UserVo数据...
        return null;
    }

    @Override
    public UserVo register(UserVo user) {
        // 省略register逻辑...
        // 返回UserVo数据...
        return null;
    }
}

public class UserControllerProxy implements IUserController {
    private MetricsCollector metricsCollector;
    private UserController userController;

    @Override
    public UserVo login(String telephone, String password) {
        long startTimestamp = System.currentTimeMillis();

        // 委托
        UserVo userVo = userController.login(telephone, password);

        long endTimestamp = System.currentTimeMillis();
        long responseTime = endTimestamp - startTimestamp;
        RequestInfo requestInfo = new RequestInfo("login", responseTime, startTimestamp);
        metricsCollector.recordRequest(requestInfo);

        return userVo;
    }

    @Override
    public UserVo register(UserVo user) {
        long startTimestamp = System.currentTimeMillis();

        // 委托
        UserVo userVo = userController.register(user);

        long endTimestamp = System.currentTimeMillis();
        long responseTime = endTimestamp - startTimestamp;
        RequestInfo requestInfo = new RequestInfo("register", responseTime, startTimestamp);
        metricsCollector.recordRequest(requestInfo);

        return userVo;
    }
}

// UserControllerProxy 使用举例
// 因为原始类和代理类实现相同的接口，是基于接口而非实现编程
// 将UserController类对象替换为 UserControllerProxy 类对象，不需要改动太多代码
IUserController userController = new UserControllerProxy(new UserController());

参照基于接口而非实现编程的设计思想，将原始类对象替换为代理对象时，为了让代码改动尽量少，在刚刚的代理模式的代码实现中，代理类和原始类需要实现相同的接口。但是，如果原始类并没有定义接口，并且原始类代码不是我们开发维护的（比如它来自一个第三方的类库），我们也没有办法修改原始类，给它重新定义一个接口。在这种情况下，该如何实现代理模式呢？

对于这种外部类的扩展，我们一般都是采用继承的方式。这里也不例外。我们让代理类继承原始类然后扩展附加功能。原理很简单，你直接看代码就能明白。具体代码如下所示：

java 复制代码 
public class UserControllerProxy extends UserController {
    private MetricsCollector metricsCollector;

    @Override
    public UserVo login(String telephone, String password) {
        long startTimestamp = System.currentTimeMillis();

        UserVo userVo = super.login(telephone, password);

        long endTimestamp = System.currentTimeMillis();
        long responseTime = endTimestamp - startTimestamp;
        RequestInfo requestInfo = new RequestInfo("login", responseTime, startTimestamp);
        metricsCollector.recordRequest(requestInfo);

        return userVo;
    }

    @Override
    public UserVo register(UserVo user) {
        long startTimestamp = System.currentTimeMillis();

        UserVo userVo = super.register(user);

        long endTimestamp = System.currentTimeMillis();
        long responseTime = endTimestamp - startTimestamp;
        RequestInfo requestInfo = new RequestInfo("register", responseTime, startTimestamp);
        metricsCollector.recordRequest(requestInfo);

        return userVo;
    }
}

动态代理的原理解析

其实，刚刚的代码还是有点问题。

  • 一方面，我们需要再代理类中，将原始类的所有方法，都重新实现一遍，并且为每个方法都附加相似的代码逻辑。
  • 另一方面，如果要添加的附加功能的类又不止一个，我们需要对每个类都创建一个代理类。

如果有 50 个要添加附加功能的原始类，我们就要创建 50 个代理类。这会导致项目中类的个数成倍增加，增加了代码的维护成本。并且，每个代理类中的代码都有点像模板模式的 "重复" 代码，也增加了不必要的开发成本。这个问题怎么解决呢？

可以使用动态代理来解决这个问题。所谓动态代理，就是我们不事先为每个原始类编写代理类，而是在运行的时候，动态地创建原始类对应的代理类，然后再=在系统中用代理类替换掉原始类。

如果你熟悉 Java 语言，实现动态代理就是件很简单的事情。因为 Java 语言本身就提供了动态代理的语法（实际上，动态代理底层依赖的就是 Java 的发射语法）。我们来看一下，如何使用 Java 的动态代理来实现刚刚的功能。具体的代码如下所示。其中， MetricsCollectorProxy 作为一个动态代理类，动态地给每个需要收集接口请求的类创建代理类。

java 复制代码 
public class MetricsCollectorProxy {
    private MetricsCollector metricsCollector;

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

    public Object createProxy(Object proxiedObject) {
        Class<?>[] interfaces = proxiedObject.getClass().getInterfaces();
        DynamicProxyHandler handler = new DynamicProxyHandler(proxiedObject);
        return Proxy.newProxyInstance(proxiedObject.getClass().getClassLoader(), interfaces, handler);
    }

    private class  DynamicProxyHandler implements InvocationHandler {
        private Object proxiedObject;

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

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            long startTimestamp = System.currentTimeMillis();

            Object result = method.invoke(proxiedObject, args);

            long endTimestamp = System.currentTimeMillis();
            long responseTime = endTimestamp - startTimestamp;
            String apiName = proxiedObject.getClass().getName() + "." + method.getName();
            RequestInfo requestInfo = new RequestInfo(apiName, responseTime, startTimestamp);
            metricsCollector.recordRequest(requestInfo);

            return result;
        }
    }
}

// MetricsCollectorProxy使用举例
MetricsCollectorProxy proxy = new MetricsCollectorProxy();
IUserController userCpntroller = (IUserController) proxy.createProxy(new UserController());

实际上，Spring AOP 底层的实现原理就是基于动态代理。用户配置好需要给那些类创建代理，并定义好在执行原始类的业务代码前后执行哪些附加功能。Spring 为这些类创建动态代理对象，并在 JVM 中替代原始对象。原本在代码中执行的原始类的方法，被换作执行代理类的方法，也就实现了给原始类添加附加功能的目的。

代理模式的应用场景

代理模式的应用场景非常多，这里列举一些比较常见的用法，希望你能举一反三地应用在你的项目开发中。

1.业务系统的非功能性需求开发

代理模式最常用的一个应用场景就是，在业务系统开发一些非功能性需求，比如：监控、统计、鉴权、限流、事务、幂等、日志。我们将这些附加功能与业务功能解耦，放到代理类中统一处理，让程序员只需要关注业务方面的开发。实际上，前面举的搜集接口请求信息的例子，就是这个应用场景的一个典型例子。

如果你熟悉 Java 语言和 Spring 框架，这部分工作都是可以在 Spring AOP 切面中完成的。前面也提到过，Spring AOP 底层的实现原理就是基于动态代理。

2.代理模式在 RPC、缓存中应用

实际上，RPC 框架也可以看做一种代理模式。GoF 的《设计模式》中把它称作远程代理。通过远程代理，将网络通信、数据编解码等细节隐藏起来。客户端在使用 RPC 服务的时候，就像使用本地函数一样，无需了解跟服务器交互的细节。此外，RPC 服务的开发者也只需要开发业务逻辑，就像开发本地使用的函数一样，不需要关注跟客户端的交互细节。

关于远程代理的代码示例，我自己实现了一个简单的 RPC 框架 Demo。

首先是服务端代码

java 复制代码 
// 服务端的Rpc基础类
public class RpcServer {
    public void export(Object service, int port) throws Exception {
        if (service == null) {
            throw new IllegalArgumentException("service instance == null");
        }
        if (port <= 0 || port > 65535) {
            throw new IllegalArgumentException("invalid port: " + port);
        }
        ServerSocket server = new ServerSocket(port);
        while (true) {
            final Socket socket = server.accept();
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        ObjectInputStream input = new ObjectInputStream(socket.getInputStream());
                        ObjectOutputStream output = new ObjectOutputStream(socket.getOutputStream());
                        try {
                            String methodName = input.readUTF();
                            Class<?>[] parameterTypes = (Class<?>[]) input.readObject();
                            Object[] args = (Object[]) input.readObject();
                            Method method = service.getClass().getMethod(methodName, parameterTypes);
                            Object result = method.invoke(service, args);
                            output.writeObject(result);
                        } catch (Throwable t) {
                            output.writeObject(t);
                        } finally {
                            output.close();
                            input.close();
                            socket.close();
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}

// 业务的接口
public interface CalculatorService {
    int add(int a, int b);
}

// 业务的实现类
public class CalculatorServiceImpl implements CalculatorService {
    @Override
    public int add(int a, int b) {
        return a + b;
    }
}

// 业务端 RPC 服务Demo
public class RpcServerApplication {
    public static void main(String[] args) throws Exception {
        CalculatorService service = new CalculatorServiceImpl();
        RpcServer server = new RpcServer();
        server.export(service, 1234);
    }
}

接下来是客户端代码

java 复制代码 
// 客户端RPC应用的基础类
public class RpcClient {
    public <T> T refer(final Class<T> interfaceClass, final String host, final int port) {
        if (interfaceClass == null) {
            throw new IllegalArgumentException("interface class == null");
        }
        if (!interfaceClass.isInterface()) {
            throw new IllegalArgumentException("The " + interfaceClass.getName() + " must be interface class");
        }
        if (host == null || host.length() == 0) {
            throw new IllegalArgumentException("host == null");
        }
        if (port <= 0 || port > 65535) {
            throw new IllegalArgumentException("invalid port: " + port);
        }
        return (T) Proxy.newProxyInstance(interfaceClass.getClassLoader(), new Class[]{interfaceClass}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                Socket socket = new Socket(host, port);
                try {
                    ObjectOutputStream output = new ObjectOutputStream(socket.getOutputStream());
                    try {
                        output.writeUTF(method.getName());
                        output.writeObject(method.getParameterTypes());
                        output.writeObject(args);
                        ObjectInputStream input = new ObjectInputStream(socket.getInputStream());
                        try {
                            Object result = input.readObject();
                            if (result instanceof Throwable) {
                                throw (Throwable) result;
                            }
                            return result;
                        } finally {
                            input.close();
                        }
                    } finally {
                        output.close();
                    }
                } finally {
                    socket.close();
                }
            }
        });
    }
}

// 需要调用的接口（服务端）
public interface CalculatorService {
    int add(int a, int b);
}

// 客户端使用demo
public class ClientDemo {
    public static void main(String[] args) {
        RpcClient client = new RpcClient();
        CalculatorService service = client.refer(CalculatorService.class, "127.0.0.1", 1234);
        int result = service.add(2, 4);
        System.out.println("result: " + result);
    }
}

再来看代理模式在缓存中的应用。假设我们要开发一个接口请求的缓存功能，对于某些接口，如果入参相同，在设定的过期时间内，直接返回缓存结果，而不用重新进行逻辑处理。比如，针对获取用户个人信息的需求，我们可以开发两个接口，一个支持缓存，一个支持实时查询。对于需要实时数据的需求，我们让其调用实时查询接口，对于不需要实时数据的需求，我们让其调用支持缓存的接口。那如何实现接口请求的缓存功能呢？

最简单的实现方法就是，给每个需要支持缓存的查询需求都开发两个不同的接口，一个支持缓存，一个支持实时查询。但是，这样做显然增加了开发成本，而且会让代码看起来非常臃肿（接口个数成倍增加），也不方便缓存接口的集中管理（增加、删除缓存接口）、集中配置（比如配置每个接口缓存过期时间）。

针对这些问题，代理模式就派上用场了。如果是基于 Spring 框架来开发的话，那就可以在 AOP 切面中完成接口缓存的功能。在应用启动时，我们从配置文件中加载需要支持缓存的接口，以及相应的缓存策略（比如过期时间）等。当请求到来的时候，我们在 AOP 切面中拦截请求，如果请求中带有支持缓存的字段（比如 http://...?..&cache=true），我们便从缓存中获取数据直接返回。

总结

1.代理模式的原理与实现

在不改变原始类（或者叫被代理类）的情况下，通过引入代理类来给原始类附加功能。一般情况下，我们让代理类和原始类实现相同的接口。但是，如果原始类并没有定义接口，并且原始类代码并不是我们开发维护的。在这种情况下，我们可以通过让代理类继承原始类的方法来实现代理模式。

2.动态代理的原理与实现

静态代理需要针对每个类都创建一个代理类，并且每个代理类中的代码都有像模板式的 "重复" 代码，增加了维护成本和开发成本。对于静态代理存在的问题，我们可以通过动态代理来解决。我们不事先为每个原始类编写代理类，而是在运行时动态地创建代理类，然后再系统中用代理类代替原始类。

3.代理模式的应用场景

代理模式常用在业务系统中开发一些非功能性需求，比如：监控、统计、鉴权、限流、事务、幂等、日志。我们将这些附加功能与业务功能解耦，放到代理类中统一处理，让程序员只关注业务方面的开发。此外，代理模式还可以用在 RPC 、缓存等应用场景中。

相关推荐
WaaTong6 小时前
《重学Java设计模式》之 单例模式
java·单例模式·设计模式
WaaTong8 小时前
《重学Java设计模式》之 原型模式
java·设计模式·原型模式
霁月风8 小时前
设计模式——观察者模式
c++·观察者模式·设计模式
暗黑起源喵11 小时前
设计模式-工厂设计模式
java·开发语言·设计模式
wrx繁星点点19 小时前
状态模式（State Pattern）详解
java·开发语言·ui·设计模式·状态模式
金池尽干20 小时前
设计模式之——观察者模式
观察者模式·设计模式
也无晴也无风雨20 小时前
代码中的设计模式-策略模式
设计模式·bash·策略模式
肘击鸣的百k路1 天前
Java 代理模式详解
java·开发语言·代理模式
捕鲸叉1 天前
MVC（Model-View-Controller）模式概述
开发语言·c++·设计模式
wrx繁星点点1 天前
享元模式：高效管理共享对象的设计模式
java·开发语言·spring·设计模式·maven·intellij-idea·享元模式
热门推荐
01如何才能让手机厂商主动拥抱华为，接入鸿蒙系统？02【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【TC3xx芯片】TC3xx芯片电源管理系统PMS详解05基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测06【经验分享】Ubuntu22.04安装微信(linux官方版)07Macbook pro M1 安装Ubuntu教程08RAG 实践- Ollama+RagFlow 部署本地知识库09Windows10安装PCL1.14.0及点云配准10文件或文件夹名称中有空格如何批量去除