java 装饰器模式

原文链接：http://chenhua-1984.iteye.com/blog/565629

记得以前听一个高手说java.io包采用了了装饰器模式，当时不是很明白什么事装饰器模式，现在，网上看了一下说明和帮助的例子，他们的例子是这样的。

   定义

Decorator装饰器，顾名思义，就是动态地给一个对象添加一些额外的职责，就好比为房子进行装修一样。因此，装饰器模式具有如下的特征：

它必须具有一个装饰的对象。

它必须拥有与被装饰对象相同的接口。

它可以给被装饰对象添加额外的功能。

用一句话总结就是：保持接口，增强性能。

装饰器通过包装一个装饰对象来扩展其功能，而又不改变其接口，这实际上是基于对象的适配器模式的一种变种。它与对象的适配器模式的异同点如下。

相同点：都拥有一个目标对象。

不同点：适配器模式需要实现另外一个接口，而装饰器模式必须实现该对象的接口。

 

Sourcable类的源代码如程序12-22所示，其定义了一个接口函数operation()。

程序12-22  源接口Sourcable.java

Java代码  

1. package pattern.decorator;  
2.   
3. public interface Sourcable {  
4.     public void operation();  
5.   
6. }  

 

（2）Source.java是Sourcable.java的一个实现，其函数operation()负责往控制台输出一个字符串：原始类的方法。其源代码如程序12-23所示。

程序12-23  源类Source.java

Java代码  

1. package pattern.decorator;  
2.   
3. public class Source implements Sourcable {  
4.   
5.     public void operation() {  
6.         System.out.println("原始类的方法");  
7.     }  
8.   
9. }  

 

（3）装饰器类Decorator1.java采用了典型的对象适配器模式，它首先拥有一个Sourcable对象source，该对象通过构造函 数进行初始化。然后它实现了Sourcable.java接口，以期保持与source同样的接口，并在重写的operation()函数中调用 source的operation()函数，在调用前后可以实现自己的输出，这就是装饰器所扩展的功能。其源代码如程序12-24所示。

程序12-24  装饰器类Decorator1.java

Java代码  

1. package pattern.decorator;  
2.   
3. public class Decorator1 implements Sourcable {  
4.   
5.     private Sourcable sourcable;  
6.     public Decorator1(Sourcable sourcable){  
7.         super();  
8.         this.sourcable=sourcable;  
9.     }  
10.       
11.     public void operation() {  
12.         System.out.println("第一个装饰器前");  
13.         sourcable.operation();  
14.         System.out.println("第一个装饰器后");  
15.   
16.     }  
17.   
18. }  

 

装饰器类Decorator2.java是另一个装饰器，不同的是它装饰的内容不一样，即输出了不同的字符串。其源代码如程序12-25所示。

程序12-25  装饰器类Decorator2.java

Java代码  

1. package pattern.decorator;  
2.   
3. public class Decorator2 implements Sourcable {  
4.   
5.     private Sourcable sourcable;  
6.     public Decorator2(Sourcable sourcable){  
7.         super();  
8.         this.sourcable=sourcable;  
9.     }  
10.     public void operation() {  
11.         System.out.println("第二个装饰器前");  
12.         sourcable.operation();  
13.         System.out.println("第二个装饰器后");  
14.   
15.     }  
16.   
17. }  

 

装饰器类Decorator1.java是第三个装饰器，不同的是它装饰的内容不一样，即输出了不同的字符串。其源代码如程序12-26所示。

程序12-26  装饰器类Decorator3.java

Java代码  

1. package pattern.decorator;  
2.   
3. public class Decorator3 implements Sourcable {  
4.   
5.     private Sourcable sourcable;  
6.     public Decorator3(Sourcable sourcable){  
7.         super();  
8.         this.sourcable=sourcable;  
9.     }  
10.     public void operation() {  
11.         System.out.println("第三个装饰器前");  
12.         sourcable.operation();  
13.         System.out.println("第三个装饰器后");  
14.   
15.     }  
16.   
17. }  

 

