【设计模式自习室】详解代理模式

ゝ一纸荒年。 2023-07-01 13:59 36阅读 0赞

![format_png][]

## 前言 ##

《设计模式自习室》系列，顾名思义，本系列文章带你温习常见的设计模式。主要内容有：

*  该模式的**介绍**，包括：
    
     *  引子、意图（大白话解释）
     *  类图、时序图（理论规范）
 *  该模式的**代码示例**：熟悉该模式的代码长什么样子
 *  该模式的**优缺点**：模式不是万金油，不可以滥用模式
 *  该模式的**应用案例**：了解它在哪些重要的源码中被使用

该系列会逐步更新于我的博客和公众号（博客见文章底部），也希望各位观众老爷能够关注我的个人公众号：**后端技术漫谈**，不会错过精彩好看的文章。

### 系列文章回顾 ###

*  [【设计模式自习室】开篇：为什么我们要用设计模式？][Link 1]
 *  [【设计模式自习室】建造者模式][Link 2]
 *  [【设计模式自习室】原型模式][Link 3]
 *  [【设计模式自习室】透彻理解单例模式][Link 4]
 *  [【设计模式自习室】理解工厂模式的三种形式][Link 5]
 *  [【设计模式自习室】适配器模式][Link 6]
 *  [【设计模式自习室】装饰模式][Link 7]
 *  [【设计模式自习室】桥接模式 Bridge Pattern：处理多维度变化][Bridge Pattern]
 *  [【设计模式自习室】门面模式 Facade Pattern][Facade Pattern]
 *  [【设计模式自习室】享元模式 Flyweight Pattern：减少对象数量][Flyweight Pattern]

## 结构型——代理模式 Proxy Pattern ##

### 引子 ###

通俗的来讲，代理模式就是我们生活中常见的**中介**。在某些情况下，一个客户不想或者不能直接引用一个对象，此时可以通过一个称之为“代理”的第三者来实现间接引用。

#### 为什么要用代理模式 ####

*  **中介隔离作用**：在某些情况下，一个客户类**不想或者不能直接引用一个委托对象**，而代理类对象可以在客户类和委托对象之间起到中介的作用，**其特征是代理类和委托类实现相同的接口。**
 *  **开闭原则，增加功能**：**真正的业务功能还是由委托类来实现**，但是可以在业务功能执行的前后加入一些公共的服务。例如我们想**给项目加入缓存、日志**这些功能，我们就可以使用代理类来完成，而没必要打开已经封装好的委托类。

### 定义 ###

代理模式**给某一个对象提供一个代理对象**，**并由代理对象控制对原对象的引用。**

**常见的代理区分为静态代理和动态代理：**

#### 1. 静态代理 ####

在程序运行前就已经存在代理类的字节码文件，代理类和真实主题角色的关系在运行前就确定了。

是**由程序员创建或特定工具自动生成源代码**，在对其编译。在程序员运行之前，代理类.class文件就已经被创建了。

#### 2. 动态代理 ####

为什么类可以动态的生成？

这就涉及到Java虚拟机的**类加载机制**了

> Java虚拟机类加载过程主要分为五个阶段：加载、验证、准备、解析、初始化。其中加载阶段需要完成以下3件事情：
> 
> 1.  通过一个类的全限定名来获取定义此类的二进制字节流
> 2.  将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构
> 3.  在内存中生成一个代表这个类的 java.lang.Class 对象，作为方法区这个类的各种数据访问入口
> 
> 由于虚拟机规范对这3点要求并不具体，所以实际的实现是非常灵活的，关于第1点，获取类的二进制字节流（class字节码）就有很多途径：
> 
> 1.  从ZIP包获取，这是JAR、EAR、WAR等格式的基础
> 2.  从网络中获取，典型的应用是 Applet
> 3.  运行时计算生成，这种场景使用最多的是动态代理技术，在 java.lang.reflect.Proxy 类中，就是用了 ProxyGenerator.generateProxyClass 来为特定接口生成形式为 \*$Proxy 的代理类的二进制字节流
> 4.  由其它文件生成，典型应用是JSP，即由JSP文件生成对应的Class类
> 5.  从数据库中获取等等
> 
> 所以，动态代理就是想办法，根据接口或目标对象，计算出代理类的字节码，然后再加载到JVM中使用。

