装饰模式 | Footprints of Growth

设计模式之装饰模式

定义

装饰模式(Decorator Pattern)：动态地给一个对象增加一些额外的职责，就增加对象功能来说，装饰模式比生成子类实现更为灵活。装饰模式是一种对象结构型模式。

了解

根据“合成复用原则”，在实现功能复用时，我们要多用关联，少用继承, 我们可以将要增强的方法抽取出来，封装在一个独立的类中，在这个类中定义（关联）一个Component类型的对象，通过调用Component的base()方法来实现对象最基本的功能，同时再通过addBehavior()方法对基本构件的功能进行增强；
根据“里氏代换原则”，程序运行过程中，我们只要向这个独立的类（装饰器或装饰类）中注入具体的Component子类的对象即可实现功能的扩展。
装饰模式可以在不改变一个对象本身功能的基础上给对象增加额外的新行为，是一种用于替代继承的技术，它通过一种无须定义子类的方式来给对象动态增加职责，使用对象之间的关联关系取代类之间的继承关系。在装饰模式中引入了装饰类，在装饰类中既可以调用待装饰的原有类的方法，还可以增加新的方法，以扩充原有类的功能。

结构图

为了让系统具有更好的灵活性和可扩展性，通常会定义一个抽象装饰类，而将具体的装饰类作为它的子类。

Component（抽象构件）：它是具体构件和抽象装饰类的共同父类，声明了在具体构件中实现的业务方法，它的引入可以使客户端以一致的方式处理未被装饰的对象以及装饰之后的对象，实现客户端的透明操作。
ConcreteComponent（具体构件）：它是抽象构件类的子类，用于定义具体的构件对象，实现了在抽象构件中声明的方法，装饰器可以给它增加额外的职责（方法）。
Decorator（抽象装饰类）：它也是抽象构件类的子类，用于给具体构件增加职责，但是具体职责在其子类中实现。它维护一个指向抽象构件对象的引用，通过该引用可以调用装饰之前构件对象的方法，并通过其子类扩展该方法，以达到装饰的目的。
ConcreteDecorator（具体装饰类）：它是抽象装饰类的子类，负责向构件添加新的职责。每一个具体装饰类都定义了一些新的行为，它可以调用在抽象装饰类中定义的方法，并可以增加新的方法用以扩充对象的行为。

由于具体构件类和装饰类都实现了相同的抽象构件接口，因此装饰模式以对客户透明的方式动态地给一个对象附加上更多的责任，换言之，客户端并不会觉得对象在装饰前和装饰后有什么不同。

典型代码

// 抽象装饰类
class Decorator implements Component
{
       private Component component;  //维持一个对抽象构件对象的引用

       public Decorator(Component component)  //注入一个抽象构件类型的对象

       {
              this.component=component;
       }

       public void operation()
       {
              component.operation();  //调用原有业务方法
       }
}

在Decorator中并未真正实现operation()方法，而只是调用原有component对象的operation()方法，它没有真正实施装饰，而是提供一个统一的接口，将具体装饰过程交给子类完成。

// 具体装饰类（继承operation()方法并根据需要进行扩展）
class ConcreteDecorator extends Decorator
{
       public ConcreteDecorator(Component  component)

       {
              super(component);
       }

       public void operation()
       {
              super.operation();  //调用原有业务方法
              addedBehavior();  //调用新增业务方法
       }

     //新增业务方法
       public  void addedBehavior()
       {
         ……
	}
}

由于在抽象装饰类Decorator中注入的是Component类型的对象，因此我们可以将一个具体构件对象注入其中，再通过具体装饰类来进行装饰；此外，我们还可以将一个已经装饰过的Decorator子类的对象再注入其中进行多次装饰，从而对原有功能的多次扩展。
子类继承了父类，若父类的构造方法没有重载那么，子类的构造方法也不需要通过super调用父类构造方法。一个类中如果构造方法重写了并且带了参数，那么这个类的原来系统默认的无参构造方法便消失。由此，若一个父类中只有一个带参数的构造方法，那么在写其子类的构造方法时必须先通过super调用父类的构造方法才能完成子类的构造方法而且super只能写在子类构造方法体内的第一行。

示例

如果需要在原有系统中增加一个新的具体构件类或者新的具体装饰类，无须修改现有类库代码，只需将它们分别作为抽象构件类或者抽象装饰类的子类即可。

透明装饰模式与半透明装饰模式

