重学设计模式，【结构型】装饰器模式

大家好，欢迎来到IT知识分享网。

在日常开发中，我们往往忽视了设计模式的重要性。这可能是因为项目时间紧迫，或者对设计模式理解不深。其实，很多时候我们可能在不经意间已经使用了某些模式。

重要的是要有意识地学习和应用，让代码更加优雅和高效。也许是时候重新审视我们的编程实践，将设计模式融入其中了。

今天由浅入深，重学【装饰器模式】，让我们一起“重学设计模式”。

装饰器模式（Decorator Pattern）是一种结构型设计模式，允许通过一种灵活的方式动态地为对象添加新的行为或职责，而无需修改其原始代码。这种模式提供了比继承更有弹性的替代方案，通过将对象包装在一系列装饰器类中，可以在运行时组合出各种行为。

一、装饰器模式的结构

0. Component（组件）：定义一个对象接口，装饰器和被装饰对象必须实现的公共接口。
1. ConcreteComponent（具体组件）：实现Component接口的类，是可以被装饰的类。
2. Decorator（装饰器）：实现Component接口，同时持有Component类型的成员变量（可以是原始对象或其他装饰器），通过组合将功能动态扩展到该对象。
3. ConcreteDecorator（具体装饰器）：实现装饰器具体行为扩展的类，通过调用被装饰对象的行为，并在此基础上添加新的功能。

二、不使用装饰器模式时

假设我们有一个基本的电脑类，并想为它动态添加不同的配置（比如CPU、内存、GPU）。

当需要新增配置时，在Computer类中新增即可，清晰明了，没有一个ifelse解决不了的。