这时，我们就可以像使用对象的适配器模式一样来使用这些装饰器，使用不同的装饰器就可以达到不同的装饰效果。如程序12-27所示，首先需要创建一 个源类对象source，然后根据将对象使用Decorator1来装饰，并以此使用Decorator2、Decorator3进行装饰，装饰后的对象 同样具有与source同样的接口。

程序12-27  测试类DecoratorTest.java

Java代码  

1. package pattern.decorator;  
2.   
3. public class DecoratorTest {  
4.   
5.     /** 
6.      * @param args 
7.      */  
8.     public static void main(String[] args) {  
9.         Sourcable source = new Source();  
10.   
11.         // 装饰类对象   
12.         Sourcable obj = new Decorator1(new Decorator2(new Decorator3(source)));  
13.         obj.operation();  
14.     }  
15.   
16. }  

 

运行该程序的输出如下：

第1个装饰器装饰前

第2个装饰器装饰前

第3个装饰器装饰前

原始类的方法

第3个装饰器装饰后

第2个装饰器装饰后

第1个装饰器装饰后

从输出的结果可以看出，原始类对象source依次被Decorator1、Decorator2、Decorator3进行了装饰。

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

原文链接：http://www.cnblogs.com/ikuman/archive/2013/01/29/2877913.htm

意图：动态的将责任附加到对象上
什么时候使用：
1.在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责
2.处理那些可以撤销的职责
3.当不能采用生成子类的方式进行扩充时
结构图：

示例代码：

1 package com.test.patten.decorator;
2 
3 public interface Person {
4     void doCoding();
5 }

 1 package com.test.patten.decorator;
 2 
 3 public class Employee implements Person {
 4 
 5     @Override
 6     public void doCoding() {
 7         System.out.println("程序员加班写程序啊，写程序，终于写完了。。。");
 8     }
 9 
10 }

1 package com.test.patten.decorator;
2 
3 public abstract class Manager implements Person{
4     
5     //装饰器增加功能
6     public abstract void doCoding();
7 
8 }

 1 package com.test.patten.decorator;
 2 
 3 public class ManagerA extends Manager {
 4     private Person person;//给雇员升职
 5     
 6     public ManagerA(Person person) {
 7         super();
 8         this.person = person;
 9     }
10     @Override
11     public void doCoding() {
12         doEarlyWork();
13         person.doCoding();        
14     }
15     /**
16      * 项目经理开始前期准备工作
17      */
18     public void doEarlyWork() {
19         System.out.println("项目经理A做需求分析");
20         System.out.println("项目经理A做架构设计");
21         System.out.println("项目经理A做详细设计"); 
22     }
23 }

 1 package com.test.patten.decorator;
 2 
 3 public class ManagerB extends Manager {
 4     private Person person;//给雇员升职
 5     
 6     public ManagerB(Person person) {
 7         super();
 8         this.person = person;
 9     }
10     @Override
11     public void doCoding() {
12         person.doCoding();
13         doEndWork();
14     }
15     /**
16      * 项目经理开始项目收尾工作
17      */
18     public void doEndWork() {
19         System.out.println("项目经理B 在做收尾工作");
20     }
21     
22 }

测试一下：

 1 package com.test.patten.decorator;
 2 
 3 public class Client {
 4     public static void main(String args[]){
 5         Person employee = new Employee();
 6         employee = new ManagerA(employee);//赋予程序猿项目经理A职责
 7         employee = new ManagerB(employee);//赋予程序猿项目经理B职责
 8         
 9         employee.doCoding();
10     }
11 }

项目经理A做需求分析 项目经理A做架构设计 项目经理A做详细设计 程序员加班写程序啊，写程序，终于写完了。。。 项目经理B 在做收尾工作

 实际应用中的例子：java i/o

应用到的设计原则：对扩展开放，对修改关闭

优缺点：

1.装饰者类反应出被装饰的组件类型

2.装饰者类可以在被装饰者的行为前面或后面加上自己的行为，甚至取代被装饰者的行为，达到特定的目的

