【设计模式】Java 设计模式之装饰者模式（Decorator）

最新推荐文章于 2024-09-26 21:53:35 发布

新手村长

最新推荐文章于 2024-09-26 21:53:35 发布

阅读量1.7k

点赞数 16

分类专栏： Java 设计模式文章标签：设计模式 java 装饰器模式

本文链接：https://blog.csdn.net/cbz6210499/article/details/136731688

版权

Java 设计模式专栏收录该内容

22 篇文章 7 订阅

订阅专栏

装饰者模式讲解

一、概述

装饰者模式（Decorator Pattern）是一种用于动态地给一个对象添加一些额外的职责的设计模式。就增加功能来说，装饰者模式相比生成子类更为灵活。装饰者模式是一种对象结构型模式。

装饰者模式可以在不改变一个对象本身功能的基础上增强其功能，通过采用组合而非继承的方式，实现了在运行时动态地扩展一个对象的功能。装饰者模式提供了一种比继承更加灵活的方式来扩展一个对象的功能。

二、模式结构

装饰者模式包含以下角色：

抽象构件（Component）角色：定义一个抽象接口以规范准备接收附加责任的对象。
具体构件（ConcreteComponent）角色：实现抽象构件，具体到某一个对象。
装饰（Decorator）角色：持有一个指向抽象构件的引用并继承抽象构件的接口。
具体装饰（ConcreteDecorator）角色：实现装饰角色，负责为构件对象“贴上”附加的责任。

三、实现方式及代码示例

以下是一个简单的装饰者模式的实现代码示例：

// 抽象构件角色
public interface Component {
    void operation();
}

// 具体构件角色
public class ConcreteComponent implements Component {
    @Override
    public void operation() {
        System.out.println("执行具体构件对象的操作");
    }
}

// 装饰角色
public class Decorator implements Component {
    protected Component component;

    public Decorator(Component component) {
        this.component = component;
    }

    @Override
    public void operation() {
        if (component != null) {
            component.operation();
        }
    }
}

// 具体装饰角色A
public class ConcreteDecoratorA extends Decorator {
    public ConcreteDecoratorA(Component component) {
        super(component);
    }

    @Override
    public void operation() {
        super.operation();
        addedFunctionA();
    }

    public void addedFunctionA() {
        System.out.println("为构件对象添加功能A");
    }
}

// 具体装饰角色B
public class ConcreteDecoratorB extends Decorator {
    public ConcreteDecoratorB(Component component) {
        super(component);
    }

    @Override
    public void operation() {
        super.operation();
        addedFunctionB();
    }

    public void addedFunctionB() {
        System.out.println("为构件对象添加功能B");
    }
}

使用装饰者模式的客户端代码示例：

public class Client {
    public static void main(String[] args) {
        Component component = new ConcreteComponent();
        
        // 使用装饰者A增强功能
        component = new ConcreteDecoratorA(component);
        
        // 使用装饰者B进一步增强功能
        component = new ConcreteDecoratorB(component);
        
        // 执行操作，会依次调用ConcreteComponent的operation、ConcreteDecoratorA的addedFunctionA、ConcreteDecoratorB的addedFunctionB
        component.operation();
    }
}

四、优缺点分析

优点：

装饰者模式可以使被装饰的类的具体子类实现不同的行为，创建出不同行为的组合。
装饰者模式可以动态地扩展一个对象的功能，通过在运行时使用不同的装饰器，可以增加由基本组件提供的功能。
装饰者模式提供了比继承更加灵活的替代方案，因为装饰者模式允许系统在不修改现有类的情况下引入新的行为。

缺点：

使用装饰者模式会增加许多子类，过度使用会增加程序的复杂性。
装饰者模式可能会导致设计出现过多的具体装饰类，如果过度使用会使程序变得很庞大。

五、常见应用场景

需要扩展一个类的功能，或给一个类增加附加职责。
需要动态地给一个对象增加一些职责。
需要为一组对象动态地增加新的行为。

六、实际应用案例解读

以Java的I/O流为例，Java I/O库的设计就使用了装饰者模式。基本的I/O流类，如InputStream、OutputStream等，提供了基本的读写功能。然而，Java I/O库还提供了许多装饰器类，如BufferedInputStream、DataInputStream等，它们可以包装基本的I/O流对象，为其添加额外的功能，如缓冲读取或按特定格式读取数据。这样，用户可以根据需要组合不同的装饰器，灵活地构建出满足特定需求的I/O流。

例如，如果需要从一个文件中读取数据，并且希望这些数据以特定的格式解析，就可以使用装饰者模式来构建一个满足需求的I/O流。首先，可以创建一个基本的FileInputStream对象来读取文件内容。然后，可以使用一个DataInputStream对象来包装这个FileInputStream对象，以便按特定格式（如基本数据类型）读取数据。如果还需要对数据进行缓冲以提高读取效率，可以再使用一个BufferedInputStream对象来包装DataInputStream对象。这样，通过组合不同的装饰者，就可以实现复杂的I/O操作。

以下是一个使用装饰者模式进行文件读取的简单示例：

import java.io.*;

