在软件开发过程中，有时想用一些现存的组件。这些组件可能只是完成了一些核心功能。但在不改变其结构的情况下，可以动态地扩展其功能。所有这些都可以釆用装饰模式来实现。

一、装饰器模式

1、装饰器模式的定义

装饰器模式（Decorator Pattern），又叫作包装器模式（Wrapper Pattern）：

指在不改变原有对象结构的基础情况下，动态地给该对象增加一些额外功能的职责。装饰器模式相比生成子类更加灵活。它属于对象结构型模式。

装饰模式和代理模式的功能是雷同的，两者区别是：

• 装饰器模式强调自身功能的扩展，是代理模式的一个特殊应用。
• 代理模式强调对代理过程的控制。

2、装饰器模式的结构

通常情况下，扩展一个类的功能会使用继承方式来实现。但继承具有静态特征，耦合度高，并且随着扩展功能的增多，子类会很膨胀。
如果使用组合关系来创建一个包装对象（即装饰对象）来包裹真实对象，并在保持真实对象的类结构不变的前提下，为其提供额外的功能，这就是装饰模式的目标。

下面来分析其基本结构和实现方法。

（1）模式的结构

装饰模式主要包含四个角色。

• 抽象构件（Component）： 可以是一个接口或者抽象类，充当被装饰类的原始对象，规定了被装饰类的行为。
• 具体构件（ConcreteComponent）： 实现/继承 Component的一个具体对象，即被装饰对象。通过装饰角色为其添加一些职责。
• 抽象装饰器（Decorator）： 实现/继承 Component。通用的 ConcreteComponent的装饰列，其内部必然有一个属性指向 Component，主要是可以通过其子类扩展具体组件的功能。
• 具体装饰器（ConcreteDecorator）： Decorator的具体实现类，并给具体构件对象添加附加的责任，一般为其特有的功能。

装饰器模式j角色分配符合设计模式的里氏替换原则、依赖倒置原则，从而使得其具备很强的扩展性，最终满足开闭原则。

（2）结构图如下：(图来自网络)

3、优缺点

主要优点：

• 装饰器是继承的有力补充，比继承灵活，在不改变原有对象的情况下，动态的给一个对象扩展功能，即插即用
• 通过使用不用装饰类及这些装饰类的排列组合，可以实现不同效果
• 装饰器模式完全遵守开闭原则

主要缺点：

• 会出现更多的代码、更多的类，增加程序的复杂性。

4、使用场景

• 当需要给一个现有类添加附加职责，而又不能采用生成子类的方法进行扩充时。
• 当对象的功能要求可以动态地添加，也可以再动态地被撤销时。
• 当需要通过对现有的一组基本功能进行排列组合而产生非常多的功能时，采用继承关系很难实现，而采用装饰模式却很好实现。

在框架源码中使用也很广泛，比如：

• JDK中的处理流 IO中包装流类等
• Spring 中处理事务缓存的 TransactionAwareCacheDecorator类
• Mybatis 中处理缓存设计的 Cache类等

二、模式的通用实现

代码如下：

public class DecoratorPattern {
    public static void main(String[] args) {
        Component p = new ConcreteComponent();
        p.operation();
        System.out.println("---------------装饰之后------------------");
        Component d = new ConcreteDecorator(p);
        d.operation();
    }
}

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

//具体构件
class ConcreteComponent implements Component {
    public ConcreteComponent() {
        System.out.println("创建具体构件角色");
    }

    // 相应的功能处理
    @Override
    public void operation() {
        System.out.println("调用具体构件角色的方法operation()");
    }
}

//抽象装饰器
class Decorator implements Component {
    // 持有的组件对象
    private Component component;

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

    @Override
    public void operation() {
        // 处理前后可以加一些附加功能
        component.operation();
    }
}

//具体装饰器
class ConcreteDecorator extends Decorator {
    public ConcreteDecorator(Component component) {
        super(component);
    }

    @Override
    public void operation() {
        // 在处理父类的方法时，可以在处理前后可以加一些附加功能
        // 如果不调用父类的方法，表示完全改写方法，实现新功能
        super.operation();
        addedFunction();
    }

    public void addedFunction() {
        System.out.println("为具体构件角色增加额外的功能addedFunction()");
    }
}

三、模式的应用实例

用一个卖煎饼果子的例子来说明。

• 原味版：煎饼果子，总价格：5
• 豪华版：辅料可自由搭配

1、抽象构件（Component）

public abstract class Battercake {

    protected abstract  String  getMessage();

    protected abstract int getPrice();
}

2、具体构件（ConcreteComponent）

public class BaseBattercake extends Battercake{

    @Override
    protected String getMessage() {
        return "煎饼果子";
    }

    @Override
    protected int getPrice() {
        return 5;
    }
}