更多Java类加载机制可以查看：

[Java虚拟机知识点快速复习手册][Java]

**动态代理又有两种典型的实现方式：JDK动态代理和CGLib动态代理**

*  **通过实现接口的方式** \-> JDK动态代理
 *  **通过继承类的方式** \-> CGLIB动态代理

**2.1 JDK反射机制（接口代理）**

*  是在程序运行时通过**反射机制动态创建**的。
 *  **为需要拦截的接口生成代理对象以实现接口方法拦截功能。**

**2.2 CGLIB代理**

*  **其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑**。
 *  但因为采用的是继承，**所以不能对final修饰的类进行代理**。
 *  **JDK动态代理与CGLib动态代理均是实现Spring AOP的基础。**

### 类图 ###

如果看不懂UML类图，可以先粗略浏览下该图，想深入了解的话，可以继续谷歌，深入学习：

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PSWzmwWE-1579686913106)(https://user-gold-cdn.xitu.io/2020/1/22/16fccab428d8c0d6?w=709&h=347&f=png&s=100832)\]

代理模式包含如下角色：

*  Subject（抽象主题角色）：定义代理类和真实主题的公共对外方法，也是代理类代理真实主题的方法；
 *  RealSubject（真实主题角色）：真正实现业务逻辑的类；
 *  Proxy（代理主题角色）：用来代理和封装真实主题；

![format_png 1][]

### 时序图 ###

![format_png 2][]

### 代码实现和使用场景 ###

代理模式得到了非常广泛的应用，最常用的便是我们在Spring中使用的CGlib代理，所以我们将代码示例和使用场景再次融合在一起来讲解。

主要分为四个代码小Demo，分别是:

*  静态代理代码示例
 *  JDK动态代理代码示例
 *  CGLIB底层使用的ASM字节码插入技术代码示例
 *  CGLIB动态代理代码示例

#### 1. 静态代理示例代码 ####

编写一个接口 UserService ，以及该接口的一个实现类 UserServiceImpl

public interface UserService {
        public void select();   
        public void update();
    }
    
    public class UserServiceImpl implements UserService {  
        public void select() {  
            System.out.println("查询 selectById");
        }
        public void update() {
            System.out.println("更新 update");
        }
    }

我们将通过静态代理对 UserServiceImpl 进行功能增强，**在调用 select 和 update 之前记录一些日志（记录开始和结束的时间点）**。写一个代理类 UserServiceProxy，代理类需要实现 UserService

public class UserServiceProxy implements UserService {
        private UserService target; // 被代理的对象
    
        public UserServiceProxy(UserService target) {
            this.target = target;
        }
        public void select() {
            before();
            target.select();    // 这里才实际调用真实主题角色的方法
            after();
        }
        public void update() {
            before();
            target.update();    // 这里才实际调用真实主题角色的方法
            after();
        }
    
        private void before() {     // 在执行方法之前执行
            System.out.println(String.format("log start time [%s] ", new Date()));
        }
        private void after() {      // 在执行方法之后执行
            System.out.println(String.format("log end time [%s] ", new Date()));
        }
    }

客户端测试

public class Client1 {
        public static void main(String[] args) {
            UserService userServiceImpl = new UserServiceImpl();
            UserService proxy = new UserServiceProxy(userServiceImpl);
    
            proxy.select();
            proxy.update();
        }
    }

通过静态代理，我们达到了功能增强的目的，而且没有侵入原代码，这是静态代理的一个优点。

#### 2. JDK动态代理 ####

JDK动态代理主要涉及两个类：java.lang.reflect.Proxy 和 java.lang.reflect.InvocationHandler

编写一个调用逻辑处理器 LogHandler 类，提供日志增强功能，并实现 InvocationHandler 接口；在 LogHandler 中维护一个目标对象，这个对象是被代理的对象（真实主题角色）；在 invoke 方法中编写方法调用的逻辑处理

import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.util.Date;
    
    public class LogHandler implements InvocationHandler {
        Object target;  // 被代理的对象，实际的方法执行者
    
        public LogHandler(Object target) {
            this.target = target;
        }
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            before();
            Object result = method.invoke(target, args);  // 调用 target 的 method 方法
            after();
            return result;  // 返回方法的执行结果
        }
        // 调用invoke方法之前执行
        private void before() {
            System.out.println(String.format("log start time [%s] ", new Date()));
        }
        // 调用invoke方法之后执行
        private void after() {
            System.out.println(String.format("log end time [%s] ", new Date()));
        }
    }

