設計模式解密（9）- 裝飾者模式

1、簡介

定義：裝飾模式是在不必改變原類文件和使用繼承的情況下，動態的擴展一個對象的功能。它是通過創建一個包裝對象，也就是裝飾來包裹真實的對象。

拆分定義，總結特點：

　　　　   1、不改變原類文件。

                 2、不使用繼承。

                 3、動態擴展。

主要解決：一般的，我們為了擴展一個類經常使用繼承方式實現，由於繼承為類引入靜態特征，並且隨着擴展功能的增多，子類會很膨脹。

何時使用：在不想增加很多子類的情況下擴展類。

如何解決：將具體功能職責划分，同時繼承裝飾者模式。

英文：Decrator

類型：結構型模式

2、類圖及組成

（引）類圖：

角色：

　　●抽象構件(Component)角色：給出一個抽象接口，以規范准備接收附加責任的對象。 
　　●具體構件(ConcreteComponent)角色：定義一個將要接收附加責任的類。 
　　●裝飾(Decorator)角色：持有一個構件(Component)對象的實例，並定義一個與抽象構件接口一致的接口。 
　　●具體裝飾(ConcreteDecorator)角色：負責給構件對象“貼上”附加的責任。

代碼結構：

抽象構件角色
public interface Component {

    public void sampleOperation();

}

具體構件角色
public class ConcreteComponent implements Component {

    @Override
    public void sampleOperation() {
        // 寫相關的業務代碼    
    }

}

裝飾角色
public class Decorator implements Component{
    private Component component;

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

    @Override
    public void sampleOperation() {
        // 委派給構件        
        component.sampleOperation();
    }

}

具體裝飾角色
public class ConcreteDecoratorA extends Decorator {

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

    @Override
    public void sampleOperation() {
　　　　  super.sampleOperation();
        // 寫相關的業務代碼   
    }
}

具體裝飾角色
public class ConcreteDecoratorB extends Decorator {

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

    @Override
    public void sampleOperation() {
　　　　  super.sampleOperation();
        // 寫相關的業務代碼    
    }
}

3、實例引入

本例中 抽象構建角色由Coder程序員接口扮演

具體構件角色由類SpecificCoder扮演

裝飾構件由類Derector扮演，它必須也實現抽象構件接口

具體裝飾構件角色由類JavaCoder(程序員)和類 JavaArchitect(架構師)扮演

具體程序員xxx有編程能力,通過學習和實踐,他漸漸的獲得很多種能力，每多一種能力，都通過裝飾類實現的

package com.designpattern.Decorator;
/**
 * 抽象構建角色
 * 程序員接口
 * @author Json
*/
public interface Coder {

    /**
     * 寫代碼
     */
    public void writeCode();
}

 具體構建角色：

package com.designpattern.Decorator;
/**
 * 具體構建角色
 * 一個具體的程序員
 * @author Json
*/
public class SpecificCoder implements Coder {
    @Override
    public void writeCode() {
        System.out.println("我是一個程序員,我能寫代碼...");
    }
}

 一個具體的裝飾角色：

package com.designpattern.Decorator;
/**
 * 一個具體的裝飾角色
 * java普通程序員
 * @author Json
*/
public class JavaCoder extends Decorator {
    
    public JavaCoder(Coder coder) {
        super(coder);
    }

    @Override
    public void writeCode(){
        super.writeCode();
        //可以追加功能
        System.out.println("我是Java程序員...");
    }
}

 一個具體的裝飾角色：

package com.designpattern.Decorator;
/**
 * 一個具體的裝飾角色
 * java架構師
 * @author Json
*/
public class JavaArchitect extends Decorator {
    
    public JavaArchitect(Coder coder) {
        super(coder);
    }

    @Override
    public void writeCode(){
        super.writeCode();
        //可以追加功能
        System.out.println("我是Java架構師...");
    }
}

測試：

package com.designpattern.Decorator;
/**
 * 測試
 * @author Json
*/
public class Test {
    public static void main(String[] args) {
        Coder coder = new SpecificCoder();
        
        System.out.println("第一次裝飾 ↓↓↓");
        Decorator javacoder = new JavaCoder(coder);
        javacoder.writeCode();
        
        System.out.println("第二次裝飾 ↓↓↓");
        Decorator javaarchitect = new JavaArchitect(javacoder);
        javaarchitect.writeCode();
        
        
        System.out.println("------------------------------------");
        System.out.println("一步裝飾多次 ↓↓↓");
        //一步裝飾多次
        Decorator javaarchitect_1 = new JavaArchitect(new JavaCoder(new SpecificCoder())); 
        javaarchitect_1.writeCode();
    }
}

結果：

