结构型模式：装饰器模式

Auroral1562025-04-30 10:31

装饰器模式是什么？

最近在重构项目时，我遇到了这样一个问题：需要给现有的对象增加新功能，但又不想修改原始代码。研究了一番后，发现装饰器模式正是解决这类问题的绝佳方案。

装饰器模式（Decorator Pattern）本质上是一种结构型设计模式，它允许我们在不改变对象结构的前提下，动态地给对象添加新功能。它就像给房子装修一样 ------ 你可以添加各种装饰（墙纸、地板、家具），但房子的基本结构保持不变。

简单来说，装饰器模式的核心思想是："在不改变原有对象的基础上，通过包装的方式给对象添加新功能，并且可以实现功能的自由组合"。

装饰器模式的结构

装饰器模式包含这几个主要角色：

  1. 组件（Component）：定义了可以被装饰的对象的接口
  2. 具体组件（Concrete Component）：实现了组件接口的实体对象
  3. 装饰器（Decorator）：持有一个组件引用，并实现与组件相同的接口
  4. 具体装饰器（Concrete Decorator）：实现具体的装饰功能

下面是装饰器模式的类图结构：

classDiagram class Component { <> +operation() } class ConcreteComponent { +operation() } class Decorator { <> -component: Component +operation() } class ConcreteDecoratorA { -addedState +operation() +addedBehavior() } class ConcreteDecoratorB { +operation() +addedBehavior() } Component <|.. ConcreteComponent Component <|.. Decorator Decorator o--> Component Decorator <|-- ConcreteDecoratorA Decorator <|-- ConcreteDecoratorB

装饰器模式的基本实现

我们先看一个简单的Java实现，了解装饰器模式的基本结构：

java 复制代码 
// 组件接口
public interface Component {
    void operation();
}

// 具体组件
public class ConcreteComponent implements Component {
    @Override
    public void operation() {
        System.out.println("具体组件的基本操作");
    }
}

// 装饰器抽象类
public abstract class Decorator implements Component {
    protected Component component;
    
    public Decorator(Component component) {
        this.component = component;
    }
    
    @Override
    public void operation() {
        component.operation();
    }
}

// 具体装饰器A
public class ConcreteDecoratorA extends Decorator {
    public ConcreteDecoratorA(Component component) {
        super(component);
    }
    
    @Override
    public void operation() {
        super.operation();
        System.out.println("装饰器A添加的功能");
    }
    
    // 额外的方法
    public void additionalFunctionA() {
        System.out.println("装饰器A特有的功能");
    }
}

// 具体装饰器B
public class ConcreteDecoratorB extends Decorator {
    public ConcreteDecoratorB(Component component) {
        super(component);
    }
    
    @Override
    public void operation() {
        super.operation();
        System.out.println("装饰器B添加的功能");
    }
    
    // 额外的方法
    public void additionalFunctionB() {
        System.out.println("装饰器B特有的功能");
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        // 创建核心组件
        Component component = new ConcreteComponent();
        System.out.println("=== 原始组件 ===");
        component.operation();
        
        // 使用装饰器A装饰
        Component decoratedA = new ConcreteDecoratorA(component);
        System.out.println("\n=== 使用装饰器A装饰后 ===");
        decoratedA.operation();
        
        // 使用装饰器B装饰
        Component decoratedB = new ConcreteDecoratorB(component);
        System.out.println("\n=== 使用装饰器B装饰后 ===");
        decoratedB.operation();
        
        // 多重装饰：先用A装饰，再用B装饰
        Component decoratedBA = new ConcreteDecoratorB(new ConcreteDecoratorA(component));
        System.out.println("\n=== 使用装饰器B和A组合装饰后 ===");
        decoratedBA.operation();
    }
}

咖啡订单系统：装饰器模式的实际应用

在项目中，我实现过一个咖啡订单系统，这是装饰器模式的经典应用场景。想象一下星巴克的点单过程：先选择基础咖啡（浓缩、黑咖啡等），然后添加各种配料（牛奶、摩卡、奶泡等）。

java 复制代码 
// 饮料组件接口
interface Beverage {
    String getDescription();
    double cost();
}

// 具体组件：浓缩咖啡
class Espresso implements Beverage {
    @Override
    public String getDescription() {
        return "浓缩咖啡";
    }
    