装饰模式虽好，但存在一个问题。如果客户端希望单独调用具体装饰类新增的方法，而不想通过抽象构件中声明的方法来调用新增方法时将有问题。栗子：

//抽象装饰类
class Decorator implements  Document
{
      private Document  document;

      public Decorator(Document  document)

      {
             this.  document = document;
      }

      public void display()
      {
             document.display();
      }
}

//具体装饰类
class Approver extends  Decorator
{
      public Approver(Document document)
      {
             super(document);
             System.out.println("增加审批功能！");
      }

      public void approve()
      {
             System.out.println("审批文件！");
      }
}

Document  doc; //使用抽象构件类型定义
doc = new PurchaseRequest();
Approver newDoc; //使用具体装饰类型定义
newDoc = new Approver(doc);
newDoc.display();//调用原有业务方法
newDoc.approve();//调用新增业务方法

如果newDoc也使用Document类型来定义，将导致客户端无法调用新增业务方法approve()，因为在抽象构件类Document中没有对approve()方法的声明。也就是说，在客户端无法统一对待装饰之前的具体构件对象和装饰之后的构件对象。
在实际使用过程中，由于新增行为可能需要单独调用，因此这种形式的装饰模式也经常出现，这种装饰模式被称为半透明(Semi-transparent)装饰模式，而标准的装饰模式是透明(Transparent)装饰模式。

透明装饰模式

在透明装饰模式中，要求客户端完全针对抽象编程，装饰模式的透明性要求客户端程序不应该将对象声明为具体构件类型或具体装饰类型，而应该全部声明为抽象构件类型。对于客户端而言，具体构件对象和具体装饰对象没有任何区别。

1
2
3

Component  c, c1; //使用抽象构件类型定义对象
c = new ConcreteComponent()；
c1 = new ConcreteDecorator (c)；

……
Component component,componentSB,componentBB; //全部使用抽象构件定义
component = new Window();
componentSB = new ScrollBarDecorator(component);
componentBB = new BlackBorderDecorator(componentSB);
componentBB.display();
……

透明装饰模式可以让客户端透明地使用装饰之前的对象和装饰之后的对象，无须关心它们的区别，此外，还可以对一个已装饰过的对象进行多次装饰，得到更为复杂、功能更为强大的对象。在实现透明装饰模式时，要求具体装饰类的operation()方法覆盖抽象装饰类的operation()方法，除了调用原有对象的operation()外还需要调用新增的addedBehavior()方法来增加新行为

半透明装饰模式

客户端希望单独调用新增的方法时，不得不用具体装饰类型来定义装饰之后的对象，而具体构件类型还是可以使用抽象构件类型来定义，这种装饰模式即为半透明装饰模式，也就是说，对于客户端而言，具体构件类型无须关心，是透明的；但是具体装饰类型必须指定，这是不透明的。

……
Document  doc; //使用抽象构件类型定义
doc = new PurchaseRequest();
Approver newDoc; //使用具体装饰类型定义
newDoc = new Approver(doc);
……

半透明装饰模式可以给系统带来更多的灵活性，设计相对简单，使用起来也非常方便；但是其最大的缺点在于不能实现对同一个对象的多次装饰，而且客户端需要有区别地对待装饰之前的对象和装饰之后的对象。在实现半透明的装饰模式时，我们只需在具体装饰类中增加一个独立的addedBehavior()方法来封装相应的业务处理，由于客户端使用具体装饰类型来定义装饰后的对象，因此可以（直接）单独调用addedBehavior()方法来扩展系统功能。

注意事项

尽量保持装饰类的接口与被装饰类的接口相同，这样，对于客户端而言，无论是装饰之前的对象还是装饰之后的对象都可以一致对待。这也就是说，在可能的情况下，我们应该尽量使用透明装饰模式。
尽量保持具体构件类ConcreteComponent是一个“轻”类，也就是说不要把太多的行为放在具体构件类中，我们可以通过装饰类对其进行扩展。
如果只有一个具体构件类，那么抽象装饰类可以作为该具体构件类的直接子类。栗子：

总结

装饰模式降低了系统的耦合度，可以动态增加或删除对象的职责，并使得需要装饰的具体构件类和具体装饰类可以独立变化，以便增加新的具体构件类和具体装饰类。在软件开发中，装饰模式应用较为广泛，例如在JavaIO中的输入流和输出流的设计、javax.swing包中一些图形界面构件功能的增强等地方都运用了装饰模式。