第一次裝飾 ↓↓↓
我是一個程序員,我能寫代碼...
我是Java程序員...
第二次裝飾 ↓↓↓
我是一個程序員,我能寫代碼...
我是Java程序員...
我是Java架構師...
------------------------------------
一步裝飾多次 ↓↓↓
我是一個程序員,我能寫代碼...
我是Java程序員...
我是Java架構師...

4、優缺點

優點：

　　1、 對於擴展一個對象的功能，裝飾模式比繼承更加靈活性，不會導致類的個數急劇增加。

　　2、 可以通過一種動態的方式來擴展一個對象的功能，通過配置文件可以在運行時選擇不同的具體裝飾類，從而實現不同的行為。

　　3、 可以對一個對象進行多次裝飾，通過使用不同的具體裝飾類以及這些裝飾類的排列組合，可以創造出很多不同行為的組合，得到功能更為強大的對象。

　　4、 具體構件類與具體裝飾類可以獨立變化，用戶可以根據需要增加新的具體構件類和具體裝飾類，原有類庫代碼無須改變，符合“開閉原則”。

缺點：

　　1、 使用裝飾模式進行系統設計時將產生很多小對象，這些對象的區別在於它們之間相互連接的方式有所不同，而不是它們的類或者屬性值有所不同，大量小對象的產生勢必會占用更多的系統資源，在一定程序上影響程序的性能。

　　2、 裝飾模式提供了一種比繼承更加靈活機動的解決方案，但同時也意味着比繼承更加易於出錯，排錯也很困難，對於多次裝飾的對象，調試時尋找錯誤可能需要逐級排查，較為繁瑣。

 

5、應用場景

1、 在不影響其他對象的情況下，以動態、透明的方式給單個對象添加職責。

2、 當不能采用繼承的方式對系統進行擴展或者采用繼承不利於系統擴展和維護時可以使用裝飾模式。不能采用繼承的情況主要有兩類：第一類是系統中存在大量獨立的 擴展，為支持每一種擴展或者擴展之間的組合將產生大量的子類，使得子類數目呈爆炸性增長；第二類是因為類已定義為不能被繼承（如 Java 語言中的 final 類）。

 

6、裝飾者模式與繼承

1、裝飾模式是一種動態行為，對已經存在類進行隨意組合，而類的繼承是一種靜態的行為，一個類定義成什么樣的，該類的對象便具有什么樣的功能，無法動態的改變。

2、裝飾模式擴展的是對象的功能，不需要增加類的數量，而類繼承擴展是類的功能，在繼承的關系中，如果我們想增加一個對象的功能，我們只能通過繼承關系，在子類中增加方法。

3、裝飾模式是在不改變原類文件和使用繼承的情況下，動態的擴展一個對象的功能，它是通過創建一個包裝對象，也就是裝飾來包裹真是的對象。

PS：一定情況下，可代替繼承。

 

7、與其他模式對比

裝飾者模式是在穩定接口上擴展：

　　原有的不能滿足現有的需求，對原有的進行增強。
　　不會改變接口，而是將一個一個的接口進行裝飾，也就是添加新的功能。
　　裝飾器模式特點在於增強，他的特點是被裝飾類和所有的裝飾類必須實現同一個接口，而且必須持有被裝飾的對象，可以無限裝飾。

適配器模式是接口的轉換：

　　適配器的特點在於兼容，從代碼上的特點來說，適配類與原有的類具有相同的接口，並且持有新的目標對象。
　　在使用適配器模式的時候，我們必須同時持有原對象，適配對象，目標對象......

代理模式是封裝對象的訪問過程：

　　代理模式的特點在於隔離，隔離調用類和被調用類的關系，通過一個代理類去調用。

 

8、總結

裝飾模式降低了系統的耦合度，可以動態增加或刪除對象的職責，並使得需要裝飾的具體構件類和具體裝飾類可以獨立變化，以便增加新的具體構件類和具體 裝飾類。

在軟件開發中，裝飾模式應用較為廣泛，例如：

裝飾者模式在JDK中的運用：
　　Java當中的 IO中輸入流和輸出流 是運用了裝飾者模式的最典型的例子。

　　下面是一個簡單的例子，通過BufferedReader對象來裝飾InputStreamReader對象：

　　BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
　　//System.in is an InputStream object

其他場景：

　　Swing包中圖形界面構件功能

　　Servlet API中提供了一個request對象的Decorator設計模式的默認實現類HttpServletRequestWrapper,增強了request對象的功能。

　　Struts2中，request，response，session對象的處理。

 

PS：源碼地址   https://github.com/JsonShare/DesignPattern/tree/master 

 

PS：原文地址 http://www.cnblogs.com/JsonShare/p/7193632.html