Java设计模式：静态代理、装饰者、动态代理详解

忘是亡心i 2023-07-25 14:18 14阅读 0赞

### 静态代理、装饰者、动态代理 ###

*   *  1. 静态代理设计模式
     *   *   *  1.1 静态代理 - 实现步骤
             *  1.2 静态代理 - 逻辑图 & 源码示例
             *  1.3 静态代理 - 优缺
     *  2. 装饰者设计模式 - 类似静态代理
     *   *   *  2.1 装饰者模式 - 实现步骤
             *  2.2 装饰者模式 - 逻辑图 & 源码示例
             *  2.3 装饰者模式 - 优缺
     *  3. 动态代理设计模式【最优】
     *   *   *  3.1 动态代理设计模式 - 实现步骤
             *  3.2 动态代理设计模式 - 逻辑图 & 源码示例
             *  3.3 动态代理设计模式 - 优缺

代理模式是Java常见的设计模式之一。  
代理模式是指不直接调用实际对象，而是通过调用代理，来间接的调用实际的对象。

> 为什么要采用这种间接的形式来调用对象呢？  
> 场景①：`不想直接访问`实际的对象；  
> 场景②：对实际的对象的`访问存在困难`；  
> 场景③：有需求需要将封装对象访问/操作的`成员方法进行逻辑增强，而不修改原方法`；  
> 在现实生活中，这种情形非常的常见，比如**请一个律师代理来打官司**。

代理模式可以有 2 种实现的方式：  
一种是`静态代理`，另一种是各大框架都喜欢的`动态代理`。  
还有一种类似静态代理的`装饰者模式`。

现有 User 实体类：

public class User { 
        private int id;  // 编号属性 id
        private String name;  // 姓名属性 name
        public User() {  }
        public User(int id, String name) { 
            this.id = id;
            this.name = name;
        }
        public int getId() {  return id; }
        public void setId(int id) {  this.id = id; }
        public String getName() {  return name; }
        public void setName(String name) {  this.name = name; }
        @Override
        public String toString() { 
        	return "User{" + "id=" + id + ", name='" + name + '\'' + '}'; 
        }
    }

`DAO封装数据访问思想：用来封装对实体类 User 类的访问/操作。`  
UserDao 接口：

public interface UserDao { 
        void add();
        void delete();
        void update();
        void select();
    }

UserDaoImpl 实现类：

public class UserDaoImpl implements UserDao { 
        @Override
        public void add() {  System.out.println("add"); }
        @Override
        public void delete() {  System.out.println("delete"); }
        @Override
        public void update() {  System.out.println("update"); }
        @Override
        public void select() {  System.out.println("select"); }
    }

需求：通过 静态代理、装饰者、动态代理模式分别 `增强 add() 方法的逻辑功能`。

## 1. 静态代理设计模式 ##

#### 1.1 静态代理 - 实现步骤 ####

① 自定义一个代理类（增强类）实现和被代理类（被增强类）相同的接口  
② 在代理类中声明被代理类的`对象`  
③ 在代理类的方法中使用被代理类调用方法

#### 1.2 静态代理 - 逻辑图 & 源码示例 ####

![Java静态代理设计模式][Java]  
代理类（该类 UserDaoProxy）、被代理类（UserDaoImpl）:

/** * 静态代理设计模式 */
    // 1.实现和被代理类相同的接口
    public class UserDaoProxy implements UserDao { 
        // 2.在代理类中声明被代理类的引用
        private UserDao userDao;
        public UserDaoProxy() { 
            userDao = new UserDaoImpl();
        }
        // 3.在代理类的方法中使用被代理类调用方法
        @Override
        public void add() { 
            System.out.println("权限校验");
            userDao.add();
            System.out.println("日志记录");
        }
        @Override
        public void delete() {  userDao.delete(); }
        @Override
        public void update() {  userDao.update(); }
        @Override
        public void select() {  userDao.select(); }
    }

测试静态代理类；