优点

对于扩展一个对象的功能，装饰模式比继承更加灵活性，不会导致类的个数急剧增加。
可以通过一种动态的方式来扩展一个对象的功能，通过配置文件可以在运行时选择不同的具体装饰类，从而实现不同的行为。
可以对一个对象进行多次装饰，通过使用不同的具体装饰类以及这些装饰类的排列组合，可以创造出很多不同行为的组合，得到功能更为强大的对象。
具体构件类与具体装饰类可以独立变化，用户可以根据需要增加新的具体构件类和具体装饰类，原有类库代码无须改变，符合“开闭原则”。

缺点

使用装饰模式进行系统设计时将产生很多小对象，这些对象的区别在于它们之间相互连接的方式有所不同，而不是它们的类或者属性值有所不同，大量小对象的产生势必会占用更多的系统资源，在一定程序上影响程序的性能。
装饰模式提供了一种比继承更加灵活机动的解决方案，但同时也意味着比继承更加易于出错，排错也很困难，对于多次装饰的对象，调试时寻找错误可能需要逐级排查，较为繁琐。

适用场景

在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。
当不能采用继承的方式对系统进行扩展或者采用继承不利于系统扩展和维护时可以使用装饰模式。不能采用继承的情况主要有两类：第一类是系统中存在大量独立的扩展，为支持每一种扩展或者扩展之间的组合将产生大量的子类，使得子类数目呈爆炸性增长；第二类是因为类已定义为不能被继承（如Java语言中的final类）。

code

/**
 * @author Wangzy
 * @Description: 客户类
 * @date 15:56 2020/1/6
 */
public class Client {

    public static void main(String[] args) {
        Component component = new Window();
        // 装饰（添加滚动条）
        Component scrollBarComponent = new ScrollBarDecorator(component);
        // 二次装饰（添加黑色边框）
        Component scrollBarAndBlackBorderComponent = new BlackBorderDecorator(scrollBarComponent);
//        scrollBarComponent.display();
        scrollBarAndBlackBorderComponent.display();

//        System.out.println(component == scrollBarComponent);
//        System.out.println(scrollBarComponent == scrollBarAndBlackBorderComponent);
    }

}

import javax.swing.plaf.nimbus.AbstractRegionPainter;

/**
 * @author Wangzy
 * @Description: 抽象构件类
 * @date 15:56 2020/1/6
 */
abstract class Component {

    abstract void display();
}

/**
 * @author Wangzy
 * @Description: 具体构件类（列表框）
 * @date 15:58 2020/1/6
 */
public class ListBox extends Component {

    @Override
    void display() {
        System.out.println("显示列表框!");
    }
}

/**
 * @author Wangzy
 * @Description: 具体构件类（文本框）
 * @date 15:58 2020/1/6
 */
public class TextBox extends Component {

    @Override
    void display() {
        System.out.println("显示文本框!");
    }
}

/**
 * @author Wangzy
 * @Description: 具体构件类（窗体）
 * @date 15:58 2020/1/6
 */
public class Window extends Component {

    @Override
    void display() {
        System.out.println("显示窗体!");
    }
}

/**
 * @author Wangzy
 * @Description: 抽象装饰类
 * @date 16:01 2020/1/6
 */
public class ComponentDecorate extends Component {

    // 与抽象构件类建立关联关系
    private Component component;

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

    @Override
    void display() {
        this.component.display();
    }
}

/**
 * @author Wangzy
 * @Description: 具体装饰类（加滚动条）
 * @date 16:05 2020/1/6
 */
public class ScrollBarDecorator extends ComponentDecorate {


    public ScrollBarDecorator(Component component) {
        super(component);
    }

    @Override
    public void display() {
        // 实现原有的显示功能
        super.display();
        // 实现加滚动条功能
        this.setScrollBar();
    }

    private void setScrollBar() {
        System.out.println("添加滚动条!");
    }
}

/**
 * @author Wangzy
 * @Description: 具体装饰类（加黑色边框）
 * @date 16:05 2020/1/6
 */
public class BlackBorderDecorator extends ComponentDecorate {


    public BlackBorderDecorator(Component component) {
        super(component);
    }

    @Override
    public void display() {
        // 实现原有的显示功能
        super.display();
        // 实现加黑色边框功能
        this.setBlackBorder();
    }

    private void setBlackBorder() {
        System.out.println("添加黑色边框!");
    }
}