GOF23设计模式之装饰模式（decorator）

一、装饰模式概述

　　（1）动态的为一个对象增加新的功能。

　　（2）装饰模式是一种用于代替继承的技术，无需通过继承增加子类就能扩展对象的新功能。

　　　　  使用对象的关联关系代替继承关系，更加灵活，同时避免类型体系的快速膨胀。

二、装饰模式实现细节

　　（1）Componen 抽象构件角色：

　　　　  真实对象和装饰对象有相同的接口。这样，客户端就能够以真实对象相同的方式同装饰对象交互。

　　（2）ConcreteComponent 具体构件角色（真是角色）：

　　　　  IO 流中的FileInputStream、FileOutputStream

　　（3）Decorator 装饰角色：

　　　　  持有一个抽象构件的引用。装饰对象接受所有客户端的请求，并把这些请求转发给真实的对象，这样就能在真实对象调用前后增加新的功能。

三、装饰模式情景导入

　　场景：设计一款可以增加任意功能的汽车，除了陆地上跑以外，还可以随意增加天上飞、水上游、自动驾驶等功能。

 /**
  * Component抽象构件角色
  * @author CL
  *
  */
 public interface ICar {
     void move();
 }

 /**
  * ConcreteComponent具体构件角色（真实角色）
  * @author CL
  *
  */
 class Car implements ICar {

     @Override
     public void move() {
         System.out.println("陆地上跑！");
     }

 }

 /**
  * Decorator装饰角色
  * @author CL
  *
  */
 class SuperCar implements ICar {
     protected ICar car;

     public SuperCar(ICar car) {
         this.car = car;
     }

     @Override
     public void move() {
         car.move();
     }
 }

 /**
  * ConcreteDecorator具体装饰角色
  *     新增新的功能：天上飞
  * @author CL
  *
  */
 class FlyCar extends SuperCar {

     public FlyCar(ICar car) {
         super(car);
     }

     public void fly() {
         System.out.println("天上飞！");
     }

     @Override
     public void move() {
         super.move();
         fly();
     }

 }

 /**
  * ConcreteDecorator具体装饰角色
  *     新增新的功能：水上游
  * @author CL
  *
  */
 class WaterCar extends SuperCar {

     public WaterCar(ICar car) {
         super(car);
     }

     public void swim() {
         System.out.println("水上游！");
     }

     @Override
     public void move() {
         super.move();
         swim();
     }

 }

 /**
  * ConcreteDecorator具体装饰角色
  *     新增新的功能：人工智能  自动驾驶
  * @author CL
  *
  */
 class AICar extends SuperCar {

     public AICar(ICar car) {
         super(car);
     }

     public void autoMove() {
         System.out.println("自动驾驶！");
     }

     @Override
     public void move() {
         super.move();
         autoMove();
     }

 }

　　测试：

 /**
  * 测试装饰模式
  * @author CL
  *
  */
 public class Client {

     public static void main(String[] args) {
         System.out.println("基本功能，陆地上跑-->");
         Car car = new Car();
         car.move();

         System.out.println("\n增加新的功能，天上飞-->");
         FlyCar flyCar = new FlyCar(car);
         flyCar.move();

         System.out.println("\n增加新的功能，水上游-->");
         WaterCar waterCar = new WaterCar(car);
         waterCar.move();

         System.out.println("\n增加新的功能，水上游， 自动驾驶-->");
         AICar aCar = new AICar(new WaterCar(car));
         aCar.move();

         System.out.println("\n增加新的功能，天上飞，水上游， 自动驾驶-->");
         AICar c = new AICar(
                     new WaterCar(
                         new FlyCar(car)));
         c.move();
     }

 }

　　控制台输出：

基本功能，陆地上跑-->
陆地上跑！

增加新的功能，天上飞-->
陆地上跑！
天上飞！

增加新的功能，水上游-->
陆地上跑！
水上游！

增加新的功能，水上游， 自动驾驶-->
陆地上跑！
水上游！
自动驾驶！

增加新的功能，天上飞，水上游， 自动驾驶-->
陆地上跑！
天上飞！
水上游！
自动驾驶！

四、装饰模式总结

　　装饰模式（Decorator）也叫做包装器模式（Wrapper）

　　装饰模式降低系统的耦合度，可以动态的增加或删除对象的职责，并使得需要装饰的具体构建类和具体装饰类可以独立变化，以便增加新的具体构建类和具体装饰类。

　　优点：

　　　　a. 扩展对象功能，比继承灵活，不会导致类个数急剧增加；

　　　　b. 可以对一个对象进行多次装饰，创造出不同行为的组合，得到功能更加强大的对象；

　　　　c. 具体构建类和具体装饰类可以独立变化，用户可以根据需要自己增加新的具体构件子类和具体装饰子类。

　　缺点：

　　　　a. 产生很多小对象，大量小对象占据内存，一定程度上影响性能；

　　　　b. 装饰模式易于出错，调试排查比较麻烦。

五、装饰模式实际开发应用场景

　　（1）IO 中输入流和输出流的设计

　　　　  a. Componen 抽象构件角色：

　　　　　  IO 流中的InputStream、OutputStream、Reader、Writer

　　　　  b. ConcreteComponen 具体构件角色：

　　　　　  IO 流中的FileInputStream、FileOutputStream

　　　　  c. Decorator 装饰角色：

　　　　　  持有一个抽象构件的引用：IO 流中的FileInputStream、FileOutputStream

　　　　  d. ConcreteDecorator 具体装饰角色：

　　　　　  负责给构件对象增加新的责任，IO 流中的BufferedInputStream、BufferedOutputStream

　　（2）Swing 包中图形界面构件功能；

　　（3）Servlet API 中提供了一个 request 对象的Decorator 设计模式的默认实现类，增强了 request 对象的功能；

　　（4）Struts2 中，request、response、session 对象的处理；　

　　（5）…………