装饰器模式详解：动态扩展对象功能的优雅解决方案

在面向对象设计中，装饰器模式是一种结构型设计模式，它允许我们在不修改现有代码的情况下，通过动态组合不同的功能来扩展对象的行为。装饰器模式特别适合需要灵活组合对象功能的场景，同时避免增加类的数量。本文将通过具体示例展示装饰器模式的优点，包括对象功能的扩展、动态组合以及符合开闭原则的实现。

装饰器模式的结构

在装饰器模式中，我们定义一个基础接口，所有具体实现和装饰器都实现该接口。在这个示例中，我们将使用 DataLoader 接口及其基本实现 FileDataLoader，并定义加密和压缩两种功能的装饰器类。这种结构使得不同的装饰器可以组合在一起，实现多样化的功能。

示例代码

1. 定义基础接口和具体实现

首先，我们定义 DataLoader 接口和一个简单的实现类 FileDataLoader，该类实现了基本的数据读写功能：

// 基础接口，定义读写数据的方法
public interface DataLoader {
    String read();
    void write(String data);
}

// 基本的文件加载实现类
public class FileDataLoader implements DataLoader {
    private String data;
    
    @Override
    public String read() {
        return data;
    }

    @Override
    public void write(String data) {
        this.data = data;
    }
}

2. 定义装饰器基类

装饰器基类 DataLoaderDecorator 实现了 DataLoader 接口，并包含一个 DataLoader 类型的成员变量 wrapper，通过它调用基础对象的 read() 和 write() 方法。所有具体装饰器类都继承这个基类：

// 装饰器基类，所有装饰器都继承自此类
public abstract class DataLoaderDecorator implements DataLoader {
    protected DataLoader wrapper;

    public DataLoaderDecorator(DataLoader wrapper) {
        this.wrapper = wrapper;
    }

    @Override
    public String read() {
        return wrapper.read();
    }

    @Override
    public void write(String data) {
        wrapper.write(data);
    }
}

3. 定义具体装饰器类

接下来，我们创建两个具体装饰器类：EncryptionDecorator 用于加密和解密数据，CompressionDecorator 用于压缩和解压数据。每个装饰器在 read() 和 write() 方法中对数据进行处理。

// 加密装饰器类
public class EncryptionDecorator extends DataLoaderDecorator {

    public EncryptionDecorator(DataLoader wrapper) {
        super(wrapper);
    }

    @Override
    public String read() {
        return decode(wrapper.read());
    }

    @Override
    public void write(String data) {
        wrapper.write(encode(data));
    }

    private String encode(String data) {
        return "ENC(" + data + ")"; // 模拟加密
    }

    private String decode(String data) {
        return data.replace("ENC(", "").replace(")", ""); // 模拟解密
    }
}

// 压缩装饰器类
public class CompressionDecorator extends DataLoaderDecorator {

    public CompressionDecorator(DataLoader wrapper) {
        super(wrapper);
    }

    @Override
    public String read() {
        return decompress(wrapper.read());
    }

    @Override
    public void write(String data) {
        wrapper.write(compress(data));
    }

    private String compress(String data) {
        return "ZIP(" + data + ")"; // 模拟压缩
    }

    private String decompress(String data) {
        return data.replace("ZIP(", "").replace(")", ""); // 模拟解压缩
    }
}

4. 使用装饰器展示优点

我们可以通过不同的装饰器组合来扩展 DataLoader 对象的功能，例如只使用加密装饰器、压缩装饰器，或同时使用两者。

public class DecoratorDemo {
    public static void main(String[] args) {
        // 基础的 DataLoader 对象
        DataLoader fileLoader = new FileDataLoader();
        
        // 1. 使用单个装饰器扩展对象功能
        DataLoader encryptedLoader = new EncryptionDecorator(fileLoader);
        encryptedLoader.write("TestData");
        System.out.println("加密数据: " + encryptedLoader.read());

        // 2. 动态组合装饰器来扩展功能（加密 + 压缩）
        DataLoader encryptedCompressedLoader = new CompressionDecorator(new EncryptionDecorator(fileLoader));
        encryptedCompressedLoader.write("TestData");
        System.out.println("加密并压缩数据: " + encryptedCompressedLoader.read());

        // 3. 增加新的装饰器无需更改原有类
        DataLoader compressedLoader = new CompressionDecorator(fileLoader);
        compressedLoader.write("TestData");
        System.out.println("压缩数据: " + compressedLoader.read());
    }
}

