软件设计模式 | 动态代理模式

水深无声 2023-10-11 21:30 56阅读 0赞

#### 文章目录 ####

*  一、动态代理概述
 *   *  1.1 代理的概述和作用
     *  1.2 动态代理的优点
     *  1.3 代理对象的创建
     *  1.4 代理对象调用方法的执行流程
 *  二、动态代理举例
 *   *  2.1 歌手经纪人
     *  2.2 业务功能的性能统计
     *  2.3 动态代理在 Spring 框架中的应用
 *  三、基于子类的动态代理

--------------------

## 一、动态代理概述 ##

### 1.1 代理的概述和作用 ###

*  **什么是代理？**  
    代理指某些场景下对象会找一个代理对象，来辅助自己完成一些工作。如：歌星(经济人)，买房的人(房产中介)
 *  **代理主要干什么工作，是如何工作的？**  
    是对对象的行为做一些辅助的操作。
 *  **代理举例：**  
    歌手刚出道时，有人花钱让他唱歌，承诺先付首款再付尾款。那么，歌手的整个工作的流程是：收首款、唱歌、收尾款。  
    歌手成名以后，业务越来越多，开始雇佣了经纪人。经纪人主要负责：收首款、收尾款以及调用歌手去唱歌，歌手只负责唱歌。  
    ![在这里插入图片描述][9483d3adfd4d4bd8957b88e2c8d8a346.png_pic_left]

--------------------

### 1.2 动态代理的优点 ###

*  非常的灵活，支持任意接口类型的实现类对象做代理，也可以直接为接本身做代理。
 *  可以为被代理对象的所有方法做代理。
 *  不仅简化了编程工作、提高了软件系统的可扩展性，同时也提高了开发效率。
 *  可以在不改变方法源码的情况下，实现对方法功能的增强。  
    方法增强的理解：歌手原本的工作是唱歌，唱歌前后的收首款和尾款方法就相当于对原本的方法的增强。

--------------------

### 1.3 代理对象的创建 ###

*  java 中代理的代表类是： `java.lang.reflect.Proxy`
 *  `Proxy` 提供了一个静态方法，用于为对象产生一个代理对象返回。  
      
    ![在这里插入图片描述][e6775672c5bf481b86e12680573f0efb.png]  
    参数二理解：因为客户是通过代理对象去调用歌手的唱歌方法，因此代理类需要接口的列表。

--------------------

### 1.4 代理对象调用方法的执行流程 ###

1.  先走向代理
2.  代理可以为方法额外做一些辅助工作
3.  开发真正触发对象的方法的执行
4.  回到代理中，由代理负责返回结果给方法的调用者

--------------------

## 二、动态代理举例 ##

### 2.1 歌手经纪人 ###

**项目包结构：**

![在这里插入图片描述][75d3766f6794444b9471cc1dda4da085.png]

**技能接口：**

public interface Skill {
        
        void jump();
        void sing();
    }

**明星类：**

public class Star implements Skill{
        
        private String name;
        public Star(String name) {
        
            this.name = name;
        }
    
        @Override
        public void jump() {
        
            System.out.println(name + "开始跳舞");
        }
    
        @Override
        public void sing() {
        
            System.out.println(name + "开始唱歌");
        }
    }

**明星代理类：**

public class StarAgentProxy {
        
        /**
         * 设计一个方法来返回 一个明星对象 的 代理对象
         *      参数一：定义代理类的类加载器
         *      参数二：代理类要实现的接口列表
         *      参数三：将方法调用分派到的处理程序
         */
        public static Skill getProxy(Star obj){
        
            // 为张三这个对象，生成代理对象
            return (Skill) Proxy.newProxyInstance(obj.getClass().getClassLoader(),
                    obj.getClass().getInterfaces(), new InvocationHandler() {
        
                        @Override
                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
                            System.out.println("收首款");
                            // proxy 代理对象的引用
                            // method 正在调用的方法对象
                            // args 代表这个方法的参数
                            Object rs = method.invoke(obj, args); // 采用反射机制，如果没有返回值，则返回null
                            System.out.println("收尾款");
                            return rs;
                        }
                    });
        }
    }