    @Override
    public double cost() {
        return 15.0;
    }
}

// 具体组件：黑咖啡
class HouseBlend implements Beverage {
    @Override
    public String getDescription() {
        return "黑咖啡";
    }
    
    @Override
    public double cost() {
        return 12.0;
    }
}

// 具体组件：低因咖啡
class Decaf implements Beverage {
    @Override
    public String getDescription() {
        return "低因咖啡";
    }
    
    @Override
    public double cost() {
        return 13.0;
    }
}

// 装饰器抽象类
abstract class CondimentDecorator implements Beverage {
    protected Beverage beverage;
    
    public CondimentDecorator(Beverage beverage) {
        this.beverage = beverage;
    }
    
    @Override
    public abstract String getDescription();
}

// 具体装饰器：牛奶
class Milk extends CondimentDecorator {
    public Milk(Beverage beverage) {
        super(beverage);
    }
    
    @Override
    public String getDescription() {
        return beverage.getDescription() + ", 加牛奶";
    }
    
    @Override
    public double cost() {
        return beverage.cost() + 3.0;
    }
}

// 具体装饰器：摩卡
class Mocha extends CondimentDecorator {
    public Mocha(Beverage beverage) {
        super(beverage);
    }
    
    @Override
    public String getDescription() {
        return beverage.getDescription() + ", 加摩卡";
    }
    
    @Override
    public double cost() {
        return beverage.cost() + 4.0;
    }
}

// 具体装饰器：奶泡
class Whip extends CondimentDecorator {
    public Whip(Beverage beverage) {
        super(beverage);
    }
    
    @Override
    public String getDescription() {
        return beverage.getDescription() + ", 加奶泡";
    }
    
    @Override
    public double cost() {
        return beverage.cost() + 2.0;
    }
}

// 具体装饰器：糖浆
class Syrup extends CondimentDecorator {
    private String flavor;
    
    public Syrup(Beverage beverage, String flavor) {
        super(beverage);
        this.flavor = flavor;
    }
    
    @Override
    public String getDescription() {
        return beverage.getDescription() + ", 加" + flavor + "糖浆";
    }
    
    @Override
    public double cost() {
        return beverage.cost() + 3.5;
    }
}

// 咖啡店示例
public class CoffeeShop {
    public static void main(String[] args) {
        System.out.println("===== 欢迎光临咖啡店 =====\n");
        
        // 点一杯普通浓缩咖啡
        Beverage espresso = new Espresso();
        displayOrder(espresso);
        
        // 点一杯双份摩卡加奶泡的黑咖啡
        Beverage specialCoffee = new Whip(new Mocha(new Mocha(new HouseBlend())));
        displayOrder(specialCoffee);
        
        // 点一杯加牛奶和焦糖糖浆的低因咖啡
        Beverage lowCaffeine = new Syrup(new Milk(new Decaf()), "焦糖");
        displayOrder(lowCaffeine);
        
        // 创建一个超级复杂的订单
        Beverage complex = new Whip(
                           new Mocha(
                           new Milk(
                           new Syrup(new Espresso(), "香草"))));
        displayOrder(complex);
    }
    
    private static void displayOrder(Beverage beverage) {
        System.out.println("订单: " + beverage.getDescription());
        System.out.println("价格: ￥" + beverage.cost());
        System.out.println();
    }
}

运行这段代码，输出结果如下：

makefile 复制代码 
===== 欢迎光临咖啡店 =====

订单: 浓缩咖啡
价格: ￥15.0

订单: 黑咖啡, 加摩卡, 加摩卡, 加奶泡
价格: ￥22.0

订单: 低因咖啡, 加牛奶, 加焦糖糖浆
价格: ￥19.5

订单: 浓缩咖啡, 加香草糖浆, 加牛奶, 加摩卡, 加奶泡
价格: ￥27.5

文本处理器：另一个实用案例

前段时间我开发了一个文本处理工具，需要支持各种文本转换操作（大写转换、HTML转义、添加前缀后缀等）。这些功能需要能够灵活组合，装饰器模式就派上了用场：

java 复制代码 
// 文本组件接口
interface TextComponent {
    String format(String text);
}

