设计模式详解（七）：装饰器模式——Decorator

装饰器模式及其作用

装饰器模式是一种结构型设计模式。所谓结构型是指在代码结构设计方面的设计模式。装饰器模式又称包装器模式，通过将对象包装在装饰器中来动态地增强其功能。这种模式通过组合多个对象来实现这一目标，而不是通过继承来实现。装饰器模式能够在不改变对象功能接口的情况下，增强新功能。

装饰器和原有对象实现了共同的功能接口，在调用功能方法时，将请求委托给被包装者的同名方法，并可在委托执行的前后做一些工作，以添加新的功能特性。装饰器间可以互相嵌套，对外界来说，调用得始终是“一个”对象，并不清楚内部包裹了多少层，以及包裹了怎样的对象。

实战举例

假如，我们要开发一个打印机功能。
初始阶段，业务相对简单，我们将打印机功能抽象成Printer类，通过print方法把输入的信息打印到控制台。

public class Pinter {
    public void print(String info) {
        System.out.println(info);
    }
}

运行测试代码，

    public static void main(String[] args) {
        Printer printer = new Printer();
        printer.print("I'm Vincent.");
    }

效果如下，

I'm Vincent.

后来，我们想增强打印功能，在打印文本的前后各插入一行星号。如何通过装饰器实现？

第一步，
将Printer 类需要装饰（增强）的功能抽象成Printable接口，且令Printer类实现该接口。

public interface Printable{
    void print(String info);
}

public class Printer implements Printable {
    @Override
    public void print(String info) {
        System.out.println(info);
    }
}

第二步，
定义装饰器类StarPrinterDecorator ，并实现Printable接口。
装饰器内持有一个Printable类型的成员变量，存储被装饰的对象。

public class StarPrinterDecorator implements Printable {
    //持有被装饰的对象
    private Printable delegator;
    
    //构造器传入被装饰的对象
    public StarPrinterDecorator(Printable printable) {
        this.delegator = printable;
    }
    //把功能委托给被装饰的对象，并在其执行前后加入了新特性，完成了装饰
    @Override
    public void print(String info) {
        System.out.println("****************");
        delegator.print(info);
        System.out.println("****************");
    }
}

运行测试代码，

    public static void main(String[] args) {
        Printable printer = new StarPrinterDecorator(new Printer());
        printer.print("I'm Vincent.");
    }

效果如下，

****************
I'm Vincent.
****************

注意上面的代码，声明变量时是Printable类型，从使用者的视角来看，永远面对的是“一个”对象，一个可以调用print方法打印信息的对象，并不关心其实现。

后来有一天，我们又接到需求变更：在打印结束后打印时间戳。显然，我们需要再次创建一个时间戳装饰器。

public class TimestampPrinterDecorator implements Printable {
    private Printable delegator;

    public TimestampPrinterDecorator(Printable delegator) {
        this.delegator = delegator;
    }

    @Override
    public void print(String info) {
        if (delegator != null) {
            //先委托给被装饰的对象
            delegator.print(info);
        }
        //加入新特性，打印时间戳
        String timestamp = SimpleDateFormat.getDateTimeInstance().format(new Date());
        System.out.println(timestamp);
    }
}

运行测试代码，

    public static void main(String[] args) {
        Printable printer = new TimestampPrinterDecorator(new StarPrinterDecorator(new Printer()));
        printer.print("I'm Vincent.");
    }

效果如下，

****************
I'm Vincent.
****************
May 31, 2024, 4:50:43 PM

随着时间的推移，业务逐渐复杂，需要的打印功能也花样繁多，我们可以对现有的装饰器自由嵌套，实现不同的功能。

    //只打印时间戳，不打印星号
    public static void main(String[] args) {
        Printable printer = new TimestampPrinterDecorator(new Printer());
        printer.print("I'm Vincent.");
    }

    //只打印星号，不打印时间戳
    public static void main(String[] args) {
        Printable printer = new StarPrinterDecorator(new Printer());
        printer.print("I'm Vincent.");
    }

我们随时可以增加一种新的装饰器，并专注于新特性，而不用考虑其他装饰器的功能，对于某个装饰器来说，我包裹的是一个Printable对象，并不清楚也没必要知道其内部是一个单独的对象，还是嵌套了多个对象以及嵌套了什么样的对象。

另外，上面的基础类Printer有可能是第三方类库，我们无法修改其代码，令其实现抽离出的功能接口，或者我们虽然能修改它，
出于风险考虑，不打算改动它的代码。这时候我们可以创建一个新类，内部持有Printer，令其实现抽离出的功能接口，print方法直接委托给Printer类。

不改动Printer类，

public class Printer {
    public void print(String info) {
        System.out.println(info);
    }
}

创建一个新类，内部持有Printer，

public class WrappedPrinter implements Printable {
    private Printer printer = new Printer();

    @Override
    public void print(String info) {
        printer.print(info);
    }
}

    public static void main(String[] args) {
        Printable printer = new TimestampPrinterDecorator(new StarPrinterDecorator(new WrappedPrinter()));
        printer.print("I'm Vincent.");
    }

装饰器的好处

• 代码复用和简化： 装饰器可以用来包装一些通用的功能，比如日志记录、性能检测、权限验证等，这样可以避免在每个函数内部重复编写相同的代码，提高了代码的复用性和可维护性。

• 分离关注点： 装饰器可以把不同关注点的代码分开，使得每个函数可以专注于解决特定的问题，增强了代码的模块化和可读性。

• 动态修改行为： 装饰器可以在运行时动态地修改函数或类的行为，比如在不修改原函数代码的情况下，给函数添加额外的功能或修改其行为。

• 代码简洁性： 使用装饰器可以使代码更加简洁明了，减少了嵌套和重复代码，使得代码更具表达力。

• 可插拔性和灵活性： 装饰器可以根据需要轻松地添加或删除功能，使得代码更具可扩展性和灵活性，方便进行功能的组合和配置。