5. 运行结果

加密数据: TestData
加密并压缩数据: TestData
压缩数据: TestData

继承结构的缺陷

如果使用继承来实现加密和压缩功能，可能会导致以下子类的爆炸性增加：

• EncryptedDataLoader
• CompressedDataLoader
• EncryptedCompressedDataLoader
• LoggedDataLoader
• LoggedEncryptedDataLoader
• LoggedCompressedDataLoader
• LoggedEncryptedCompressedDataLoader

随着功能的增加，类的数量也会急剧增加，造成“类爆炸”。

装饰器模式的优点分析

灵活扩展功能

通过组合 EncryptionDecorator 和 CompressionDecorator，我们可以轻松实现数据的加密和压缩功能，而无需创建大量子类，从而避免“类爆炸”。

动态扩展

装饰器模式允许在运行时选择不同的装饰器，这使得功能扩展更加灵活。例如，可以根据不同的环境选择是否对数据进行加密和压缩。

符合开闭原则

新增功能只需创建新的装饰器类，无需修改现有类。即使希望添加日志记录等功能，也只需新增装饰器，而不必更改已有类的代码。

动态装饰器组合：通过配置文件实现运行时扩展

装饰器模式的一个重要优势是可以通过配置文件动态指定装饰器组合，从而在运行时灵活扩展对象的功能。这一特性在需要快速调整功能而无需重新编译代码的应用中尤为重要。接下来，我们将通过一个简单的 config.properties 文件实现动态组合装饰器的功能。

配置文件示例

在 config.properties 文件中指定所需的装饰器组合：

decorators=EncryptionDecorator,CompressionDecorator

动态加载装饰器

我们使用反射机制，根据配置文件中的装饰器类名称动态加载相应装饰器，并组合这些装饰器：

import java.io.InputStream;
import java.util.Properties;

public class DataLoaderFactory {

    public static DataLoader createDataLoader() throws Exception {
        DataLoader dataLoader = new FileDataLoader();
        
        // 加载配置文件
        Properties props = new Properties();
        try (InputStream input = DataLoaderFactory.class.getClassLoader().getResourceAsStream("config.properties")) {
            props.load(input);
        }

        // 获取装饰器列表并动态组合装饰器
        String decorators = props.getProperty("decorators");
        if (decorators != null) {
            for (String decoratorClass : decorators.split(",")) {
                Class<?> clazz = Class.forName(decoratorClass.trim());
                dataLoader = (DataLoader) clazz.getConstructor(DataLoader.class).newInstance(dataLoader);
            }
        }

        return dataLoader;
    }
}

测试动态装饰器组合

通过 DataLoaderFactory 创建动态组合的 DataLoader：

public class Main {
    public static void main(String[] args) throws Exception {
        DataLoader dataLoader = DataLoaderFactory.createDataLoader();
        
        // 使用装饰后的 DataLoader 写入和读取数据
        dataLoader.write("测试数据");
        System.out.println("读取数据: " + dataLoader.read());
    }
}

运行结果示例

假设启用了 EncryptionDecorator 和 CompressionDecorator：

写入数据: 压缩(加密(测试数据))
读取数据: 解压缩(解密(原始数据))

总结

装饰器模式通过组合装饰器动态扩展对象的功能，显著减少了类的数量，符合开闭原则，并且在运行时灵活配置功能，提升了代码的复用性与维护性。这种模式优雅地解决了继承可能引发的类爆炸问题，尤其在设计扩展性强的应用时极具优势。

关于装饰者模式的使用场景，您可以参考这篇文章：装饰者模式使用场景