【源码分析设计模式 5】Java I/O系统中的装饰器模式

一、基本介绍

动态地将责任附加到对象上。若要扩展功能，装饰者提供了比继承更有弹性的替代方案。

二、装饰器模式的结构

1、Component，抽象构件

Component是一个接口或者抽象类，是定义我们最核心的对象，也可以说是最原始的对象，比如街边小吃；

2、ConcreteComponent，具体构件，或者基础构件

ConcreteComponent是最核心、最原始、最基本的接口或抽象类Component的实现，可以单独用，也可将其进行装饰，比如街边小吃最有名的手抓饼；

3、Decorator，装饰角色

　一般是一个抽象类，继承自或实现Component，在它的属性里面有一个变量指向Component抽象构件，我觉得这是装饰器最关键的地方。

4、ConcreteDecorator，具体装饰角色

ConcreteDecoratorA和ConcreteDecoratorB是两个具体的装饰类，它们可以把基础构件装饰成新的东西，比如把一个普通的手抓饼装饰成加蛋、加肠儿、金针菇的手抓饼。

三、装饰器模式优缺点

1、优点

（1）装饰类和被装饰类可以独立发展，而不会相互耦合。换句话说，Component类无需知道Decorator类，Decorator类是从外部来扩展Component类的功能，而Decorator也不用知道具体的构件。

（2）装饰器模式是继承关系的一个替代方案。我们看装饰类Decorator，不管装饰多少层，返回的对象还是Component(因为Decorator本身就是继承自Component的)，实现的还是is-a的关系。

2、缺点

（1）装饰器模式虽然减少了类的爆炸,但是在使用的时候,你就可能需要更多的对象来表示继承关系中的一个对象

（2）装饰器模式虽然从数量级上减少了类的数量,但是为了要装饰,仍旧会增加很多的小类这些具体的装饰类的逻辑将不会非常的清晰,不够直观,容易令人迷惑。

（3）多层的装饰是比较复杂的。为什么会复杂？你想想看，就像剥洋葱一样，你剥到最后才发现是最里层的装饰出现了问题，可以想象一下工作量。这点从我使用Java I/O的类库就深有感受，我只需要单一结果的流，结果却往往需要创建多个对象，一层套一层，对于初学者来说容易让人迷惑。

四、装饰器模式的使用场景

1、当你想要给一个类增加功能,然而,却并不想修改原来类的代码时,可以考虑装饰器模式如果你想要动态的给一个类增加功能,并且这个功能你还希望可以动态的撤销,就好像直接拿掉了一层装饰物；

2、比如java里面的基本数据类型int、boolean、char....都有它们对应的装饰类Integer、Boolean、Character....

3、在Java IO中，具体构建角色是节点流、装饰角色是过滤流；

FilterInputStream和FilterOutputStream是装饰角色，而其他派生自它们的类则是具体装饰角色。

DataoutputStream out=new DataoutputStream(new FileoutputStream());

这就是装饰者模式，DataoutputStream是装饰者子类，FileoutputStream是实现接口的子类。

这里不会调用到装饰者类--FilteroutputStream,只是作为继承的另一种方案，对客户端来说是透明的，是为了功能的扩张。

五、装饰器模式实现手抓饼

老板，来个手抓饼，加个蛋、加根烤肠多少钱？

这个就是装饰器模式，用蛋和烤肠去装饰手抓饼，让手抓饼更加美味。

1、Component，抽象构件：街边小吃

package designMode.advance.decorator;public abstract class Snack {public String des; // 描述private float price = 0.0f;public String getDes() {return des;}public void setDes(String des) {this.des = des;}public float getPrice() {return price;}public void setPrice(float price) {this.price = price;}//计算费用的抽象方法//子类来实现public abstract float cost();
}

2、ConcreteComponent，具体构件，或者基础构件

（1）手抓饼

package designMode.advance.decorator;public class HandGrabCake extends Snack {public HandGrabCake() {setPrice(5.0f);setDes(" 手抓饼 "+cost());}@Overridepublic float cost() {return super.getPrice();}
}

（2）烤冷面

package designMode.advance.decorator;public class GrilledColdNoodles extends Snack {public GrilledColdNoodles() {setPrice(4.0f);setDes(" 烤冷面 "+cost());}@Overridepublic float cost() {return super.getPrice();}
}

Decorator，装饰角色

