【设计模式】结构型-装饰器模式

在代码的海洋深处迷离，藏匿着一片神奇之地。那里有细腻的线条交错，是装饰器的奇妙艺术。

一、登录的困境

假设我们有一个 User 类，它有一些基本的功能，比如 login() 和 logout()。现在，如果我们想要添加一些额外的功能，比如日志记录、权限检查等，我们可能会这样做：

public class User {
    public void login() {
        System.out.println("Logging in...");
    }

    public void logout() {
        System.out.println("Logging out...");
    }

    public void logActivity() {
        System.out.println("Logging activity...");
    }

    public void checkPermission() {
        System.out.println("Checking permission...");
    }
}

然后，我们可以像这样使用它：

public class Main {
    public static void main(String[] args) {
        User user = new User();
        user.login();
        user.logActivity();
        user.checkPermission();
        user.logout();
    }
}

这种方法的问题在于，我们的 User 类变得越来越复杂，每次添加新的功能，我们都需要修改 User 类。这使得代码难以维护和扩展。

二、装饰器模式

装饰器模式是一种结构型设计模式，它允许动态地将新功能附加到对象上。这种模式通常用于遵循单一职责原则，即每个类应该只负责一种类型的功能。装饰器模式通过将对象封装在一个装饰器类的实例中，然后再封装到另一个装饰器类的实例中，以此类推，来实现功能的添加或修改，而不需要修改原始对象的代码。

装饰器模式的特点：

1. 动态添加功能： 装饰器模式允许在运行时动态地给对象添加新的功能，而不需要修改原始对象的代码。通过装饰器，可以在不改变现有对象结构的情况下，扩展其功能。
2. 保持单一职责原则： 装饰器模式遵循了设计原则中的单一职责原则。每个装饰器类都只关注于添加一个特定的功能，而不会包含其它的无关逻辑，从而保持了类的简洁性和可维护性。
3. 避免类爆炸： 装饰器模式避免了通过继承来扩展功能可能导致的类爆炸问题。通过组合和嵌套装饰器，可以灵活地组合不同的功能，而不需要创建大量的子类。
4. 与继承相比更灵活： 装饰器模式提供了一种比继承更加灵活的方式来扩展对象的功能。通过组合和嵌套装饰器，可以实现更复杂的功能组合，而不会产生类层次结构的复杂性。
5. 可透明地使用原始对象： 使用装饰器模式时，客户端可以透明地使用原始对象，不需要知道装饰器的存在。装饰器和原始对象拥有相同的接口，因此可以完全替代原始对象的使用。

三、装饰器模式的核心组成部分

装饰器模式的核心组成包括以下几个要素：

1. Component（组件）： 这是一个接口或者抽象类，定义了被装饰对象和装饰器对象的公共接口，确保它们可以相互替换。
2. ConcreteComponent（具体组件）： 这是实现了 Component 接口的具体类，是被装饰的对象。它定义了最基本的行为，可以被一个或多个装饰器扩展。
3. Decorator（装饰器）： 这是一个抽象类或者接口，与 Component 具有相同的接口，并且包含一个指向 Component 对象的引用。它通常是一个抽象类，提供了一个默认实现来调用被装饰对象的原始方法，或者添加一些共享的功能。
4. ConcreteDecorator（具体装饰器）： 这是实现了 Decorator 接口的具体类，用于给 ConcreteComponent 添加额外的功能。它可以有一个或多个具体装饰器，可以嵌套使用，每个装饰器都对组件的行为进行了修改或者扩展。

这个类图展示了 Component、ConcreteComponent、Decorator 和 ConcreteDecorator 之间的关系。Component 是被装饰对象和装饰器对象的公共接口，ConcreteComponent 是具体的被装饰对象，Decorator 是装饰器的抽象类，ConcreteDecorator 是具体的装饰器类。

四、运用装饰器模式

场景假设：我们需要在之前已经拥有的登录功能上多增加一项功能：在用户登录时显示一条欢迎消息。我们可以使用装饰器模式来实现这个功能。