public class Computer { private boolean hasRAMUpgrade; private boolean hasGPUUpgrade; private boolean hasStorageUpgrade; // 基础电脑的价格 private double baseCost = 500; public Computer(boolean hasRAMUpgrade, boolean hasGPUUpgrade, boolean hasStorageUpgrade) { this.hasRAMUpgrade = hasRAMUpgrade; this.hasGPUUpgrade = hasGPUUpgrade; this.hasStorageUpgrade = hasStorageUpgrade; } public String getDescription() { String description = "Basic Computer"; if (hasRAMUpgrade) { description += ", with 16GB RAM"; } if (hasGPUUpgrade) { description += ", with NVIDIA GPU"; } if (hasStorageUpgrade) { description += ", with 1TB SSD"; } return description; } public double cost() { double totalCost = baseCost; if (hasRAMUpgrade) { totalCost += 150; } if (hasGPUUpgrade) { totalCost += 300; } if (hasStorageUpgrade) { totalCost += 200; } return totalCost; } } package com.guor.designPattern.decorator.no; public class Test { public static void main(String[] args) { // 用户选择了升级内存和显卡 Computer myComputer = new Computer(true, true, true); System.out.println(myComputer.getDescription() + " costs #34; + myComputer.cost()); } }

三、使用装饰器模式优化

当需要新增配置时，直接实现ComputerDecorator，重写getDescription、cost方法即可，实现了高扩展，解决了ifelse low爆炸的问题。

1、基础电脑组件

/ * 基础电脑 */ public class BasicComputer extends Computer { @Override public String getDescription() { return "Basic Computer"; } @Override public double cost() { return 500; // 基础电脑的价格 } }

2、抽象组件

package com.guor.designPattern.decorator; / * 抽象组件 */ public abstract class Computer { // 描述 public abstract String getDescription(); // 成本 public abstract double cost(); }

3、抽象装饰器

/ * 抽象装饰器 */ public abstract class ComputerDecorator extends Computer { protected Computer computer; public ComputerDecorator(Computer computer) { this.computer = computer; } public abstract String getDescription(); }

4、具体装饰器

public class StorageUpgrade extends ComputerDecorator { public StorageUpgrade(Computer computer) { super(computer); } @Override public String getDescription() { return computer.getDescription() + ", with 1TB SSD"; } @Override public double cost() { return computer.cost() + 200; } } public class RAMUpgrade extends ComputerDecorator { public RAMUpgrade(Computer computer) { super(computer); } @Override public String getDescription() { return computer.getDescription() + ", with 16GB RAM"; } @Override public double cost() { return computer.cost() + 150; // 额外内存的价格 } } public class GPUUpgrade extends ComputerDecorator { public GPUUpgrade(Computer computer) { super(computer); } @Override public String getDescription() { return computer.getDescription() + ", with NVIDIA GPU"; } @Override public double cost() { return computer.cost() + 300; // 额外显卡的价格 } }

四、使用装饰器模式有哪些优势

1、动态扩展对象功能

装饰器模式允许在运行时动态地为对象添加功能，而不需要修改对象的结构。相比于继承，它提供了更为灵活的扩展方式，因为继承在编译时就固定了对象的行为，而装饰器则可以通过组合多个装饰器动态改变对象的行为。

2、更好的代码复用性

装饰器可以封装可复用的功能，不同的对象可以共享这些功能而不需要重复编写代码。这种方式提高了代码的可维护性和复用性。

3、遵循单一职责原则

装饰器将对象的核心职责和其他辅助功能（如日志、缓存、权限控制）分离开来，每个装饰器只负责一个特定的功能，避免了类的职责过多。

4、减少子类的数量

继承机制常常会导致大量的子类，因为每个新的功能都需要通过子类来实现。而装饰器模式可以通过组合多个装饰器来实现相同的功能扩展，减少类的数量和复杂度。

5、运行时灵活性

装饰器可以在运行时动态地添加或移除功能，而不需要修改已有的代码。这在开发过程中非常实用，尤其是在需要频繁调整功能的场景中。

五、哪些场景可以使用装饰器模式优化？

1、增强对象功能时

当需要为现有对象增加新功能，且不希望修改对象本身或者使用继承时，可以考虑使用装饰器模式。比如在 UI 组件系统中，基础组件可以通过装饰器动态添加滚动、边框等特性，而不需要修改原始组件的代码。

2、跨领域关注点（如日志、权限验证、性能监控）

在处理一些横切关注点（cross-cutting concerns）时，装饰器模式非常有用。比如日志记录、权限控制、事务管理、性能监控等功能，它们常常不属于对象的核心业务逻辑，通过装饰器模式可以将这些功能单独提取出来，并动态添加到业务逻辑中，而不污染原始代码。

示例：

0. 日志记录：为方法调用自动添加日志功能，记录方法的输入、输出和执行时间。
1. 权限控制：在执行某些业务方法前，动态检查用户权限。
2. 事务管理：在数据库操作前后动态添加事务处理。

3、需要多个功能组合时

当对象的功能可以通过不同的方式组合时，装饰器模式是一个理想的选择。它允许通过多个装饰器的组合形成不同的功能，比如装饰器可以为对象依次添加不同的行为，从而形成灵活的功能组合。

示例：在咖啡订单系统中，咖啡基础类可以通过装饰器动态添加牛奶、糖、巧克力等配料，而不用创建大量的子类来表示每一种咖啡组合。

4、避免类爆炸（class explosion）

通过装饰器模式可以避免通过继承产生大量的子类。特别是在当类的功能是通过多个维度扩展时，比如一种基础功能的类可能同时需要加日志、加缓存、加权限控制，使用继承将导致很多子类，而使用装饰器可以有效减少类的数量。

5、与策略模式配合使用

装饰器模式可以与策略模式结合起来，为策略类提供更丰富的功能扩展。比如在电商网站中，可以为订单结算策略类动态添加打折、积分计算等功能，而不必为每种结算方式都创建新的子类。

六、优化场景举例

场景 1：Web 应用中的权限验证和日志记录

在 Web 应用中，通常需要在处理请求时添加权限验证和日志记录。假设系统已经有一个基本的请求处理类，通过装饰器可以实现动态添加权限验证和日志记录功能。

在这个场景中，通过装饰器，我们可以动态地为请求处理类添加权限验证和日志记录功能，而不必修改现有的 RequestHandler 类。

// 定义一个处理请求的接口 interface RequestHandler { void handle(String request); } // 具体的请求处理类 class BasicRequestHandler implements RequestHandler { @Override public void handle(String request) { System.out.println("Handling request: " + request); } } // 抽象装饰器类 abstract class RequestHandlerDecorator implements RequestHandler { protected RequestHandler handler; public RequestHandlerDecorator(RequestHandler handler) { this.handler = handler; } @Override public void handle(String request) { handler.handle(request); } } // 日志记录装饰器 class LoggingDecorator extends RequestHandlerDecorator { public LoggingDecorator(RequestHandler handler) { super(handler); } @Override public void handle(String request) { System.out.println("Logging request: " + request); super.handle(request); } } // 权限验证装饰器 class AuthDecorator extends RequestHandlerDecorator { public AuthDecorator(RequestHandler handler) { super(handler); } @Override public void handle(String request) { if (checkPermission(request)) { System.out.println("Permission granted"); super.handle(request); } else { System.out.println("Permission denied"); } } private boolean checkPermission(String request) { // 简单模拟权限验证逻辑 return request.contains("admin"); } } // 测试客户端 public class DecoratorExample { public static void main(String[] args) { RequestHandler handler = new BasicRequestHandler(); RequestHandler authHandler = new AuthDecorator(handler); RequestHandler loggingAuthHandler = new LoggingDecorator(authHandler); // 测试通过权限验证和日志记录的请求处理 loggingAuthHandler.handle("admin: important data"); } } 

场景 2：电子商务系统中的商品定价策略

假设一个电子商务系统中，需要对商品的价格进行灵活调整。可以通过装饰器模式为商品价格添加不同的优惠策略，例如打折、满减、会员优惠等。

在此例中，通过装饰器可以灵活组合打折和满减的策略，而不需要为每种优惠策略创建新的子类，简化了系统结构。

// 商品接口 interface Product { double getPrice(); } // 基础商品类 class BasicProduct implements Product { private double price; public BasicProduct(double price) { this.price = price; } @Override public double getPrice() { return price; } } // 抽象装饰器类 abstract class ProductDecorator implements Product { protected Product product; public ProductDecorator(Product product) { this.product = product; } @Override public double getPrice() { return product.getPrice(); } } // 打折装饰器 class DiscountDecorator extends ProductDecorator { public DiscountDecorator(Product product) { super(product); } @Override public double getPrice() { return product.getPrice() * 0.9; // 10% 折扣 } } // 满减装饰器 class FullReductionDecorator extends ProductDecorator { public FullReductionDecorator(Product product) { super(product); } @Override public double getPrice() { double price = product.getPrice(); if (price > 200) { return price - 20; // 满200减20 } return price; } } // 测试客户端 public class EcommerceExample { public static void main(String[] args) { Product product = new BasicProduct(250); Product discountProduct = new DiscountDecorator(product); Product finalProduct = new FullReductionDecorator(discountProduct); System.out.println("Final price: " + finalProduct.getPrice()); } } 

装饰器模式在需要动态扩展对象功能、复用功能模块、组合不同行为以及避免类爆炸的场景中非常有用。它可以通过装饰器类灵活地为对象添加职责，从而提升代码的可维护性、复用性和扩展性。

七、典型案例：Java I/O 流中的装饰器模式

在JDK源码中，装饰器模式有很多应用，特别是在I/O类库中，装饰器模式被广泛使用。通过装饰器模式，Java的I/O类库可以动态地为输入输出流添加缓冲、数据处理等功能，而不改变原始的输入输出流的实现。

在Java中，java.io包的输入输出流(InputStream、OutputStream)就是装饰器模式的一个典型应用。InputStream和OutputStream类是抽象基类，具体的实现类如FileInputStream、BufferedInputStream等都是具体组件，而BufferedInputStream、DataInputStream等类则是装饰器，它们通过封装InputStream实现了额外的功能，比如缓冲和数据类型处理。

1、BufferedInputStream 是 InputStream 的装饰器

// java.io.BufferedInputStream 源码片段 public class BufferedInputStream extends FilterInputStream { // Buffer size protected volatile byte[] buf; public BufferedInputStream(InputStream in) { this(in, DEFAULT_BUFFER_SIZE); } public BufferedInputStream(InputStream in, int size) { super(in); // 调用父类 FilterInputStream 的构造方法，传入被装饰的 InputStream if (size <= 0) { throw new IllegalArgumentException("Buffer size <= 0"); } buf = new byte[size]; } @Override public int read() throws IOException { // 通过缓存读取流数据，添加缓冲功能 } // 其他相关的重写方法 }

FilterInputStream：抽象装饰器类，它继承了InputStream，并且持有一个InputStream的引用，装饰器类通过持有的这个引用来增强对象的功能。

BufferedInputStream：具体的装饰器类，通过为InputStream添加缓冲功能提高读取效率。

public class FileInputStream extends InputStream { // 打开文件并创建文件输入流 public FileInputStream(String name) throws FileNotFoundException { this(name != null ? new File(name) : null); } // 其他相关代码... } // 客户端使用 public class DecoratorTest { public static void main(String[] args) throws IOException { InputStream fileStream = new FileInputStream("data.txt"); // 用 BufferedInputStream 装饰 FileInputStream，增加缓冲功能 InputStream bufferedStream = new BufferedInputStream(fileStream); int data = bufferedStream.read(); // 读取数据 while (data != -1) { System.out.print((char) data); data = bufferedStream.read(); } bufferedStream.close(); } } 

在这个例子中，FileInputStream是一个具体的输入流，而BufferedInputStream是装饰器，增加了缓冲功能。客户端可以通过组合来增强输入流的功能，而不必修改原始的FileInputStream类。

2、DataInputStream 是 InputStream 的装饰器

DataInputStream 是另一个经典的装饰器，它允许从输入流中读取基本数据类型（如int、float等）。

// java.io.DataInputStream 源码片段 public class DataInputStream extends FilterInputStream implements DataInput { public DataInputStream(InputStream in) { super(in); // 调用装饰的 InputStream } // 读取一个 int 数据 public final int readInt() throws IOException { int ch1 = in.read(); int ch2 = in.read(); int ch3 = in.read(); int ch4 = in.read(); if ((ch1 | ch2 | ch3 | ch4) < 0) throw new EOFException(); return ((ch1 << 24) + (ch2 << 16) + (ch3 << 8) + (ch4 << 0)); } // 其他相关的读取方法 } 

在这个例子中，DataInputStream装饰了一个InputStream，并且扩展了功能，支持读取基本数据类型。

public class DecoratorTest { public static void main(String[] args) throws IOException { InputStream fileStream = new FileInputStream("data.bin"); // 使用 BufferedInputStream 增加缓冲功能 InputStream bufferedStream = new BufferedInputStream(fileStream); // 使用 DataInputStream 增加读取基本数据类型的功能 DataInputStream dataStream = new DataInputStream(bufferedStream); int number = dataStream.readInt(); // 从文件中读取一个 int 值 System.out.println("Read integer: " + number); dataStream.close(); } } 

在这个例子中，DataInputStream为InputStream增加了读取基本数据类型的功能。通过使用BufferedInputStream和DataInputStream的组合，客户端可以获得既有缓冲功能，又可以读取基本数据类型的输入流。

3、PrintStream 和 PrintWriter 也是装饰器

PrintStream 和 PrintWriter 是对输出流的装饰器，它们添加了打印方法，比如print()和println()，使得输出流可以方便地输出字符串、对象等数据。

public class PrintStream extends FilterOutputStream implements Appendable, Closeable { // 构造函数接受 OutputStream 作为参数 public PrintStream(OutputStream out) { super(out); // 调用 FilterOutputStream 构造方法 } public void println(String x) { synchronized (this) { print(x); newLine(); } } // 其他相关代码... }

在Java I/O类库中，装饰器模式通过扩展InputStream和OutputStream的功能而被广泛使用。

BufferedInputStream、DataInputStream、PrintStream等类都是装饰器，它们在不改变底层流的情况下增加了缓冲、数据类型处理和打印等功能。

通过装饰器模式，Java I/O类库实现了灵活的功能扩展，并且使用者可以根据需求动态组合这些装饰器。

4、除了I/O流之外，Java中的装饰器模式也被应用在其他场景中：

（1）Java的集合类包装器

Collections.synchronizedList()、Collections.unmodifiableList()等方法实际上是对集合进行包装，动态为集合对象增加线程安全或不可修改的特性。

（2）java.util.logging.Logger

日志框架中的Logger类允许通过装饰器为日志添加各种处理行为，例如格式化输出、发送到不同的目的地（控制台、文件、远程服务器等）。

八、总结

装饰器模式在JDK源码中的典型应用主要体现在I/O流的设计中。通过装饰器模式，Java的InputStream和OutputStream类可以在不修改原始类的情况下动态扩展功能。例如，BufferedInputStream和DataInputStream分别为基础流增加了缓冲读取和读取基本数据类型的能力，而PrintStream为输出流提供了打印字符串、对象等的便捷方法。

装饰器模式允许开发者通过组合多个装饰器类，为对象添加不同的功能，避免了创建大量子类的复杂性。例如，BufferedInputStream可以与FileInputStream组合使用，为文件输入流增加缓冲，提升读取效率。这种模式不仅灵活，还使代码复用性和扩展性大幅提升。

此外，装饰器模式还广泛应用于Java集合类和日志系统等场景，像Collections.synchronizedList()、Collections.unmodifiableList()等都通过装饰器动态增加线程安全或不可修改的特性。装饰器模式通过其灵活的结构设计，实现了功能增强与解耦的目的，是Java开发中的常见设计模式。