3、抽象装饰器（Decorator）

public abstract class BattercakeDecorator extends Battercake{
    // 静态代理，委托
    private Battercake battercake;

    public BattercakeDecorator(Battercake battercake) {
        this.battercake = battercake;
    }

    @Override
    protected String getMessage() {
        return this.battercake.getMessage();
    }

    @Override
    protected int getPrice() {
        return this.battercake.getPrice();
    }

    // 可以加额外功能方法
    protected abstract void addedFunction();
}

4、具体装饰器（ConcreteDecorator）
这里给定三种辅料可供选择

• 鸡蛋

public class EggDecorator extends BattercakeDecorator {

    public EggDecorator(Battercake battercake) {
        super(battercake);
    }

    @Override
    protected String getMessage() {
        return super.getMessage() + " + 1个鸡蛋";
    }

    @Override
    protected int getPrice() {
        return super.getPrice() + 2;
    }

    @Override
    protected void addedFunction() {

    }

    // 可以加其特有的功能方法
}

• 香肠

public class SausageDecorator extends BattercakeDecorator{

    public SausageDecorator(Battercake battercake) {
        super(battercake);
    }

    @Override
    protected String getMessage() {
        return super.getMessage() + " + 一个香肠";
    }

    @Override
    protected int getPrice() {
        return super.getPrice() + 4;
    }

    @Override
    protected void addedFunction() {

    }
    // 可以加其特有的功能方法
}

• 另类

public class OtherDecorator extends BattercakeDecorator{
    public OtherDecorator(Battercake battercake) {
        super(battercake);
    }

    @Override
    protected String getMessage() {
        return message();
    }

    @Override
    protected int getPrice() {
        return price();
    }

    @Override
    protected void addedFunction() {

    }

    // 可以加其特有的功能方法
    private String message(){
        return "老板，啥也不要，来根大葱";
    }
    private int price(){
        return 5;
    }
}

5、测试

在public class Test {
    public static void main(String[] args) {
        System.out.println("===来一个基础版煎饼果子===");
        Battercake battercake = new BaseBattercake();
        System.out.println(battercake.getMessage() + "，总价格：" + battercake.getPrice() + "元。");

        System.out.println("===来一个套餐A煎饼果子===");
        battercake = new EggDecorator(battercake);
        System.out.println(battercake.getMessage() + "，总价格：" + battercake.getPrice() + "元。");

        System.out.println("===来一个套餐A+B煎饼果子===");
        battercake = new SausageDecorator(battercake);
        System.out.println(battercake.getMessage() + "，总价格：" + battercake.getPrice() + "元。");


        System.out.println("===屌丝买煎饼果子===");
        Battercake battercake2 = new BaseBattercake();
        battercake2 = new OtherDecorator(battercake2);
        System.out.println(battercake2.getMessage() + "，总价格：" + battercake2.getPrice() + "元。");
    }
}

四、装饰模式的扩展

装饰模式所包含的 4 个角色不是任何时候都要存在的，在有些应用环境下模式是可以简化的，有时候抽象装饰器是可有可无的，如以下两种情况。（图来自网络）

1、只有一个具体装饰器，这样就不需要抽象装饰器，其结构图如下：

2、只有一个具体构件，这样就不需要抽象构件，抽象装饰者可以直接继承具体构件，其结构图如下：

3、只有一个具体构件和一个具体装饰者，这样抽象角色都不需要了，具体装饰者直接继承集体构件就可以了

参考文章：

• 设计模式：http://c.biancheng.net/view/1366.html
• 装饰者模式：https://www.cnblogs.com/mingmingcome/p/9798248.html

—— Stay Hungry. Stay Foolish. 求知若饥，虚心若愚。

什么是装饰器模式

装饰器模式从字面意思来说就是对某一个事物进行装饰的一种模式。从代码层面而言，是对类的一个扩展或者是修饰，从传统方法而言，我们可以使用继承来对某一个类进行扩展，但是往往会导致会出现非常多的子类，如果我们要想避免这种情况，那么我们就可以使用设计模式中的——装饰器模式。

装饰器模式的优缺点

装饰器模式是在不改变现有对象结构的情况下，动态地给该对象增加一些职责，即增加其额外功能。

但是如果对于一个类型装饰的类的扩展功能太多，那么将会导致有很多的小类，我们在选择使用装饰器设计模式的时候要根据实际情况进行选择。

案例

定义一个Person接口，定义两个方法 getRole 和 getAge，创建三个实体类（Father、Mother、Son）实现（implements）Person 接口。定义一个装饰类 继承（extends）Person，并设置私有的成员变量Person，创建一个特定的装饰修饰类（PersonMaleDecorator）设置成员为男性。

Person

public class PersonDecorator implements Person {

    private Person person;