// 基础文本处理器
class BasicTextProcessor implements TextComponent {
    @Override
    public String format(String text) {
        // 基本文本处理逻辑
        return text;
    }
}

// 文本装饰器抽象类
abstract class TextDecorator implements TextComponent {
    protected TextComponent textComponent;
    
    public TextDecorator(TextComponent textComponent) {
        this.textComponent = textComponent;
    }
}

// 大写转换装饰器
class UpperCaseDecorator extends TextDecorator {
    public UpperCaseDecorator(TextComponent textComponent) {
        super(textComponent);
    }
    
    @Override
    public String format(String text) {
        String processedText = textComponent.format(text);
        return processedText.toUpperCase();
    }
}

// 删除空格装饰器
class TrimDecorator extends TextDecorator {
    public TrimDecorator(TextComponent textComponent) {
        super(textComponent);
    }
    
    @Override
    public String format(String text) {
        String processedText = textComponent.format(text);
        return processedText.trim();
    }
}

// HTML转义装饰器
class HtmlEscapeDecorator extends TextDecorator {
    public HtmlEscapeDecorator(TextComponent textComponent) {
        super(textComponent);
    }
    
    @Override
    public String format(String text) {
        String processedText = textComponent.format(text);
        return processedText
                .replace("&", "&amp;")
                .replace("<", "&lt;")
                .replace(">", "&gt;")
                .replace("\"", "&quot;")
                .replace("'", "&#39;");
    }
}

// 添加前缀/后缀装饰器
class PrefixSuffixDecorator extends TextDecorator {
    private String prefix;
    private String suffix;
    
    public PrefixSuffixDecorator(TextComponent textComponent, String prefix, String suffix) {
        super(textComponent);
        this.prefix = prefix;
        this.suffix = suffix;
    }
    
    @Override
    public String format(String text) {
        String processedText = textComponent.format(text);
        return prefix + processedText + suffix;
    }
}

// 文本压缩装饰器（移除重复空格）
class CompressDecorator extends TextDecorator {
    public CompressDecorator(TextComponent textComponent) {
        super(textComponent);
    }
    
    @Override
    public String format(String text) {
        String processedText = textComponent.format(text);
        return processedText.replaceAll("\\s+", " ");
    }
}

Java API中的装饰器模式

在学习装饰器模式的过程中，我发现Java标准库中有很多经典的装饰器模式应用。最典型的例子就是Java I/O流：

java 复制代码 
// 一个典型的Java I/O装饰器链
BufferedReader reader = new BufferedReader(
                         new InputStreamReader(
                         new FileInputStream("file.txt")));

这里，我们用BufferedReader和InputStreamReader这两个装饰器层层包装了FileInputStream，从而增强了基本的文件输入流功能。

Java集合框架中的Collections工具类也提供了许多装饰器方法：

java 复制代码 
// 不可修改的列表装饰器
List<String> safeList = Collections.unmodifiableList(originalList);

// 线程安全的Map装饰器
Map<String, Integer> syncMap = Collections.synchronizedMap(originalMap);

装饰器模式的适用场景

通过实际项目经验，我总结了装饰器模式的几个适用场景：

  1. 需要动态添加功能时：当你需要在运行时决定给对象添加什么功能，装饰器模式比继承更灵活。

  2. 需要组合多种功能时：比如我们的咖啡示例，可以随意组合各种配料。

  3. 继承方案导致子类爆炸时：如果使用继承，为每种功能组合创建一个子类，类的数量会呈指数级增长。

  4. 不想修改现有代码时：遵循开闭原则，通过装饰器添加新功能而不修改现有代码。

装饰器模式与其他模式的比较

在项目选型时，我经常需要在几种相似的设计模式中做选择：

  1. 装饰器模式 vs 代理模式：

    • 装饰器：专注于动态添加功能，通常有多个装饰器层
    • 代理：控制对对象的访问，通常只有一层代理

  2. 装饰器模式 vs 策略模式：

    • 装饰器：增强对象功能，保持接口不变
    • 策略：提供不同的算法实现，一次只能使用一种策略

  3. 装饰器模式 vs 组合模式：

    • 装饰器：关注于包装和增强
    • 组合：关注于构建树形结构，处理"部分-整体"关系

装饰器模式的优缺点