3.可以用无数个装饰者包装一个组件，装饰者类会导致设计中出现许多小对象，过度使用会让程序变的复杂

4.装饰者一般对组件的客户是透明的，除非客户程序依赖于组件的具体类型

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

原文链接：http://blog.163.com/nonoliuhao@126/blog/static/1716520942010101211132305/

装饰器模式主要应用于这样一种场合，当你已经有了一个目标类，并且它是一个接口的实现类，在对该类使用的后期发现需要对相应接口程序的前后做更多的处理，这些处理是变化的，不固定的，但是有不能去修改这个目标类，这时我们就可以使用这个装饰器模式：

比如，我们已经有一个付款的方法 payMoney(long count) ，这个方法只负责将钱付给对方，不做其他操作，但是这时我们需要记录下这个付款的操作，并把这个操作记录到日志文件中以方便日后的查看，比如这个方法叫做 insertLog(String str) ，有一种办法就是使用继承，并复写相应的 payMoney(long count) 方法，这样也可以满足条件，但是问题出来了，如果我们又有其他的操作，例如通知付款人已经将款额付出 notic(String username) ，这时候这么办，当然我们仍然可以通过继承来实现，可是如果我现在有不想将付款操作记录到日志文件中了，那我又该这么办？

为了解决这种问题，我们使用了 装饰器模式 ，在我们的应用中可以使用不同的装饰器类（以及装饰器类的组合）来达到以上的目的。

再将问题简化，我们要在控制台输出字符，但是需要在字符前后加上“*”和“+”，也就是说，我可能需要在我输入的字符前后加上“*”，也可能过了会儿又想加“+”而不是“*”，或者又想“*”和“+”都加上，有或者都不想加。

装饰器模式 让这些要求动态的配置出来，也就是说在运行时不需要改变原来已经生成好的对象。

让我们来看看这个解决方案的 装饰器模式 的类图吧：

其中，MyText 类为我们要显示的字符类，而 DecoratorTextConsole 及其子类为我们的 装饰类 。

具体代码如下：
/**********************************************************************/
package decorator.interfaces;

public interface TextConsole {
public void printWords();

public void readWords();
}
/**********************************************************************/
package decorator.service;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import decorator.interfaces.TextConsole;

public class MyText implements TextConsole {

private String words;

public void printWords() {
   System.out.print(words);
}

public void readWords() {
   BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
   try{
    System.out.print("please enter some word to display:");
    words = br.readLine();
   }catch(IOException e){
    e.printStackTrace();
    words = "There are some errors occured during your entering!";
   }
}

}
/**********************************************************************/
package decorator.interfaces.impl;

import decorator.interfaces.TextConsole;

public class DecoratorTextConsole implements TextConsole {

private TextConsole text;

public DecoratorTextConsole(TextConsole text){
   this.text = text;
}

public void printWords() {
   text.printWords();
}

public void readWords() {
   text.readWords();
}

}
/**********************************************************************/
package decorator.interfaces.impl;

import decorator.interfaces.TextConsole;

public class AsteriskTextConsole extends DecoratorTextConsole {


public AsteriskTextConsole(TextConsole text){
   super(text);
}

public void printWords(){
   addAsterisk();
   super.printWords();
   addAsterisk();
}

private void addAsterisk(){
   System.out.print("*");
}
}
/**********************************************************************/
package decorator.interfaces.impl;

import decorator.interfaces.TextConsole;

public class PlusTextConsole extends DecoratorTextConsole {

public PlusTextConsole(TextConsole text){
   super(text);
}

public void printWords(){
   addPlus();
   super.printWords();
   addPlus();
}

private void addPlus(){
   System.out.print("+");
}
}
/**********************************************************************/
package decorator;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import decorator.interfaces.TextConsole;
import decorator.interfaces.impl.AsteriskTextConsole;
import decorator.interfaces.impl.PlusTextConsole;
import decorator.service.MyText;