1. 定义组件接口： 首先，定义一个接口或抽象类，代表被装饰的对象。这个接口应该声明装饰器和被装饰者共同拥有的方法。

   // UserService.java
   public interface UserService {
       void login(String username);
   }
   

2. 创建具体组件类： 实现组件接口，创建一个具体的类，代表基本的被装饰对象。这个类提供了最基本的功能。

   // SimpleUserService.java
   public class SimpleUserService implements UserService {
       @Override
       public void login(String username) {
           System.out.println("User " + username + " logged in.");
       }
   }
   

3. 定义装饰器抽象类或接口： 创建一个抽象类或接口，用于定义装饰器的公共接口。这个类通常会包含一个指向组件接口的引用，以便装饰器可以对被装饰者进行操作。

   // UserServiceDecorator.java
   public abstract class UserServiceDecorator implements UserService {
       protected UserService decoratedUserService;
   
       public UserServiceDecorator(UserService decoratedUserService) {
           this.decoratedUserService = decoratedUserService;
       }
   
       @Override
       public void login(String username) {
           decoratedUserService.login(username);
       }
   }
   

4. 创建具体装饰器类： 创建一个或多个具体的装饰器类，它们实现了装饰器接口，并包含一个指向组件接口的引用。这些装饰器类可以添加额外的功能或修改组件的行为。

   // WelcomeMessageDecorator.java
   public class WelcomeMessageDecorator extends UserServiceDecorator {
       public WelcomeMessageDecorator(UserService decoratedUserService) {
           super(decoratedUserService);
       }
   
       @Override
       public void login(String username) {
           super.login(username);
           // 新增的欢迎功能
           System.out.println("Welcome, " + username + "!");
       }
   }
   

5. 使用装饰器： 在客户端代码中，创建一个具体的组件对象，并用装饰器对象对其进行包装。可以通过链式调用多个装饰器来实现复杂的装饰效果。

   // Main.java
   public class Main {
       public static void main(String[] args) {
           // 创建一个简单的用户服务
           UserService simpleUserService = new SimpleUserService();
   
           // 使用装饰器添加欢迎消息
           UserService userServiceWithWelcomeMessage = new WelcomeMessageDecorator(simpleUserService);
   
           // 模拟用户登录
           userServiceWithWelcomeMessage.login("Alice");
       }
   }
   

五、装饰器模式的应用场景

装饰器模式在许多场景中都非常有用，特别是当需要动态地、透明地（不影响其他对象）给对象添加职责时。以下是一些常见的应用场景：

1. 图形用户界面工具箱：在图形用户界面工具箱中，装饰器模式可以用来动态地添加新的功能。例如，你可以创建一个基本的窗口对象，然后使用装饰器来添加滚动条、边框、标题等。
2. Java I/O：Java 的 I/O 类库就广泛使用了装饰器模式。例如，你可以创建一个基本的 FileInputStream 对象，然后使用装饰器如 BufferedInputStream 来增加缓冲功能。
3. Web 开发中的中间件：在 Web 开发中，装饰器模式常常被用作中间件，允许在处理请求和响应之前或之后插入额外的逻辑，比如日志记录、错误处理、身份验证等。
4. 测试和校验：在写测试或者进行数据校验时，装饰器模式也很有用。可以使用装饰器来添加额外的校验逻辑，或者在测试中模拟特定的条件。

这些只是装饰器模式的一些应用场景，实际上，只要你需要动态地给对象添加职责，而又不想增加子类的复杂性，装饰器模式就可能会是一个好的选择。

六、小结

装饰器模式是一种非常灵活的设计模式，它可以帮助我们在运行时动态地扩展对象的功能，同时保持对象接口的一致性。通过合理地运用装饰器模式，我们可以使代码更加灵活、可维护，并且更容易扩展。

推荐阅读

1. Spring 三级缓存
2. 深入了解 MyBatis 插件：定制化你的持久层框架
3. Zookeeper 注册中心：单机部署
4. 【JavaScript】探索 JavaScript 中的解构赋值
5. 深入理解 JavaScript 中的 Promise、async 和 await