极客时间《设计模式之美》笔记---代理、适配器、桥接与装饰器模式

柔情只为你懂 2022-09-03 12:17 63阅读 0赞

### 文章目录 ###

*  设计模式综述
 *  代理模式（Proxy Design Pattern）
 *   *   *  接口代理
         *  继承代理
         *  动态代理
         *  适用场景
 *  桥接模式
 *   *   *   *  适用场景
 *  适配器模式
 *   *   *  适用场景
         *   *  1. 封装有缺陷的接口设计
             *  2. 统一多个类的接口设计
             *  3. 替换依赖的外部系统
             *  4.兼容老版本接口
             *  5.适配不同格式的数据
 *  装饰器模式
 *  四种模式的比较
 *  参考阅读：

# 设计模式综述 #

大致上存在 `23` 种经典的设计模式。它们又可以分为三大类：创建型、结构型、行为型。对于常用的设计模式，我们要花多点时间理解掌握。对于不常用的设计模式，我们只需要稍微了解即可。  
按照类型和是否常用，设计模式进行了简单的分类，具体如下所示。

1.  创建型（创建型模式提供了创建对象的机制， 能够提升已有代码的灵活性和可复用性）  
    常用的有：**单例模式、工厂模式（工厂方法和抽象工厂）、建造者模式**  
    不常用的有：原型模式。
2.  结构型（结构型模式介绍如何将对象和类组装成较大的结构， 并同时保持结构的灵活和高效）  
    常用的有：**代理模式、桥接模式、装饰者模式、适配器模式**  
    不常用的有：门面模式、组合模式、享元模式，
3.  行为型（行为模式负责对象间的高效沟通和职责委派）  
    常用的有：**观察者模式、模板模式、策略模式、职责链模式、迭代器模式、[状态模式][Link 1]**  
    不常用的有：访问者模式、备忘录模式、命令模式、解释器模式、中介模式。

# 代理模式（Proxy Design Pattern） #

> 不改变原始类（或叫被代理类）代码的情况下，通过引入代理类来给原始类附加功能  
> 就拿下面这些代码来举例，

public class UserController { 
      //...省略其他属性和方法...
      private MetricsCollector metricsCollector; // 依赖注入
    
      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数据...
      }
    
      public UserVo register(String telephone, String password) { 
        long startTimestamp = System.currentTimeMillis();
    
        // ... 省略register逻辑...
    
        long endTimeStamp = System.currentTimeMillis();
        long responseTime = endTimeStamp - startTimestamp;
        RequestInfo requestInfo = new RequestInfo("register", responseTime, startTimestamp);
        metricsCollector.recordRequest(requestInfo);
    
        //...返回UserVo数据...
      }
    }

这段代码的问题主要出在哪里呐？主要在与：**性能统计 和 请求统计 与业务代码完全耦合**。这样就会导致我们该处理业务的类职责不单一，业务开发者除了关心业务代码还要关心 其他代码，带来负担！

// 我们会如何使用它：
    UserController userController =  new UserController();
    userController.login();

### 接口代理 ###

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