编写客户端，获取动态生成的代理类的对象须借助 Proxy 类的 newProxyInstance 方法，具体步骤可见代码和注释

import proxy.UserService;
    import proxy.UserServiceImpl;
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Proxy;
    
    public class Client2 {
        public static void main(String[] args) throws IllegalAccessException, InstantiationException {
            // 设置变量可以保存动态代理类，默认名称以 $Proxy0 格式命名
            // System.getProperties().setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
            // 1. 创建被代理的对象，UserService接口的实现类
            UserServiceImpl userServiceImpl = new UserServiceImpl();
            // 2. 获取对应的 ClassLoader
            ClassLoader classLoader = userServiceImpl.getClass().getClassLoader();
            // 3. 获取所有接口的Class，这里的UserServiceImpl只实现了一个接口UserService，
            Class[] interfaces = userServiceImpl.getClass().getInterfaces();
            // 4. 创建一个将传给代理类的调用请求处理器，处理所有的代理对象上的方法调用
            //     这里创建的是一个自定义的日志处理器，须传入实际的执行对象 userServiceImpl
            InvocationHandler logHandler = new LogHandler(userServiceImpl);
            /*
               5.根据上面提供的信息，创建代理对象 在这个过程中，
                   a.JDK会通过根据传入的参数信息动态地在内存中创建和.class 文件等同的字节码
                   b.然后根据相应的字节码转换成对应的class，
                   c.然后调用newInstance()创建代理实例
             */
            UserService proxy = (UserService) Proxy.newProxyInstance(classLoader, interfaces, logHandler);
            // 调用代理的方法
            proxy.select();
            proxy.update();
    
            // 保存JDK动态代理生成的代理类，类名保存为 UserServiceProxy
            // ProxyUtils.generateClassFile(userServiceImpl.getClass(), "UserServiceProxy");
        }
    }

结果：

log start time [Thu Dec 20 16:55:19 CST 2018] 
    查询 selectById
    log end time [Thu Dec 20 16:55:19 CST 2018] 
    log start time [Thu Dec 20 16:55:19 CST 2018] 
    更新 update
    log end time [Thu Dec 20 16:55:19 CST 2018]

上方1和2中的示例代码来自，文中有详细的细节分析：

http://laijianfeng.org/2018/12/Java-%E5%8A%A8%E6%80%81%E4%BB%A3%E7%90%86%E8%AF%A6%E8%A7%A3/

#### 3. CGLib动态代理 ####

CGLIB代理则是通过继承的方式来生成代理类。

##### 字节码修改示例代码 #####

首先，我们先通过代码来了解一下字节码修改技术是如何实现的

我们使用ASM字节码操作类库（cglib底层使用的是ASM）来给出一段示例代码，小伙伴们也可以自己在本地运行试试。

> ASM 可以直接产生二进制 class 文件，它能被用来动态生成类或者增强既有类的功能。
> 
> ASM从类文件中读入信息后，能够改变类行为，分析类信息，甚至能够根据用户要求生成新类。
> 
> ASM相对于其他类似工具如BCEL、SERP、Javassist、CGLIB，它的最大的优势就在于其性能更高，其jar包仅30K。Hibernate和Spring都使用了cglib代理，而cglib底层使用的是ASM，可见ASM在各种开源框架都有广泛的应用。

Base类：被修改的类，该类实现了每3秒输出一个process，用来模拟正在处理的请求。

package asm;
    
    import java.lang.management.ManagementFactory;
    
    public class Base {
        public static void main(String[] args) {
            String name = ManagementFactory.getRuntimeMXBean().getName();
            String s = name.split("@")[0];
            //打印当前Pid
            System.out.println("pid:"+s);
            while (true) {
                try {
                    Thread.sleep(3000L);
                } catch (Exception e) {
                    break;
                }
                process();
            }
        }
    
        public static void process() {
            System.out.println("process");
        }
    }

执行字节码修改和转换的类：该类中，我们实现在被修改类前后都输出start和end语句的方法