public class TestProxy { 
        public static void main(String[] args) { 
            // 测试静态代理模式
            UserDaoProxy userDaoProxy = new UserDaoProxy();
            userDaoProxy.add();
            userDaoProxy.delete();
    }

运行结果：  
![Java静态代理设计模式][Java 1]

#### 1.3 静态代理 - 优缺 ####

优点：不修改源码`增强`被代理类的功能，可以`控制`被代理类的对象  
缺点：`必须要重写被代理类接口的所有的方法，耦合性高`

## 2. 装饰者设计模式 - 类似静态代理 ##

#### 2.1 装饰者模式 - 实现步骤 ####

① 自定义一个装饰类（增强类）实现和被装饰类（被增强类）相同的接口  
② 在装饰类中声明被装饰类的`引用`  
③ 在装饰类的方法中使用被装饰类调用方法

#### 2.2 装饰者模式 - 逻辑图 & 源码示例 ####

![Java装饰者设计模式][Java 2]  
装饰类（该类 UserDaoWrapper）、被装饰类（UserDaoImpl）:

/** * 装饰设计模式 */
    // 1.实现和被装饰类相同的接口
    public class UserDaoWrapper implements UserDao { 
        // 2.在装饰类中声明被装饰类的引用
        private UserDao userDao;
        public UserDaoWrapper() {  }
        public UserDaoWrapper(UserDao userDao) { 
            this.userDao = userDao;
        }
        // 3.在装饰类的方法中使用被装饰类调用方法
        @Override
        public void add() { 
            System.out.println("权限校验");
            userDao.add();
            System.out.println("日志记录");
        }
        @Override
        public void delete() {  userDao.delete(); }
        @Override
        public void update() {  userDao.update(); }
        @Override
        public void select() {  userDao.select(); }
    }

测试装饰者类：

public class TestProxy { 
        public static void main(String[] args) { 
            // 测试装饰设计模式
            UserDaoWrapper userDaoWrapper = new UserDaoWrapper(new UserDaoImpl());
            userDaoWrapper.add();
            userDaoWrapper.delete();
    }

运行结果：  
![Java装饰者设计模式][Java 3]

#### 2.3 装饰者模式 - 优缺 ####

优点：不修改源码`增强`被代理类的功能，`无法控制`被代理类的对象  
缺点：`必须要重写被代理类接口的所有的方法，耦合性高`

## 3. 动态代理设计模式【最优】 ##

动态代理是通过反射来实现的，借助Java自带的 `java.lang.reflect.Proxy` 通过固定的规则生成。  
动态代理本质就是通过`反射`来生成的一个代理。  
在Java中 java.lang.reflect 包下提供了一个 `Proxy 类`和 `InvocationHandler 接口`，通过使用这个类和接口就可以生成动态代理对象，Proxy类中的方法创建动态代理对象。

> JDK提供的代理只能针对接口做代理，有更强大的代理`cglib`：  
> 一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展Java类与实现Java接口。

#### 3.1 动态代理设计模式 - 实现步骤 ####

步骤：——`基于接口的方法增强`  
① 编写一个代理类的接口  
② 实现一个真正的代理类，实现该接口  
③ 创建一个动态的代理类，实现 `InvocationHandler 接口`，并重写该 `invoke()` 方法  
④ 在测试类中调用 `Proxy.newProxyInstance()` 方法生成动态代理对象

> 优化：③④可合并为实现了对应接口`匿名内部类`替代。  
> 即 在调用该动态代理对象的成员方法时，是 invoke 增强的方法执行。

#### 3.2 动态代理设计模式 - 逻辑图 & 源码示例 ####

![Java动态代理设计模式][Java 4]  
Proxy.newProxyInstance() 方法的参数解释：

/* * 通过反射来实现的动态代理核心方法 * @loader: 被代理类对应的类加载器 * @interfaces: 被代理类所实现的所有接口 * @h: 一个用以增强代理类的处理器 * @return Object对象 */
        @CallerSensitive
        public static Object newProxyInstance(ClassLoader loader,
                                              Class<?>[] interfaces,
                                              InvocationHandler h);

InvocationHandler 接口的 invoke 方法参数解释：

/** * 在代理实例上处理方法调用，并返回结果 * @param proxy 代理类的实例 * @param method 被代理类的原方法 * @param args 被代理类的原方法的实际参数 * @return Object对象 */
        @Override
        public Object invoke(Object proxy, Method method, Object[] args);

匿名内部类直接测试：

public class TestProxy { 
        public static void main(String[] args) { 
            UserDao userDao = new UserDaoImpl();
            //动态代理设计模式：匿名内部类对象
            UserDao p = (UserDao) Proxy.newProxyInstance(
                    userDao.getClass().getClassLoader(),
                    userDao.getClass().getInterfaces(),
                    //Lambda表达式，等价于 new InvocationHandler(){ invoke(){...} }
                    (proxy, method, argss) -> { 
                        String methodName = method.getName();
                        Object result;
                        //方法名比较：只增强指定的需要增强的方法
                        if ("add".equals(methodName)) { 
                            System.out.println("权限校验");
                            result = method.invoke(userDao, argss);
                            System.out.println("日志记录");
                        } else { 
                            result = method.invoke(userDao, argss);
                        }
                        return result;
                    });
            p.add();
            p.delete();
    }

![Java动态代理设计模式][Java 5]

#### 3.3 动态代理设计模式 - 优缺 ####

优点：`不需要重写接口中的所有方法，耦合度更低`。  
缺点：没有，动态代理就是这么任性，这条gai最靓的仔本仔！

[Java]: /images/20230528/ff614f526fb84f8fb1f74de1e2c6e204.png
[Java 1]: /images/20230528/229b44a3a06c4cc78ffb69adcadeb88c.png
[Java 2]: /images/20230528/e74aef94b8424fd6bef3869be26695f5.png
[Java 3]: /images/20230528/d6acd42384fa4280a6f7c1717b17af33.png
[Java 4]: /images/20230528/3121cfe0792341399f648c806e41a8ad.png
[Java 5]: /images/20230528/afb8e048afe54359aa4edd5492f02a10.png