public interface IUserController { 
      UserVo login(String telephone, String password);
      UserVo register(String telephone, String password);
    }
    
    public class UserController implements IUserController { 
      //...省略其他属性和方法...
    
      @Override
      public UserVo login(String telephone, String password) { 
        //...省略login逻辑...
        //...返回UserVo数据...
      }
    
      @Override
      public UserVo register(String telephone, String password) { 
        //...省略register逻辑...
        //...返回UserVo数据...
      }
    }
    
    public class UserControllerProxy implements IUserController { 
      private MetricsCollector metricsCollector;
      private UserController userController;
    
      public UserControllerProxy(UserController userController) { 
        this.userController = userController;
        this.metricsCollector = new MetricsCollector();
      }
    
      @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(String telephone, String password) { 
        long startTimestamp = System.currentTimeMillis();
    
        UserVo userVo = userController.register(telephone, password);
    
        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());
    userController.login();
    */

这里我们再把未使用代理模式的形式粘出来做个对比：

UserController userController =  new UserController();
    userController.login();

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

### 继承代理 ###

对于这种外部类的扩展，就采用继承的方式即可。**让代理类继承原始类，然后扩展附加功能**。具体代码如下所示：

public class UserControllerProxy extends UserController { 
        private MetricsCollector metricsCollector;
    
        public UserControllerProxy() { 
            this.metricsCollector = new 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(String telephone, String password) { 
            long startTimestamp = System.currentTimeMillis();
    		// 父类执行逻辑 即可
            UserVo userVo = super.register(telephone, password);
    
            long endTimeStamp = System.currentTimeMillis();
            long responseTime = endTimeStamp - startTimestamp;
            RequestInfo requestInfo = new RequestInfo("register", responseTime, startTimestamp);
            metricsCollector.recordRequest(requestInfo);
    
            return userVo;
        }
    }
        // UserControllerProxy使用举例
        UserController userController = new UserControllerProxy();

### 动态代理 ###

不过，不管怎么做，我们都会随之而来两个问题，那就是 **（1）我们需要在代理类中，将原始类中的所有的方法，都重新实现一遍，并且为每个方法都附加相似的代码逻辑（看endTimeStamp - startTimestamp）**。另外，**（2）如果要添加的附加功能的类有不止一个，我们需要针对每个类都创建一个代理类**。

这里就可以使用动态代理来解决这个问题。所谓动态代理（Dynamic Proxy），就是我们不事先为每个原始类编写代理类，而是在运行的时候，动态地创建原始类对应的代理类，然后在系统中用代理类替换掉原始类。那如何实现动态代理呢？Java 中的就是：**反射**，具体的代码如下所示：

public class MetricsCollectorProxy { 
        private MetricsCollector metricsCollector;
    
        public MetricsCollectorProxy() { 
            this.metricsCollector = new 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 userController = (IUserController) proxy.createProxy(new UserController()); */

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

### 适用场景 ###

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

# 桥接模式 #

解释：**将抽象和实现解耦，让它们可以独立变化**！它是23种设计模式中最难理解的模式之一。这里直接**拿JDBC驱动的例子来解释一下。JDBC驱动是桥接模式的经典应用**。  
利用JDBC驱动来查询数据库：

Class.forName("com.mysql.jdbc.Driver");//加载及注册JDBC驱动程序
    String url = "jdbc:mysql://localhost:3306/sample_db?user=root&password=your_password";
    Connection con = DriverManager.getConnection(url);
    Statement stmt = con.createStatement()；
    String query = "select * from test";
    ResultSet rs=stmt.executeQuery(query);
    while(rs.next()) { 
      rs.getString(1);
      rs.getInt(2);
    }

如果我们想要把 MySQL 数据库换成 Oracle 数据库，只需要第一行代码中的 com.mysql.jdbc.Driver 换成oracle.jdbc.driver.OracleDriver 就可以了（或者直接从配置中心读取得了~）  
`com.mysql.jdbc.Driver`如下：

package com.mysql.jdbc;
    
    import java.sql.DriverManager;
    import java.sql.SQLException;
    
    													// 实现了 java.sql.Driver 接口
    public class Driver extends NonRegisteringDriver implements java.sql.Driver { 
        public Driver() throws SQLException { 
        }
    
        static { 
            try { 
            // 将MySQL Driver注册到DriverManager类中
                DriverManager.registerDriver(new Driver());
            } catch (SQLException var1) { 
                throw new RuntimeException("Can't register driver!");
            }
        }
    }

再来看 `DriverManager`:

package bridge;
    
    import jdk.internal.reflect.CallerSensitive;
    import jdk.internal.reflect.Reflection;
    
    import java.sql.Connection;
    import java.sql.Driver;
    import java.sql.DriverAction;
    import java.sql.DriverInfo;
    import java.sql.SQLException;
    import java.util.Collections;
    import java.util.Enumeration;
    import java.util.concurrent.CopyOnWriteArrayList;
    import java.util.stream.Stream;
    
    public class Example { 
        // List of registered JDBC drivers
        private final static CopyOnWriteArrayList<DriverInfo> registeredDrivers = new CopyOnWriteArrayList<>();
        // Used in ensureDriversInitialized() to synchronize driversInitialized
        private final static Object lockForInitDrivers = new Object();
        private static volatile boolean driversInitialized;
    
        @CallerSensitive
        public static Connection getConnection(String url) throws SQLException { 
            java.util.Properties info = new java.util.Properties();
            return (getConnection(url, info, Reflection.getCallerClass()));
        }
    
        public static void registerDriver(java.sql.Driver driver, DriverAction da) throws SQLException { 
            /* Register the driver if it has not already been added to our list */
            if (driver != null) { 
                registeredDrivers.addIfAbsent(new DriverInfo(driver, da));
            } else { 
                // This is for compatibility with the original DriverManager
                throw new NullPointerException();
            }
            println("registerDriver: " + driver);
        }
    
        /** * Retrieves an Enumeration with all of the currently loaded JDBC drivers * to which the current caller has access. * * <P><B>Note:</B> The classname of a driver can be found using * <CODE>d.getClass().getName()</CODE> * * @return the list of JDBC Drivers loaded by the caller's class loader * @see #drivers() */
        @CallerSensitive
        public static Enumeration<Driver> getDrivers() { 
            ensureDriversInitialized();
    
            return Collections.enumeration(getDrivers(Reflection.getCallerClass()));
        }
    
        // Worker method called by the public getConnection() methods.
        private static Connection getConnection(String url, java.util.Properties info, Class<?> caller) throws SQLException { 
            // Walk through the loaded registeredDrivers attempting to make a connection.
            // Remember the first exception that gets raised so we can reraise it.
            SQLException reason = null;
            for (DriverInfo aDriver : registeredDrivers) { 
                try { 
                    println(" trying " + aDriver.driver.getClass().getName());
                    Connection con = aDriver.driver.connect(url, info);
                    if (con != null) { 
                        // Success!
                        println("getConnection returning " + aDriver.driver.getClass().getName());
                        return (con);
                    }
                } catch (SQLException ex) { 
                    if (reason == null) { 
                        reason = ex;
                    }
                }
            }
    
            // if we got here nobody could connect.
            if (reason != null) { 
                println("getConnection failed: " + reason);
                throw reason;
            }
            println("getConnection: no suitable driver found for " + url);
            throw new SQLException("No suitable driver found for " + url, "08001");
        }
    
        /** * Retrieves a Stream with all of the currently loaded JDBC drivers * to which the current caller has access. * * @return the stream of JDBC Drivers loaded by the caller's class loader * @since 9 */
        @CallerSensitive
        public static Stream<Driver> drivers() { 
            ensureDriversInitialized();
            return getDrivers(Reflection.getCallerClass()).stream();
        }
    }

**当我们把具体的 Driver实现类（比如，com.mysql.jdbc.Driver）注册到 `DriverManager`之后，后续所有对JDBC接口的调用，都会委派到对具体的Driver实现类来执行**。而Driver实现类都实现了相同的接口（java.sql.Driver ），这也是可以灵活切换Driver的原因。

那么在这个例子中：什么是抽象？什么是实现呐？

实际上，JDBC本身就相当于“抽象”。注意，这里所说的“抽象”，指的并非“抽象类”或“接口”，而是跟具体的数据库无关的、被抽象出来的一套“类库”。具体的Driver（比如，com.mysql.jdbc.Driver）就相当于“实现”。注意，这里所说的“实现”，也并非指“接口的实现类”，而是跟具体数据库相关的一套“类库”。JDBC和Driver独立开发，通过对象之间的组合关系，组装在一起。JDBC的所有逻辑操作，最终都委托给 Driver 来执行。如图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXNoZW5neGlfcm9vdA_size_16_color_FFFFFF_t_70]

#### 适用场景 ####

桥接模式通常适用于以下场景。

1.  当一个类存在两个独立变化的维度，且这两个维度都需要进行扩展时。
2.  当一个系统不希望使用继承或因为多层次继承导致系统类的个数急剧增加时。（替换继承的场景）
3.  当一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性时。

# 适配器模式 #

适配器模式的英文翻译是Adapter Design Pattern。顾名思义，这个模式就是用来做适配的，它将不兼容的接口转换为可兼容的接口，让原本由于接口不兼容而不能一起工作的类可以一起工作。对于这个模式，有一个经常被拿来解释它的例子，就是USB转接头充当适配器，把两种不兼容的接口，通过转接变得可以一起工作。

适配器模式有两种实现方式：**类适配器和对象适配器**。其中，**类适配器使用继承关系来实现，对象适配器使用组合关系来实现**。具体的代码实现如下所示。其中，ITarget表示要转化成的接口定义。Adaptee是一组不兼容ITarget接口定义的接口，`Adaptor`将`Adaptee`转化成一组符合`ITarget`接口定义的接口：

// 类适配器: 基于继承
    public interface ITarget { 
      void f1();
      void f2();
      void fc();
    }
    
    public class Adaptee { 
      public void fa() {  //... }
      public void fb() {  //... }
      public void fc() {  //... }
    }
    
    public class Adaptor extends Adaptee implements ITarget { 
      public void f1() { 
        super.fa();
      }
      
      public void f2() { 
        //...重新实现f2()...
      }
      
      // 这里fc()不需要实现，直接继承自Adaptee，这是跟对象适配器最大的不同点
    }
    
    // 对象适配器：基于组合
    public interface ITarget { 
      void f1();
      void f2();
      void fc();
    }
    
    public class Adaptee { 
      public void fa() {  //... }
      public void fb() {  //... }
      public void fc() {  //... }
    }
    
    public class Adaptor implements ITarget { 
      private Adaptee adaptee;
      
      public Adaptor(Adaptee adaptee) { 
        this.adaptee = adaptee;
      }
      
      public void f1() { 
        adaptee.fa(); //委托给Adaptee
      }
      
      public void f2() { 
        //...重新实现f2()...
      }
      
      public void fc() { 
        adaptee.fc();
      }
    }

针对这两种实现方式，在实际的开发中，到底该如何选择使用哪一种呢？**判断的标准主要有两个，一个是Adaptee接口的个数，另一个是Adaptee和ITarget的契合程度**。

*  如果Adaptee接口并不多，那两种实现方式都可以。
 *  如果Adaptee接口很多，而且Adaptee和ITarget接口定义大部分都相同，那我们推荐使用类适配器，因为Adaptor复用父- 类Adaptee的接口，比起对象适配器的实现方式，Adaptor的代码量要少一些。
 *  如果Adaptee接口很多，而且Adaptee和ITarget接口定义大部分都不相同，那我们推荐使用对象适配器，因为组合结构相对于继承更加灵活。

### 适用场景 ###

#### 1. 封装有缺陷的接口设计 ####

想要使用一个已经存在的类，但是它却不符合现有的接口规范，导致无法直接去访问，这时创建一个适配器就能间接去访问这个类中的方法。

public class CD {  //这个类来自外部sdk，我们无权修改它的代码
      //...
      public static void staticFunction1() {  //... }
      
      public void uglyNamingFunction2() {  //... }
    
      public void tooManyParamsFunction3(int paramA, int paramB, ...) {  //... }
      
       public void lowPerformanceFunction4() {  //... }
    }
    // 使用适配器模式进行重构
    public class ITarget { 
      void function1();
      void function2();
      void fucntion3(ParamsWrapperDefinition paramsWrapper);
      void function4();
      //...
    }
    // 注意：适配器类的命名不一定非得末尾带Adaptor
    public class CDAdaptor extends CD implements ITarget { 
      //...
      public void function1() { 
         super.staticFunction1();
      }
      
      public void function2() { 
        super.uglyNamingFucntion2();
      }
      
      public void function3(ParamsWrapperDefinition paramsWrapper) { 
         super.tooManyParamsFunction3(paramsWrapper.getParamA(), ...);
      }
      
      public void function4() { 
        //...reimplement it...
      }
    }

#### 2. 统一多个类的接口设计 ####

**某个功能的实现依赖多个外部系统（或者说类）。通过适配器模式，将它们的接口适配为统一的接口定义，然后我们就可以使用多态的特性来复用代码逻辑**。具体我还是举个例子来解释一下。

假设我们的系统要对用户输入的文本内容做敏感词过滤，为了提高过滤的召回率，我们引入了多款第三方敏感词过滤系统，依次对用户输入的内容进行过滤，过滤掉尽可能多的敏感词。但是，每个系统提供的过滤接口都是不同的。这就意味着我们没法复用一套逻辑来调用各个系统。这个时候，我们就可以使用适配器模式，将所有系统的接口适配为统一的接口定义，这样我们可以复用调用敏感词过滤的代码。

public class ASensitiveWordsFilter {  // A敏感词过滤系统提供的接口
      //text是原始文本，函数输出用***替换敏感词之后的文本
      public String filterSexyWords(String text) { 
        // ...
      }
      
      public String filterPoliticalWords(String text) { 
        // ...
      } 
    }
    
    public class BSensitiveWordsFilter  {  // B敏感词过滤系统提供的接口
      public String filter(String text) { 
        //...
      }
    }
    public class CSensitiveWordsFilter {  // C敏感词过滤系统提供的接口
      public String filter(String text, String mask) { 
        //...
      }
    }
    // 未使用适配器模式之前的代码：代码的可测试性、扩展性不好
    public class RiskManagement { 
      private ASensitiveWordsFilter aFilter = new ASensitiveWordsFilter();
      private BSensitiveWordsFilter bFilter = new BSensitiveWordsFilter();
      private CSensitiveWordsFilter cFilter = new CSensitiveWordsFilter();
      
      public String filterSensitiveWords(String text) { 
        String maskedText = aFilter.filterSexyWords(text);
        maskedText = aFilter.filterPoliticalWords(maskedText);
        maskedText = bFilter.filter(maskedText);
        maskedText = cFilter.filter(maskedText, "***");
        return maskedText;
      }
    }
    // 使用适配器模式进行改造
    public interface ISensitiveWordsFilter {  // 统一接口定义
      String filter(String text);
    }
    public class ASensitiveWordsFilterAdaptor implements ISensitiveWordsFilter { 
      private ASensitiveWordsFilter aFilter;
      public String filter(String text) { 
        String maskedText = aFilter.filterSexyWords(text);
        maskedText = aFilter.filterPoliticalWords(maskedText);
        return maskedText;
      }
    }
    //...省略BSensitiveWordsFilterAdaptor、CSensitiveWordsFilterAdaptor...
    
    // 扩展性更好，更加符合开闭原则，如果添加一个新的敏感词过滤系统，
    // 这个类完全不需要改动；而且基于接口而非实现编程，代码的可测试性更好。
    public class RiskManagement {  
      private List filters = new ArrayList<>();
     
      public void addSensitiveWordsFilter(ISensitiveWordsFilter filter) { 
        filters.add(filter);
      }
      
      public String filterSensitiveWords(String text) { 
        String maskedText = text;
        for (ISensitiveWordsFilter filter : filters) { 
          maskedText = filter.filter(maskedText);
        }
        return maskedText;
      }
    }

#### 3. 替换依赖的外部系统 ####

顾名思义即可！

// 外部系统A
    public interface IA { 
      //...
      void fa();
    }
    public class A implements IA { 
      //...
      public void fa() {  //... }
    }
    // 在我们的项目中，外部系统A的使用示例
    public class Demo { 
      private IA a;
      public Demo(IA a) { 
        this.a = a;
      }
      //...
    }
    Demo d = new Demo(new A());
    
    // 将外部系统A替换成外部系统B
    public class BAdaptor implemnts IA { 
      private B b;
      public BAdaptor(B b) { 
        this.b= b;
      }
      public void fa() { 
        //...
        b.fb();
      }
    }
    // 借助BAdaptor，Demo的代码中，调用IA接口的地方都无需改动，
    // 只需要将BAdaptor如下注入到Demo即可。
    Demo d = new Demo(new BAdaptor(new B()));

#### 4.兼容老版本接口 ####

#### 5.适配不同格式的数据 ####

前面我们讲到，适配器模式主要用于接口的适配，实际上，它还可以用在不同格式的数据之间的适配。比如，把从不同征信系统拉取的不同格式的征信数据，统一为相同的格式，以方便存储和使用。再比如，Java中的Arrays.asList()也可以看作一种数据适配器，将数组类型的数据转化为集合容器类型。

`List stooges = Arrays.asList("Larry", "Moe", "Curly");`

# 装饰器模式 #

非常类似于代理模式。主要用与**解决继承关系过于复杂的问题**，通过组合来替代继承。**它（1）主要的作用是给原始类添加增强功能。这也是判断是否该用装饰器模式的一个重要的依据**。除此之外，装饰器模式还有一个特点，那就是可以对原始类嵌套使用多个装饰器。为了满足这个应用场景，在设计的时候，装饰器类需要跟原始类继承相同的抽象类或者接口。

代码见：

// 代理模式的代码结构(下面的接口也可以替换成抽象类)
    public interface IA { 
      void f();
    }
    public class A impelements IA { 
      public void f() {  //... }
    }
    public class AProxy impements IA { 
      private IA a;
      public AProxy(IA a) { 
        this.a = a;
      }
      
      public void f() { 
        // 新添加的代理逻辑
        a.f();
        // 新添加的代理逻辑
      }
    }
    
    // 装饰器模式的代码结构(下面的接口也可以替换成抽象类)
    public interface IA { 
      void f();
    }
    public class A impelements IA { 
      public void f() {  //... }
    }
    public class ADecorator impements IA { 
      private IA a;
      public ADecorator(IA a) { 
        this.a = a;
      }
      
      public void f() { 
        // 功能增强代码
        a.f();
        // 功能增强代码
      }
    }

# 四种模式的比较 #

> 代理模式：代理模式在不改变原始类接口的条件下，为原始类定义一个代理类，主要目的是控制访问，而非加强功能，这是它跟装饰器模式最大的不同。

> 桥接模式：桥接模式的目的是将接口部分和实现部分分离，从而让它们可以较为容易、也相对独立地加以改变。

> 装饰器模式：装饰者模式在不改变原始类接口的情况下，对原始类功能进行增强，并且支持多个装饰器的嵌套使用。

> 适配器模式：适配器模式是一种事后的补救策略。适配器提供跟原始类不同的接口，而代理模式、装饰器模式提供的都是跟原始类相同的接口。

# 参考阅读： #

[Spring Aop 动态代理][Spring Aop]

[Link 1]: https://blog.csdn.net/liushengxi_root/article/details/119086426
[Spring Aop]: https://segmentfault.com/a/1190000037596406
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdXNoZW5neGlfcm9vdA_size_16_color_FFFFFF_t_70]: /images/20220829/cea9a36aef344ac18abea3d65ffcfb24.png