package designMode.advance.decorator;public class Decorator extends Snack {private Snack obj;public Decorator(Snack obj) { //组合this.obj = obj;}@Overridepublic float cost() {return super.getPrice() + obj.cost();}@Overridepublic String getDes() {// obj.getDes() 输出被装饰者的信息return des + " " + getPrice() + " && " + obj.getDes();}
}

3、具体装饰角色

（1）鸡蛋

package designMode.advance.decorator;public class Egg extends Decorator {public Egg(Snack obj) {super(obj);setDes(" 鸡蛋 ");setPrice(1.0f);}
}

（2）烤肠

package designMode.advance.decorator;public class Sausage extends Decorator  {public Sausage(Snack obj) {super(obj);setDes(" 烤肠 ");setPrice(2.0f);}
}

（3）金针菇

package designMode.advance.decorator;public class NeedleMushroom extends Decorator{public NeedleMushroom(Snack obj) {super(obj);setDes(" 金针菇 ");setPrice(2.5f);}
}

4、老板，来个手抓饼，加2个蛋、加1根烤肠

package designMode.advance.decorator;public class HandGrabCakeBar {public static void main(String[] args) {// 装饰者模式下的订单：2个蛋+一根烤肠的手抓饼// 1. 点一份手抓饼Snack order = new HandGrabCake();System.out.println("小白手抓饼费用=" + order.cost());System.out.println("描述=" + order.getDes());// 2. order 加入一个鸡蛋order = new Egg(order);System.out.println("手抓饼 加入1个鸡蛋 费用 =" + order.cost());System.out.println("手抓饼 加入1个鸡蛋 描述 = " + order.getDes());// 3. order 加入一个鸡蛋order = new Egg(order);System.out.println("手抓饼 加入1个鸡蛋 加入2个鸡蛋 费用 =" + order.cost());System.out.println("手抓饼 加入1个鸡蛋 加入2个鸡蛋 描述 = " + order.getDes());// 3. order 加入一根烤肠order = new Sausage(order);System.out.println("手抓饼 加入1个鸡蛋 加入2个鸡蛋 加1根烤肠 费用 =" + order.cost());System.out.println("手抓饼 加入1个鸡蛋 加入2个鸡蛋 加1根烤肠 描述 = " + order.getDes());System.out.println("===========================");Snack order2 = new GrilledColdNoodles();System.out.println("考冷面 费用 =" + order2.cost());System.out.println("考冷面 描述 = " + order2.getDes());// 1. order2 加入一袋金针菇order2 = new NeedleMushroom(order2);System.out.println("考冷面 加入一袋金针菇  费用 =" + order2.cost());System.out.println("考冷面 加入一袋金针菇 描述 = " + order2.getDes());}
}

5、好嘞，您拿好

六、装饰器模式在Java I/O系统中的实现

前面总结了这么多，再从大神们的作品中找一个实际应用例子吧，毕竟那是经历实战检验的，肯定是有道理的。嗯，在平时的留意中我发现Java I/O系统的设计中用到了这一设计模式，因为Java I/O类库需要多种不同功能的组合。这里我就以InputStream为例简单说明一下，同样我们还是来看一下其类图：

InputStream作为抽象构件，其下面大约有如下几种具体基础构件，从不同的数据源产生输入：

ByteArrayInputStream，从字节数组产生输入；
FileInputStream，从文件产生输入；
StringBufferInputStream，从String对象产生输入；
PipedInputStream，从管道产生输入；
SequenceInputStream，可将其他流收集合并到一个流内；

FilterInputStream作为装饰器在JDK中是一个普通类，其下面有多个具体装饰器比如BufferedInputStream、DataInputStream等。我们以BufferedInputStream为例，使用它就是避免每次读取时都进行实际的写操作，起着缓冲作用。我们可以在这里稍微深入一下，站在源码的角度来管中窥豹。

FilterInputStream内部封装了基础构件：

protected volatile InputStream in;

而BufferedInputStream在调用其read()读取数据时会委托基础构件来进行更底层的操作，而它自己所起的装饰作用就是缓冲，在源码中可以很清楚的看到这一切：

public synchronized int read() throws IOException {if (pos >= count) {fill();if (pos >= count)return -1;}return getBufIfOpen()[pos++] & 0xff;
}private void fill() throws IOException {byte[] buffer = getBufIfOpen();if (markpos < 0)pos = 0;            /* no mark: throw away the buffer */else if (pos >= buffer.length)  /* no room left in buffer */if (markpos > 0) {  /* can throw away early part of the buffer */int sz = pos - markpos;System.arraycopy(buffer, markpos, buffer, 0, sz);pos = sz;markpos = 0;} else if (buffer.length >= marklimit) {markpos = -1;   /* buffer got too big, invalidate mark */pos = 0;        /* drop buffer contents */} else if (buffer.length >= MAX_BUFFER_SIZE) {throw new OutOfMemoryError("Required array size too large");} else {            /* grow buffer */int nsz = (pos <= MAX_BUFFER_SIZE - pos) ?pos * 2 : MAX_BUFFER_SIZE;if (nsz > marklimit)nsz = marklimit;byte nbuf[] = new byte[nsz];System.arraycopy(buffer, 0, nbuf, 0, pos);if (!bufUpdater.compareAndSet(this, buffer, nbuf)) {throw new IOException("Stream closed");}buffer = nbuf;}count = pos;// 看这行就行了，委托基础构件来进行更底层的操作int n = getInIfOpen().read(buffer, pos, buffer.length - pos);if (n > 0)count = n + pos;
}private InputStream getInIfOpen() throws IOException {InputStream input = in;if (input == null)throw new IOException("Stream closed");return input;
}

这部分的代码很多，这里我们没有必要考虑这段代码的具体逻辑，只需要看到在BufferedInputStream的read方法中通过getInIfOpen()获取基础构件从而委托其进行更底层的操作(在这里是读取单个字节)就可以说明本文所要说的一切了。

至于I/O类库中的其他设计诸如OutputStream、Writer、Reader，是一致的，这里就不再赘述了。