根据我的使用经验，装饰器模式有以下优点：

  • 灵活性高：比继承更灵活，能在运行时动态组合功能
  • 避免类爆炸：不需要为每种功能组合创建子类
  • 符合开闭原则：可以在不修改现有代码的情况下添加新功能
  • 单一职责：每个装饰器专注于单一功能

但也存在一些缺点：

  • 可能产生大量小对象：过多的装饰器可能导致系统中有大量小对象
  • 增加复杂性：装饰层次太深可能会难以理解和调试
  • 装饰器顺序问题：有时装饰器的顺序很重要，不当的顺序可能导致问题
  • 调试困难：嵌套多层装饰器后，调试时可能难以确定问题出在哪一层

实际工作中的最佳实践

在工作中使用装饰器模式时，我总结了一些实用技巧：

  1. 保持接口简单：装饰器接口应尽量简单，这样装饰器实现起来更容易

  2. 创建装饰器工厂：当装饰器组合变得复杂时，可以创建工厂方法简化客户端代码

  3. 注意异常处理：确保装饰器正确处理和传播异常

  4. 考虑性能影响：装饰器可能带来性能开销，特别是在I/O操作中

  5. 明确记录装饰器顺序：如果装饰器顺序很重要，请在文档中清晰说明

现代框架中的装饰器应用

除了Java标准库，现代框架中也广泛使用装饰器模式：

Spring框架中的应用

java 复制代码 
// Spring中的数据源装饰器
public class LoggingDataSourceDecorator extends AbstractDataSourceDecorator {
    public LoggingDataSourceDecorator(DataSource dataSource) {
        super(dataSource);
    }
    
    @Override
    public Connection getConnection() throws SQLException {
        System.out.println("获取数据库连接");
        Connection connection = super.getConnection();
        System.out.println("已获取数据库连接");
        return connection;
    }
}

JavaScript中的装饰器

javascript 复制代码 
// JavaScript装饰器函数
function loggingDecorator(originalFunction) {
    return function(...args) {
        console.log(`调用函数，参数：${args}`);
        const result = originalFunction.apply(this, args);
        console.log(`函数返回：${result}`);
        return result;
    };
}

// 使用装饰器
const calculate = (a, b) => a + b;
const decoratedCalculate = loggingDecorator(calculate);
decoratedCalculate(3, 5); // 自动打印日志

总结

装饰器模式的灵活性和可组合性使其成为增强对象功能的理想选择。不过，和所有设计模式一样，它也不是万能的，需要根据具体场景合理使用。

希望这篇文章能帮助你理解装饰器模式的本质和应用。如果你有任何问题或者使用装饰器模式的经验想要分享，欢迎在评论区留言交流！

相关推荐
mooridy27 分钟前
设计模式 | 详解常用设计模式（六大设计原则，单例模式，工厂模式，建造者模式，代理模式）
c++·设计模式
程序员JerrySUN30 分钟前
设计模式每日硬核训练 Day 17：中介者模式（Mediator Pattern）完整讲解与实战应用
microsoft·设计模式·中介者模式
智想天开3 小时前
14.外观模式：思考与解读
windows·microsoft·设计模式·外观模式
摘星编程5 小时前
并发设计模式实战系列(9)：消息传递（Message Passing）
设计模式·并发编程
此木|西贝13 小时前
【设计模式】享元模式
java·设计模式·享元模式
麓殇⊙15 小时前
设计模式--建造者模式详解
设计模式·建造者模式
不当菜虚困15 小时前
JAVA设计模式——（八）单例模式
java·单例模式·设计模式
Java致死15 小时前
工厂设计模式
java·设计模式·简单工厂模式·工厂方法模式·抽象工厂模式
全栈凯哥17 小时前
桥接模式（Bridge Pattern）详解
java·设计模式·桥接模式
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03西电B测-计算机网络综合实验(含验收问题)04Coze扣子平台完整体验和实践（附国内和国际版对比）05YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】06DeepSeek各版本说明与优缺点分析07【VIsion Master】机器视觉软件二次开发（C#版本）学习笔记08yolov8，yolo11，yolo12 服务器训练到部署全流程 笔记09我决定放弃搞 Java 了10Python基于Flask的豆瓣电影数据分析可视化系统（附源码，文档说明）