public class TestMain {
public static void main(String[] args){
   TextConsole mt = new MyText();    // mt 实例在整个被调用的过程中都不会改变，但是它的其他装饰器类却是动态生成的，而且是可自由“拆卸”的，这样就比单一的继承灵活的多。
   mt.readWords();
   mt.printWords();
   System.out.println();
  
   String commond = new String();
   System.out.println("please enter commond: (add ?(-plus | -astr | -all) | exit");
  
   while(!commond.equals("exit")){
    try{
     commond = new BufferedReader(new InputStreamReader(System.in)).readLine();
    }catch(IOException e){
     e.printStackTrace();
     commond = "exit";
    }
    if(commond.equals("add -plus")){
     TextConsole ptc = new PlusTextConsole(mt);
     ptc.printWords();
     System.out.println();
    }else if(commond.equals("add -astr")){
     TextConsole atc = new AsteriskTextConsole(mt);
     atc.printWords();
     System.out.println();
    }else if(commond.equals("add -all")){
     TextConsole tc = new AsteriskTextConsole(new PlusTextConsole(mt));
     tc.printWords();
     System.out.println();
    }else{
     mt.printWords();
     System.out.println();
    }
   }
}
}

三　装饰模式的应用

　学过装饰模式后，大家会发现，它在Java语言中最著名的应用莫过于Java I/O标准为库的设计了。这一节将以处理Byte流为例，看看装饰模式是怎样得到应用的。

　为什么不用继承而用装饰模式

　我们知道Java I/O库需要很多性能的各种组合，如果说这些性能的组合是通过继承方式来实现的话，那么每一种组合都需要一个类，这样就会出现大量重复性问题的出现，从而使类数目“爆炸”。而如果采用装饰模式，那么不仅类的数目大减少了，性能的重复也可以减至到最少。所以装饰模式是Java I/O库的基本模式。在这里我想再用<<Head First Design Pattern>>中讲到装饰模式时候的一个例子，看看装饰模式是怎么达到不仅类的数目大减少了，性能的重复也可以减至到最少：

　它这个例子大概是说：Beverage是一个抽象类，它被所有在一个咖啡店里卖的饮料继承。Beverage有个抽象方法cost，所有的子类都要实现这个抽象方法，计算它们的价格。现在有四个最基本的咖啡：HouseBlend,DarkRoast,Decaf,Espresso他们都继承自Beverage，现在的需求是说在四个最基本的咖啡里，每个都可以随便地添加调味品，像steamed milk,soy,还有mocha最后是加上whipped milk。如果是说按继承来实现这种几个调味品跟原来咖啡的组合的话，我们会很自然地设计来下面的类图来：

看到了上面的类图了吗，我们不禁会说这就是“类爆炸”。如果是按装饰模式的设计思路我们可以得出下面的设计类图：

我们再来看看Gof里面的标准的装饰模式的类图表示：

仔细看看上面的几个图后我们肯定就会理解这句话了：装饰模式是怎么达到不仅类的数目大减少了，性能的重复也可以减至到最少。

　再回到Java I/O库，由于装饰模式的引用，造成了灵活性和复杂都大大增加了，我们在使用Java I/O库时，必须理解Java I/O库是由一些基本的原始流处理器和围绕它们的装饰流处理器所组成的，这样可以在学习和使用Java I/O库时达到事半功倍的效果。

　下面我用<<Java与模式>>，<<Head First Design Pattern>>或者是网上看到的一些类图来分析：

　首先是InputStream类型中的装饰模式：

　InputStream有七个直接的具体子类，有四个属于FilterInputStream的具体子类，如下图所示：

　　上图中所有的类都叫做流处理器，这个图就叫做（InputStream类型的）流处理器图。

　　书中提到根据输入流的源的类型，可以将这些流类分成两种，即原始流类（Original Stream）和链接流处理器（Wrapper Stream）。

　　原始流处理器

　　原始流处理器接收一个Byte数组对象，String对象，FileDiscriptor对象或者不同类型的流源对象，根据上面的图，原始流处理器包括以下四种：

　　ByteArrayInputStream：为多线程的通信提供缓冲区操作功能，接收一个Byte数组作为流的源。