**客户端模拟：**

public class Test {
        
        /**
         * 理解动态代理
         */
        public static void main(String[] args) {
        
            // 1. 创建一个对象
            Star star = new Star("张三");
            // 为张三对象，生成一个代理对象（经纪人）
            Skill proxy = StarAgentProxy.getProxy(star);
            proxy.jump();
            System.out.println("--------");
            proxy.sing();
        }
    }

**输出结果：**

![在这里插入图片描述][3853dfe83037455bba4284f4b0c2dcf8.png_pic_left]

--------------------

### 2.2 业务功能的性能统计 ###

**需求：** 模拟某企业用户管理业务，需包含用户登录、删除、查询功能，并要统计每个功能的耗时

**项目包结构：**

![在这里插入图片描述][606525fdf1d8437eaca87f6e46c02a82.png]

**用户业务层接口：**

public interface UserService {
        
        String login(String loginName, String password);
        void delete(Integer id);
        void selectUsers();
    }

**用户业务层实现类：**

public class UserServiceImpl implements UserService{
        
        @Override
        public String login(String loginName, String password) {
        
            String rs = "登录名称或者密码错误！";
            if("admin".equals(loginName) && "123456".equals(password)){
        
                rs = "登录成功";
            }
            try {
        
                Thread.sleep(1000);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            return rs;
        }
    
        @Override
        public void delete(Integer id) {
        
            try {
        
                System.out.println("正在删除数据中");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
        }
    
        @Override
        public void selectUsers() {
        
            System.out.println("查询了100个用户数据！");
            try {
        
                Thread.sleep(3000);
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    }

**代理对象工具类：**

public class ProxyUtil {
        
        /**
         * 通过静态方法为用户业务对象返回代理对象
         */
        public static UserService getProxy(UserService obj){
        
            return (UserService) Proxy.newProxyInstance(obj.getClass().getClassLoader(),
                    obj.getClass().getInterfaces(), new InvocationHandler() {
        
                        @Override
                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
                            long startTime = System.currentTimeMillis();
    
                            // 真正触发对象的行为执行
                            Object rs = method.invoke(obj, args);
    
                            long endTime = System.currentTimeMillis();
                            System.out.println(method.getName() + "方法耗时：" + (endTime-startTime)/1000.0 + "s");
                            return rs;
                        }
                    });
        }
    }

**客户端模拟：**

public class Test {
        
        public static void main(String[] args) {
        
            UserService proxy = ProxyUtil.getProxy(new UserServiceImpl());
            proxy.login("admin", "123456");
            proxy.delete(1);
            proxy.selectUsers();
        }
    }

**输出结果：**

![在这里插入图片描述][4da9bfefa55f4dcbbf55a883b1ef4ae4.png_pic_left]

--------------------

### 2.3 动态代理在 Spring 框架中的应用 ###

转账方法的事务问题回顾:

参考：[Spring 从入门到精通系列 09 —— 转账方法的事务问题与动态代理][Spring _ 09 _]

转账业务流程中，如果中间的某一部分业务出现异常，那么会导致异常后的事务不会执行，从而引发账户出错的严重情况。

![在这里插入图片描述][d6be79d139b549a39f61e281f5d0332d.png_pic_left]  
问题的关键在于：  
整个业务方法一共获取了四次数据库连接对象，有四个业务需要处理。当前事务完成后，会直接提交事务。那么当某个事务出现异常时，只对他自己的事务进行回滚，对其他的事务不回滚。

当时提出的解决方案是：  
由于整体的业务属于一个线程，那么通过使用 ThreadLocal 对象把 Connection 连接对象和当前线程绑定，即使一个线程中只有一个 Connection 对象，而不是原本的四个。（要么都发生，要么都不发生）

更新事务控制后，具体实现如下：

![在这里插入图片描述][4a3fdffe886c43e0a650f515f598f39c.png_pic_left]  
代码变的很复杂，而且每个方法都需要加上：开启事务、提交事务…等事务处理。因此，可利用动态代理的技术进行处理。  
Spring 的 AOP 的实现思想就是动态代理，即 在不修改源码的基础上对已有方法进行增强。

--------------------

## 三、基于子类的动态代理 ##

上文讲述的代理模式属于 **基于接口的动态代理模式**，当其不实现任何接口时，该动态代理对象不能得到。  
但是 **基于子类的动态代理** 可以实现不用实现接口的情况下实现代理。

**导入依赖：**

<dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib</artifactId>
        <version>2.1_3</version>
    </dependency>

**明星类：**

public class Star{
        
        private String name;
    
        public Star() {
        
        }
    
        public Star(String name) {
        
            this.name = name;
        }
    
        public void jump() {
        
            System.out.println(name + "开始跳舞");
        }
    
        public void sing() {
        
            System.out.println(name + "开始唱歌");
        }
    }

**明星代理类：**

public class ProxyUtil {
        
        /**
         * 通过静态方法为用户业务对象返回代理对象
         */
        public static Star getProxy(Star obj){
        
            return (Star) Enhancer.create(obj.getClass(), new MethodInterceptor() {
        
                /**
                 * 执行被代理对象的任何方法都会经过该方法
                 * @param proxy
                 * @param method
                 * @param args
                 *    以上三个参数和基于接口的动态代理中invoke方法的参数是一样的
                 * @param methodProxy ：当前执行方法的代理对象
                 */
                @Override
                public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        
                    System.out.println("收首款");
                    Object rs = method.invoke(obj, args);
                    System.out.println("收尾款");
                    return rs;
                }
            });
        }
    }

**客户端模拟：**

public class Test {
        
        public static void main(String[] args) {
        
            final Star star = new Star("张三");
            Star proxy = ProxyUtil.getProxy(star);
            proxy.jump();
            System.out.println("--------");
            proxy.sing();
        }
    }

**输出结果：**

![在这里插入图片描述][3853dfe83037455bba4284f4b0c2dcf8.png_pic_left]

注：基于子类的动态代理，被代理类必须实现无参构造（当被代理类中有参构造函数时，需重写无参构造），否则报以下异常。

![在这里插入图片描述][b1c5792f597d4b999c8958053f40ada9.png]

[9483d3adfd4d4bd8957b88e2c8d8a346.png_pic_left]: https://img-blog.csdnimg.cn/9483d3adfd4d4bd8957b88e2c8d8a346.png#pic_left
[e6775672c5bf481b86e12680573f0efb.png]: https://img-blog.csdnimg.cn/e6775672c5bf481b86e12680573f0efb.png
[75d3766f6794444b9471cc1dda4da085.png]: https://img-blog.csdnimg.cn/75d3766f6794444b9471cc1dda4da085.png
[3853dfe83037455bba4284f4b0c2dcf8.png_pic_left]: https://img-blog.csdnimg.cn/3853dfe83037455bba4284f4b0c2dcf8.png#pic_left
[606525fdf1d8437eaca87f6e46c02a82.png]: https://img-blog.csdnimg.cn/606525fdf1d8437eaca87f6e46c02a82.png
[4da9bfefa55f4dcbbf55a883b1ef4ae4.png_pic_left]: https://img-blog.csdnimg.cn/4da9bfefa55f4dcbbf55a883b1ef4ae4.png?#pic_left
[Spring _ 09 _]: https://blog.csdn.net/weixin_43819566/article/details/117459286
[d6be79d139b549a39f61e281f5d0332d.png_pic_left]: https://img-blog.csdnimg.cn/d6be79d139b549a39f61e281f5d0332d.png?#pic_left
[4a3fdffe886c43e0a650f515f598f39c.png_pic_left]: https://img-blog.csdnimg.cn/4a3fdffe886c43e0a650f515f598f39c.png#pic_left
[b1c5792f597d4b999c8958053f40ada9.png]: https://img-blog.csdnimg.cn/b1c5792f597d4b999c8958053f40ada9.png