    public PersonDecorator(Person person) {
        this.person = person;
    }

    @Override
    public void getRole() {

        person.getRole();
    }

    @Override
    public void getAge() {

        person.getAge();
    }
}

Father

public class Father implements Person {
    @Override
    public void getRole() {
        System.out.println("role : father");
    }

    @Override
    public void getAge() {
        System.out.println("father age : 38 years");
    }
}

Mother

public class Mother implements Person {
    @Override
    public void getRole() {
        System.out.println("role : mother");
    }

    @Override
    public void getAge() {
        System.out.println("mather age : 35 years");
    }
}

Son

public class Son implements  Person {
    @Override
    public void getRole() {
        System.out.println("role : son");
    }

    @Override
    public void getAge() {
        System.out.println("son age : 7 years");
    }
}

PersonDecorator

public class PersonDecorator implements Person {

    private Person person;

    public PersonDecorator(Person person) {
        this.person = person;
    }

    @Override
    public void getRole() {

        person.getRole();
    }

    @Override
    public void getAge() {

        person.getAge();
    }
}

PersonMaleDecorator

public class PersonMaleDecorator extends PersonDecorator {
    public PersonMaleDecorator(Person person) {
        super(person);
    }

    @Override
    public void getRole() {
        super.getRole();
        this.setGender();
    }

    @Override
    public void getAge() {
        super.getAge();
    }

    private void setGender(){
        System.out.println("Ta is male");
    }
}

main

public class DecoratorDemo {
    public static void main(String[] args) {
        Mother mother = new Mother();

        PersonMaleDecorator father = new PersonMaleDecorator(new Father());
        PersonMaleDecorator son = new PersonMaleDecorator(new Son());

        mother.getRole();
        mother.getAge();
        System.out.println("-------------------------");

        father.getRole();
        father.getAge();
        System.out.println("-------------------------");

        son.getRole();
        son.getAge();
    }
}

结果：

role : mother
mather age : 35 years
-------------------------
role : father
Ta is male
father age : 38 years
-------------------------
role : son
Ta is male
son age : 7 years

前言

装饰器模式也叫做包装器模式，属于结构性设计模式一种，装饰器设计模式在实际的生活中也有很多体现，举例来说，某手机厂商发布了XXX标准版手机，为了吸引用户眼球，提升销量，还特别有纪念碑，青春版，至尊版等

我们可以这么设想，不管是哪个版本的手机，其基本的功能是不变的，电话、短信、拍照等这些基础的功能在各个版本都能找到

但是不同的版本，基于某个基础的版本，根据标价的不同添加了更多定制化或个性化的功能，相当于是说丰富了标准版的功能

• 装饰器模式作为现有类的一个包装，允许向现有的对象添加注入新的功能，同时还不改变原有的结构
• 给基础对象添加功能，一般有2种方式，继承或关联组合，将一个类的对象嵌入到另一个对象中，由另一个对象来决定是否调用嵌入对象的行为来增强功能，这个就是装饰器模式，相比继承更加灵活

在JDK源码里面使用最多的就是IO流，大量使用到了装饰器设计模式

装饰器设计模式的简易结构图如下所示：

对上图中各个组件的作用做简单的解释：

• 角色：(装饰者和被装饰者具有相同的超类(可以理解为接口))
• 抽象组件：定义装饰器方法的规范，比如手机，仅定义了打电话，发短信功能
• 被装饰者：Component的具体实现，也就是我们即将要装饰的具体对象，实现了接口中的方法，比如打电话，发短信
• 装饰者组件：定义了具体装饰者的行为规范，和Component角色具有相同的接口，并持有组件(Component)对象实例的引用，即其他版本的手机都有打电话和短信的功能
• 具体装饰物：负责给基础组件添加新的功能，比如在电话和短信基础上定制了视频通话功能

代码演示

定义基本的接口

public interface Phone {
    String desc();
    int getPrice();
}

具体的被装饰类的实现，以手机为例，这里提供标准版手机，普通版和高配版

StandardPhone

public class StandardPhone implements Phone{

    private String desc = "标准版手机";

    @Override
    public String desc() {
        return desc;
    }

    @Override
    public int getPrice() {
        return 1000;
    }

}

MiddlePhone

public class MiddlePhone implements Phone{

    private String desc = "普通版手机";

    @Override
    public String desc() {
        return desc;
    }

    @Override
    public int getPrice() {
        return 1500;
    }
}

HighLevelPhone

public class HighLevelPhone implements Phone{

    private String desc = "尊贵版手机";

    @Override
    public String desc() {
        return desc;
    }

    @Override
    public int getPrice() {
        return 2500;
    }
}

手机装饰器：

装饰器在这里起到一个中间层作用，方便后面的扩展，具体的装饰实现延迟到子类中