public class TestTransformer implements ClassFileTransformer {
        @Override
        public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
            System.out.println("Transforming " + className);
            try {
                ClassPool cp = ClassPool.getDefault();
                CtClass cc = cp.get("asm.Base");
                CtMethod m = cc.getDeclaredMethod("process");
                m.insertBefore("{ System.out.println(\"start\"); }");
                m.insertAfter("{ System.out.println(\"end\"); }");
                return cc.toBytecode();
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    }

接着我们生成字节码修改的Jar包

public class TestAgent {
        public static void agentmain(String args, Instrumentation inst) {
            inst.addTransformer(new TestTransformer(), true);
            try {
                inst.retransformClasses(TransformTarget.class);
                System.out.println("Agent Load Done.");
            } catch (Exception e) {
                System.out.println("agent load failed!");
            }
        }
    }

我们将生成的agent.jar通过JVM Tool写入正在执行的Base进程中。可以看出，本来只是3秒输出procss的类变成了从前后输出start和end的类，类被成功修改了。

![format_png 3][]

上面字节码修改的Demo代码我放在了自己的Github仓库中：

https://github.com/qqxx6661/Java\_Practise/tree/master/ASMDemo

##### CGLib动态代理代码示例 #####

maven引入CGLIB包，然后编写一个UserDao类，它没有接口，只有两个方法，select() 和 update()

public class UserDao {
        public void select() {
            System.out.println("UserDao 查询 selectById");
        }
        public void update() {
            System.out.println("UserDao 更新 update");
        }
    }

编写一个 LogInterceptor ，继承了 MethodInterceptor，用于方法的拦截回调

import java.lang.reflect.Method;
    import java.util.Date;
    
    public class LogInterceptor implements MethodInterceptor {
        /**
         * @param object 表示要进行增强的对象
         * @param method 表示拦截的方法
         * @param objects 数组表示参数列表，基本数据类型需要传入其包装类型，如int-->Integer、long-Long、double-->Double
         * @param methodProxy 表示对方法的代理，invokeSuper方法表示对被代理对象方法的调用
         * @return 执行结果
         * @throws Throwable
         */
        @Override
        public Object intercept(Object object, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
            before();
            Object result = methodProxy.invokeSuper(object, objects);   // 注意这里是调用 invokeSuper 而不是 invoke，否则死循环，methodProxy.invokesuper执行的是原始类的方法，method.invoke执行的是子类的方法
            after();
            return result;
        }
        private void before() {
            System.out.println(String.format("log start time [%s] ", new Date()));
        }
        private void after() {
            System.out.println(String.format("log end time [%s] ", new Date()));
        }
    }

测试类

import net.sf.cglib.proxy.Enhancer;
    
    public class CglibTest {
        public static void main(String[] args) {
            DaoProxy daoProxy = new DaoProxy(); 
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(Dao.class);  // 设置超类，cglib是通过继承来实现的
            enhancer.setCallback(daoProxy);
    
            Dao dao = (Dao)enhancer.create();   // 创建代理类
            dao.update();
            dao.select();
        }
    }

运行结果和上面相同。

### 优缺点 ###

#### 静态代理优缺点 ####

*  优点：可以做到**在符合开闭原则的情况下**对目标对象进行功能扩展。
 *  缺点：当需要代理多个类的时候，由于代理对象要实现与目标对象一致的接口，有两种方式：
    