public class IODecoratorExample {
    public static void main(String[] args) {
        try {
            // 创建一个基本的文件输入流
            InputStream fileInputStream = new FileInputStream("example.txt");
            
            // 使用DataInputStream装饰器，以便按特定格式读取数据
            InputStream dataInputStream = new DataInputStream(fileInputStream);
            
            // 使用BufferedInputStream装饰器，以便进行缓冲读取
            InputStream bufferedInputStream = new BufferedInputStream(dataInputStream);
            
            // 读取数据
            int value = bufferedInputStream.read();
            System.out.println("读取到的值: " + value);
            
            // 关闭流
            bufferedInputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，FileInputStream是具体的构件对象，而DataInputStream和BufferedInputStream是装饰者对象，它们分别给FileInputStream添加了按特定格式读取和缓冲读取的功能。通过组合这些装饰者，我们得到了一个功能更强大的输入流对象。

总结来说，装饰者模式是一种非常灵活的设计模式，它允许我们在不修改现有类的情况下动态地给对象添加新的职责。通过组合不同的装饰者，我们可以构建出满足各种复杂需求的对象。在Java I/O库中，装饰者模式的应用就是一个很好的例子，它使得I/O操作变得更加灵活和高效。

在实际应用中，装饰者模式的应用不仅限于I/O流。它还可以用于许多其他场景，例如GUI组件的定制、服务功能的扩展等。以下是一个GUI组件定制的应用案例。

假设我们正在开发一个图形用户界面（GUI）应用程序，其中有一个基本的按钮（Button）组件。这个按钮组件可以执行一些基本的操作，如点击事件的处理。然而，我们可能希望为这个按钮添加一些额外的功能或样式，比如显示一个图标、改变字体样式或颜色等。

为了支持这种定制，我们可以使用装饰者模式。首先，我们定义一个抽象的按钮组件接口，然后创建一个具体的按钮实现类。接下来，我们创建一系列装饰器类，每个装饰器类都包装一个按钮组件并添加额外的功能。

// 抽象按钮组件接口
public interface Button {
    void onClick();
    void display();
}

// 具体按钮实现类
public class SimpleButton implements Button {
    @Override
    public void onClick() {
        System.out.println("按钮被点击了");
    }

    @Override
    public void display() {
        System.out.println("显示基本按钮");
    }
}

// 装饰器抽象类
public abstract class ButtonDecorator implements Button {
    protected Button button;

    public ButtonDecorator(Button button) {
        this.button = button;
    }

    @Override
    public void onClick() {
        button.onClick();
    }

    @Override
    public void display() {
        button.display();
    }
}

// 添加图标的装饰器类
public class IconButtonDecorator extends ButtonDecorator {
    public IconButtonDecorator(Button button) {
        super(button);
    }

    @Override
    public void display() {
        super.display();
        System.out.println("显示带有图标的按钮");
    }
}

// 改变字体样式的装饰器类
public class StyledButtonDecorator extends ButtonDecorator {
    public StyledButtonDecorator(Button button) {
        super(button);
    }

    @Override
    public void display() {
        super.display();
        System.out.println("以特定样式显示按钮");
    }
}

使用这些装饰器，我们可以创建具有不同功能的按钮：

public class GUIApplication {
    public static void main(String[] args) {
        Button basicButton = new SimpleButton();
        
        // 创建一个带有图标的按钮
        Button iconButton = new IconButtonDecorator(basicButton);
        
        // 创建一个既带有图标又改变字体样式的按钮
        Button styledIconButton = new StyledButtonDecorator(iconButton);
        
        // 显示并测试按钮
        styledIconButton.display();
        styledIconButton.onClick();
    }
}

在这个GUI应用案例中，装饰者模式允许我们动态地为按钮添加额外的功能或样式，而无需修改基本的按钮实现类。这使得我们的代码更加灵活和可维护。

总的来说，装饰者模式是一种强大的设计模式，它提供了一种灵活的方式来扩展对象的功能。通过组合不同的装饰者，我们可以构建出功能丰富且易于维护的系统。然而，在使用装饰者模式时，我们也需要注意避免过度使用，以免导致系统变得过于复杂。

继续探讨装饰者模式的应用，我们还可以考虑在更广泛的软件架构中使用它。装饰者模式不仅适用于单个对象的增强，也可以用于构建复杂的软件架构，其中对象或组件可以根据需要动态地组合和扩展。

以下是一个关于在软件架构中使用装饰者模式的更高级别讨论：

服务链与中间件

在服务导向的架构中，装饰者模式可以用于构建服务链或中间件，这些中间件可以为服务调用增加额外的功能，如日志记录、权限检查、事务管理等。每个中间件都可以看作是一个装饰者，它们包装了原始的服务对象，并在调用前后添加自己的逻辑。

public interface Service {
    void execute();
}

public class CoreService implements Service {
    @Override
    public void execute() {
        System.out.println("执行核心服务逻辑");
    }
}

public abstract class ServiceDecorator implements Service {
    protected Service service;

    public ServiceDecorator(Service service) {
        this.service = service;
    }

    @Override
    public void execute() {
        beforeExecute();
        service.execute();
        afterExecute();
    }

    protected abstract void beforeExecute();
    protected abstract void afterExecute();
}

public class LoggingDecorator extends ServiceDecorator {
    public LoggingDecorator(Service service) {
        super(service);
    }

    @Override
    protected void beforeExecute() {
        System.out.println("开始记录日志...");
    }

    @Override
    protected void afterExecute() {
        System.out.println("结束记录日志...");
    }
}

// 类似地，可以创建其他中间件装饰器，如权限检查装饰器、事务管理装饰器等。

使用这些装饰器，我们可以动态地构建服务链：

public class ServiceChainExample {
    public static void main(String[] args) {
        Service coreService = new CoreService();
        Service loggingService = new LoggingDecorator(coreService);
        // 可以继续添加其他装饰器
        
        loggingService.execute(); // 执行时会先记录日志，然后执行核心服务逻辑，最后再记录日志结束
    }
}