　　FileInputStream:建立一个与文件有关的输入流。接收一个File对象作为流的源。

　　PipedInputStream：可以与PipedOutputStream配合使用，用于读入一个数据管道的数据，接收一个PipedOutputStream作为源。

　　StringBufferInputStream：将一个字符串缓冲区转换为一个输入流。接收一个String对象作为流的源。（ＪＤＫ帮助文档上说明：已过时。此类未能正确地将字符转换为字节。从ＪＤＫ1.1开始，从字符串创建流的首选方法是通过StringReader类进行创建。只有字符串中每个字符的低八位可以由此类使用。）

　　链接流处理器

　　所谓链接流处理器，就是可以接收另一个流对象作为源，并对之进行功能扩展的类。InputStream类型的链接处理器包括以下几种，它们都接收另一个InputStream对象作为流源。

　　（１）FilterInputStream称为过滤输入流，它将另一个输入流作为流源。这个类的子类包括以下几种：

　　BufferedInputStream：用来从硬盘将数据读入到一个内存缓冲区中，并从缓冲区提供数据。

　　DataInputStream：提供基于多字节的读取方法，可以读取原始类型的数据。

　　LineNumberInputStream：提供带有行计数功能的过滤输入流。

　　PushbackInputStream：提供特殊的功能，可以将已经读取的字节“推回”到输入流中。

　　（２）ObjectInputStream可以将使用ObjectInputStream串行化的原始数据类型和对象重新并行化。

　　（３）SeqcueneInputStream可以将两个已有的输入流连接起来，形成一个输入流，从而将多个输入流排列构成一个输入流序列。

　　抽象结构图

　　按照上面的这种原始流处理器和链接流处理器的划分，可以用下面的结构图来描述它们之间的关系。

　　

　上面的流处理器图跟装饰模式的结构图有着显而易见的相同之处。实际上InputStream类型的流处理器结构确实符合装饰模式。　

　装饰模式结构图

　

　　对于上图FilterInputStream查看JDK1.4源代码，部分代码如下:

Public class FilterInputStream extends InputStream {

    /**

     * The input stream to be filtered.

     */

    protected InputStream in;

    protected FilterInputStream(InputStream in) {

        this.in = in;

    }

    //其它代码

}

FilterInputStream继承了InputStream,也引用了InputStream,而它有四个子类,这就是所谓的Decorator模式

　　上面这个图向我们传达了这个信息：链接流链接流对象接收一个原始流对象或者另外一个链接流对象作为流源；另一方面他们对流源的内部工作方法做了相应的改变，这种改变是装饰模式所要达到的目的。比如：

　　BufferedInputStream“装饰”了InputStream的内部工作方式，使得流的读入操作使用了缓冲机制。在使用了缓冲机制后，不会对每一次的流读入操作都产生一个物理的读盘动作，从而提高了程序的效率，在汲及到物理流的读入时，都应当使用这个装饰流类。

　　LineNumberInputStream和PushbackInputStream也同样“装饰”了InputStream的内部工作方式，前者使得程序能够按照行号读入数据；后者能够使程序读入的过程中，退后一个字符。

　　DataInputStream子类读入各种不同的原始数据类型以及String类型的数据，这一点可以从它提供的各种read方法看出来，如：readByte(),readInt(),readFloat()等。

　 Java语言的I/O库提供了四大等级结构:InputStream,OutputStream,Reader,Writer四个系列的类。InputStream和OutputStream处理8位字节流数据, Reader和Writer处理16位的字符流数据。InputStream和Reader处理输入, OutputStream和Writer处理输出，所以OutputStream,Reader,Writer这三类的装饰模式跟前面详细介绍的InputStream装饰模式大同小异，大家可以看书中其它部分对这三类的详细描述或者从网上也能找到有关资料。为了方便比较这几种类型，顺便附上Java语言的I/O层次结构图：

　下面的图表示:以InputStream和OutputStream形成的层次关系

　下面的图表示:以Reader和Writer形成的层次关系