public class PhoneDecorator implements Phone {

    private String desc = "这是装饰器";

    @Override
    public String desc() {
        return desc;
    }

    @Override
    public int getPrice() {
        return 0;
    }

}

添加了视频通话的装饰器类

public class VideoDecorator extends PhoneDecorator{

    private String desc = "增加一个视频通话功能";

    private int videoPrice = 500;

    private Phone phone;

    public VideoDecorator(Phone phone){
        this.phone=phone;
    }

    @Override
    public String desc() {
        return phone.desc() + "," + desc;
    }

    @Override
    public int getPrice() {
        return phone.getPrice() + videoPrice;
    }

}

增加了wifi充电功能的装饰器类

public class WifiChargeDecorator extends PhoneDecorator {

    private String desc = "增加一个wifi充电功能";

    private int wifiAddProce = 800;

    private Phone phone;

    public WifiChargeDecorator(Phone phone){
        this.phone=phone;
    }

    @Override
    public String desc() {
        return phone.desc() + "," + desc;
    }

    @Override
    public int getPrice() {
        return phone.getPrice() + wifiAddProce;
    }
}

新增的手机的附加功能可以通过多个装饰类实现，方便客户端调用时自由选择，如果有更多的装饰类，可以按照上面的方式继续添加

下面来简单测试下，

1、获取一个普通版手机

public static void main(String[] args) {
        /**
         * 基础测试
         */
        Phone phone = new MiddlePhone();
        System.out.println(phone.desc() + " --- " + phone.getPrice());
    }

2、在普通版手机基础上增加视频通话功能

public static void main(String[] args) {
        /**
         * 基础测试
         */
        Phone phone = new MiddlePhone();
        System.out.println(phone.desc() + " --- " + phone.getPrice());
        System.out.println();
        /**
         * 增加视频通话功能
         */
        phone = new VideoDecorator(phone);
        System.out.println(phone.desc() + " --- " + phone.getPrice());
    }

3、在普通版手机基础上继续增加wifi充电功能

public static void main(String[] args) {
        /**
         * 基础测试
         */
        Phone phone = new MiddlePhone();
        System.out.println(phone.desc() + " --- " + phone.getPrice());
        System.out.println();
        /**
         * 增加视频通话功能
         */
        phone = new VideoDecorator(phone);
        System.out.println(phone.desc() + " --- " + phone.getPrice());
        System.out.println();

        /**
         * 增加wifi充电功能
         */
        phone = new WifiChargeDecorator(phone);
        System.out.println(phone.desc() + " --- " + phone.getPrice());
    }

通过上面的代码演示，可以清楚的看到，使用装饰器模式可以很灵活的对既有的基础组件对象持有的功能进行补充和扩展，可以根据自身的业务诉求进行自由搭配

装饰器设计模式，优点：

• 装饰模式与继承关系的目的都是要扩展原有对象的功能，但是装饰器模式比继承增加了更多的灵活性
• 使用不同的具体装饰类以及这些装饰类的排列组合，可以创造出更多的不同行为的组合，原有的代码无需改变，符合“开闭”原则

缺点：

• 装饰器模式添加了许多子类，过多使用会使程序变得很复杂
• 增加了系统的复杂程度，加大了使用者的学习成本和理解难度

在JDK源码中的应用

IO流的读取与写入在JDK源码中大量使用到了装饰器模式，简单来说，按照装饰器模式下其组件的划分，可以总结如下：

• 抽象组件：(Component):Inputstream，定义了装饰方法的规范
• 被装饰者：(ConcreteComponent)：FileInputStream,ByteArrayInputStream,Component的具体实现，也就是要装饰的具体对象
• 装饰者组件：(Decorator)：FileInputStream，定义装饰者行为规范，和Component具有相同接口，持有对象组件（Component）的实例引用
• 具体装饰物：（ConcreteDecorator）BufferedInputStream，DataInputStream，负责给构件对象添加额外的功能

下面来看一下DataInputStream和DataOutputStream的类结构图，可以发现它们的顶层实现了InputStream或者OutputStream

一个具体的实现案例

public static void main(String[] args) throws IOException {
        DataInputStream in = new DataInputStream(new FileInputStream("D:\\test.txt"));
        DataOutputStream out = new DataOutputStream(new FileOutputStream("D:\\test1.txt"));
        BufferedReader d = new BufferedReader(new InputStreamReader(in));
        String count;
        while ((count = d.readLine()) != null) {
            String u = count.toUpperCase();
            System.out.println(u);
            out.writeBytes(u + "  ,");
        }
        d.close();
        out.close();
    }

本篇通过实例演示并说明了装饰器设计模式的使用，可以结合自身的业务使用装饰器模式对代码进行优化和改进，本篇到此结束，最后感谢观看！