     *  只维护一个代理类，由这个代理类实现多个接口，但是这样就**导致代理类过于庞大**
     *  新建多个代理类，每个目标对象对应一个代理类，但是这样会**产生过多的代理类**

#### JDK动态代理优缺点 ####

*  优势：虽然相对于静态代理，动态代理大大减少了我们的开发任务，同时减少了对业务接口的依赖，降低了耦合度。
 *  劣势：**只能对接口进行代理**

#### CGLIB动态代理优缺点 ####

**CGLIB创建的动态代理对象比JDK创建的动态代理对象的性能更高**，但是**CGLIB创建代理对象时所花费的时间却比JDK多得多**。

*  所以**对于单例的对象，因为无需频繁创建对象，用CGLIB合适**，反之使用JDK方式要更为合适一些。
 *  同时由于CGLib由于是采用动态创建子类的方法，对于final修饰的方法无法进行代理。

## 参考 ##

*  https://www.cnblogs.com/daniels/p/8242592.html
 *  http://laijianfeng.org/2018/12/Java-%E5%8A%A8%E6%80%81%E4%BB%A3%E7%90%86%E8%AF%A6%E8%A7%A3/
 *  https://www.cnblogs.com/jie-y/p/10732347.html

### 补充 ###

#### 装饰模式与代理模式的区别 ####

**装饰器模式关注于在一个对象上动态的添加方法，然而代理模式关注于控制对对象的访问。**

*  使用代理模式的时候，**我们常常在一个代理类中创建一个对象的实例**。
 *  当我们使用装饰器模式的时候，我们通常的做法是**将原始对象作为一个参数传给装饰者的构造器**。

# 关注我 #

我是一名后端开发工程师。

主要关注后端开发，数据安全，爬虫，物联网，边缘计算等方向，欢迎交流。

### 各大平台都可以找到我 ###

*  **微信公众号：后端技术漫谈**
 *  Github：[@qqxx6661][qqxx6661]
 *  CSDN：[@后端技术漫谈][Link 8]
 *  知乎：[@后端技术漫谈][Link 9]
 *  简书：[@后端技术漫谈][Link 10]
 *  掘金：[@后端技术漫谈][Link 11]

### 原创博客主要内容 ###

*  Java面试知识点复习全手册
 *  设计模式/数据结构 自习室
 *  Leetcode/剑指offer 算法题解析
 *  SpringBoot/SpringCloud菜鸟入门实战系列
 *  爬虫相关技术文章
 *  后端开发相关技术文章
 *  逸闻趣事/好书分享/个人兴趣

### 个人公众号：后端技术漫谈 ###

![公众号：后端技术漫谈.jpg][.jpg]

**如果文章对你有帮助，不妨收藏，投币，转发，在看起来~**

[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91c2VyLWdvbGQtY2RuLnhpdHUuaW8vMjAyMC8xLzIyLzE2ZmNjYTg2ZGQ4MGE4NzM?x-oss-process=image/format,png
[Link 1]: https://blog.csdn.net/qqxx6661/article/details/103655091
[Link 2]: https://blog.csdn.net/qqxx6661/article/details/103687437
[Link 3]: https://blog.csdn.net/qqxx6661/article/details/103703300
[Link 4]: https://blog.csdn.net/qqxx6661/article/details/103734115
[Link 5]: https://blog.csdn.net/qqxx6661/article/details/103812506
[Link 6]: https://blog.csdn.net/qqxx6661/article/details/103839005
[Link 7]: https://blog.csdn.net/qqxx6661/article/details/103847437
[Bridge Pattern]: https://blog.csdn.net/qqxx6661/article/details/104010114
[Facade Pattern]: https://blog.csdn.net/qqxx6661/article/details/104029094
[Flyweight Pattern]: https://blog.csdn.net/qqxx6661/article/details/104045326
[Java]: https://blog.csdn.net/qqxx6661/article/details/86774725
[format_png 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91c2VyLWdvbGQtY2RuLnhpdHUuaW8vMjAyMC8xLzIyLzE2ZmNjYWE3YmI4OGEyZWE?x-oss-process=image/format,png
[format_png 2]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91c2VyLWdvbGQtY2RuLnhpdHUuaW8vMjAyMC8xLzIyLzE2ZmNjYWI2YWJkMTUzZWM?x-oss-process=image/format,png
[format_png 3]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91c2VyLWdvbGQtY2RuLnhpdHUuaW8vMjAyMC8xLzIyLzE2ZmNjYWJkNTQxOGQyNDg?x-oss-process=image/format,png
[qqxx6661]: https://github.com/qqxx6661
[Link 8]: http://blog.csdn.net/qqxx6661
[Link 9]: https://www.zhihu.com/people/yang-zhen-dong-1/
[Link 10]: https://www.jianshu.com/u/b5f225ca2376
[Link 11]: https://juejin.im/user/5b48015ce51d45191462ba55
[.jpg]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91c2VyLWdvbGQtY2RuLnhpdHUuaW8vMjAyMC8xLzIyLzE2ZmNjYTg1ZTM4ZTI0NzY?x-oss-process=image/format,png