組合模式

組合模式

定義：將對象組合成樹形結構以表示“部分-整體”的層次結構，使客戶端對單個對象和組合對象保持一致的方式處理

類型：結構型

適用場景：

• 希望客戶端可以忽略組合對象與單個對象的差異時
• 處理一個樹形結構時

優點：

• 清楚地定義分層次的負責對象，表示對象的全部或部分層次
• 讓客戶端忽略了層次的差異，方便對整個層次結構進行控制
• 簡化客戶端的代碼
• 符合開閉原則

缺點：

• 限制類型時會比較複雜
• 使設計變得更加抽象

組合模式擴展說明：

合成模式的實現根據所實現接口的區別分爲兩種形式，分別稱爲安全式和透明式。

示例

• 文件系統就是典型的組合模式，如下圖是window系統D盤符下的部分目錄組織結構，紅橙色的是目錄，淺綠色的是文件，這裏目錄和文件是可以看成是同一種對象對待

合成模式可以不提供父對象的管理方法，但是合成模式必須在合適的地方提供子對象的管理方法，諸如：add()、remove()、以及getChild()等

安全式合成模式

　安全模式的合成模式要求管理聚集的方法只出現在樹枝構件類中，而不出現在樹葉構件類中

抽象構件(Component)角色：這是一個抽象角色，它給參加組合的對象定義出公共的接口及其默認行爲，可以用來管理所有的子對象。合成對象通常把它所包含的子對象當做類型爲Component的對象。在安全式的合成模式裏，構件角色並不定義出管理子對象的方法，這一定義由樹枝構件對象給出。

樹葉構件(Leaf)角色：樹葉對象是沒有下級子對象的對象，定義出參加組合的原始對象的行爲。

樹枝構件(Composite)角色：代表參加組合的有下級子對象的對象。樹枝構件類給出所有的管理子對象的方法，如add()、remove()以及getChild()。

• 安全式合成模式代碼：

/**
 * 抽象構件角色類
 */
public interface Component {

    /**
     * 輸出組件的名稱
     * @param preStr
     */
    void printStruct(String preStr);

}

/**
 * 樹枝構件角色類(目錄）
 */
public class Composite implements Component {

    /**
     * 存儲組合對象中包含的子組件的對象（可能是目錄也可能是文件）
     */
    private List<Component> childComponents = new ArrayList<>();

    /**
     * 組合對象的名稱
     */
    private String name;

    /**
     * 構件名稱
     * @param name
     */
    public Composite(String name) {
        this.name = name;
    }


    /**
     * 輸出對象的自身結構
     * @param preStr 前綴，主要是按照層級拼接空格，實現向後縮進
     */
    @Override
    public void printStruct(String preStr) {
        // 先把自己輸出
        System.out.println(preStr + "+" + this.name);
        //如果還包含有子組件，那麼就輸出這些子組件對象
        if(this.childComponents != null){
            //添加兩個空格，表示向後縮進兩個空格
            preStr += "  ";
            //輸出當前對象的子對象
            for(Component c : childComponents){
                //遞歸輸出每個子對象
                c.printStruct(preStr);
            }
        }
    }

    /**
     * 聚集管理方法，增加一個子構件對象
     * @param child 子構件對象
     */
    public void addChild(Component child){
        childComponents.add(child);
    }

    /**
     * 聚集管理方法，刪除一個子構件對象
     * @param index 子構件對象的下標
     */
    public void removeChild(int index){
        childComponents.remove(index);
    }

    /**
     * 聚集管理方法，返回所有子構件對象
     */
    public List<Component> getChild(){
        return childComponents;
    }
}

/**
 * 葉子構件
 */
public class Leaf implements Component {

    /**
     * 葉子對象的名字
     */
    private String name;
    /**
     * 構造方法，傳入葉子對象的名稱
     * @param name 葉子對象的名字
     */
    public Leaf(String name){
        this.name = name;
    }
    /**
     * 輸出葉子對象的結構，葉子對象沒有子對象，也就是輸出葉子對象的名字
     * @param preStr 前綴，主要是按照層級拼接的空格，實現向後縮進
     */
    @Override
    public void printStruct(String preStr) {
        System.out.println(preStr + "-" + name);
    }
}

/**
 * 安全模式（客戶端）
 */
public class Client {

    public static void main(String[] args) {
        Composite root = new Composite("D盤");
        Composite favoriteDir = new Composite("收藏夾");
        Composite picDir = new Composite("圖片");
        picDir.addChild(new Leaf("美女1.png"));
        picDir.addChild(new Leaf("美女2.png"));       

        Composite workDir = new Composite("工作");
        workDir.addChild(new Leaf("需求文檔.doc"));
        Composite learningDir = new Composite("學習");
        learningDir.addChild(new Leaf("Java筆記.md"));
        learningDir.addChild(new Leaf("數據庫筆記.doc"));

        root.addChild(favoriteDir);
        root.addChild(workDir);
        root.addChild(learningDir);
        root.addChild(picDir);
        root.addChild(new Leaf("log.txt"));

        //錯誤演示
        //Leaf leaf = new Leaf("test.txt");
        //leaf.addChild(new Leaf("log.txt"))//報錯，編譯不通過,安全模式下不會出現錯誤調用

        //輸出整個目錄結構
        root.printStruct("");

    }

}

+D盤
+收藏夾
+工作
-需求文檔.doc
+學習
-Java筆記.md
-數據庫筆記.doc
+圖片
-美女1.png
-美女2.png
-log.txt

可以看出，樹枝構件類(Composite)給出了addChild()、removeChild()以及getChild()等方法的聲明和實現，而樹葉構件類則沒有給出這些方法的聲明或實現。這樣的做法是安全的，由於這個特點，客戶端應用程序不可能錯誤地調用樹葉構件的聚集方法，因爲樹葉構件沒有這些方法，調用會導致編譯錯誤。但是，這種安全模式卻有違背組合模式原本的定義，使客戶端對單個對象和組合對象保持一致的方式處理

透明式合成模式

• 與安全式的合成模式不同的是，透明式的合成模式要求所有的具體構件類，不論樹枝構件還是樹葉構件，均符合一個固定接口

• 透明合成模式代碼

/**
 * 抽象構件角色類
 */
public abstract class Component {

    /**
     * 輸出組件自身的名稱
     */
    public abstract void printStruct(String preStr);

    /**
     * 聚集管理方法，增加一個子構件對象
     * @param child 子構件對象
     */
    public void addChild(Component child){
        /**
         * 缺省實現，拋出異常，因爲葉子對象沒有此功能
         * 或者子組件沒有實現這個功能
         */
        throw new UnsupportedOperationException("對象不支持此功能");
    }

    /**
     * 聚集管理方法，刪除一個子構件對象
     * @param index 子構件對象的下標
     */
    public void removeChild(int index){
        /**
         * 缺省實現，拋出異常，因爲葉子對象沒有此功能
         * 或者子組件沒有實現這個功能
         */
        throw new UnsupportedOperationException("對象不支持此功能");
    }

    /**
     * 聚集管理方法，返回所有子構件對象
     */
    public List<Component> getChild(){
        /**
         * 缺省實現，拋出異常，因爲葉子對象沒有此功能
         * 或者子組件沒有實現這個功能
         */
        throw new UnsupportedOperationException("對象不支持此功能");
    }
}

/**
 * 樹枝構件角色類，此類將implements Conponent改爲extends Conponent，其他地方無變化
 */
public class Composite extends Component {

    /**
     * 用來存儲組合對象中包含的子組件對象
     */
    private List<Component> childComponents = new ArrayList<Component>();

    /**
     * 組合對象的名字
     */
    private String name;

    /**
     * 構造方法，傳入組合對象的名字
     * @param name    組合對象的名字
     */
    public Composite(String name){
        this.name = name;
    }

    /**
     * 聚集管理方法，增加一個子構件對象
     * @param child 子構件對象
     */
    public void addChild(Component child){
        childComponents.add(child);
    }

    /**
     * 聚集管理方法，刪除一個子構件對象
     * @param index 子構件對象的下標
     */
    public void removeChild(int index){
        childComponents.remove(index);
    }

    /**
     * 聚集管理方法，返回所有子構件對象
     */
    public List<Component> getChild(){
        return childComponents;
    }

    /**
     * 輸出對象的自身結構
     * @param preStr 前綴，主要是按照層級拼接空格，實現向後縮進
     */
    @Override
    public void printStruct(String preStr) {
        // 先把自己輸出
        System.out.println(preStr + "+" + this.name);
        //如果還包含有子組件，那麼就輸出這些子組件對象
        if(this.childComponents != null){
            //添加兩個空格，表示向後縮進兩個空格
            preStr += "  ";
            //輸出當前對象的子對象
            for(Component c : childComponents){
                //遞歸輸出每個子對象
                c.printStruct(preStr);
            }
        }

    }

}

/**
 * 樹葉構件角色類，此類將implements Conponent改爲extends Conponent，其他地方無變化
 */
public class Leaf extends Component {
    /**
     * 葉子對象的名字
     */
    private String name;
    /**
     * 構造方法，傳入葉子對象的名稱
     * @param name 葉子對象的名字
     */
    public Leaf(String name){
        this.name = name;
    }
    /**
     * 輸出葉子對象的結構，葉子對象沒有子對象，也就是輸出葉子對象的名字
     * @param preStr 前綴，主要是按照層級拼接的空格，實現向後縮進
     */
    @Override
    public void printStruct(String preStr) {
        System.out.println(preStr + "-" + name);
    }

}

/**
 * 透明模式（客戶端）
 */
public class Client {

    public static void main(String[] args) {
        Component root = new Composite("D盤");
        Component favoriteDir = new Composite("收藏夾");
        Component picDir = new Composite("圖片");
        picDir.addChild(new Leaf("美女1.png"));
        picDir.addChild(new Leaf("美女2.png"));


        Component workDir = new Composite("工作");
        workDir.addChild(new Leaf("需求文檔.doc"));
        Component learningDir = new Composite("學習");
        learningDir.addChild(new Leaf("Java筆記.md"));
        learningDir.addChild(new Leaf("數據庫筆記.doc"));

        root.addChild(favoriteDir);
        root.addChild(workDir);
        root.addChild(learningDir);
        root.addChild(picDir);
        root.addChild(new Leaf("log.txt"));

        //Component leaf = new Leaf("test");
        //leaf.addChild(new Leaf("log.txt"));//編譯通過,運行報錯

        root.printStruct("");

    }

}

可以看出，客戶端無需再區分操作的是樹枝對象(Composite)還是樹葉對象(Leaf)了；對於客戶端而言，操作的都是Component對象。

總結

這裏所說的安全性組合模式是指：從客戶端使用合成模式上看是否更安全，如果是安全的，那麼就不會有發生誤操作的可能，能訪問的方法都是被支持的。

這裏所說的透明性組合模式是指：從客戶端使用合成模式上，是否需要區分到底是“樹枝對象”還是“樹葉對象”。如果是透明的，那就不用區分，對於客戶而言，都是Compoent對象，具體的類型對於客戶端而言是透明的，是無須關心的。

對於合成模式而言，在安全性和透明性上，會更看重透明性，畢竟合成模式的目的是：讓客戶端不再區分操作的是樹枝對象還是樹葉對象，而是以一個統一的方式來操作。

而且對於安全性的實現，需要區分是樹枝對象還是樹葉對象。有時候，需要將對象進行類型轉換，卻發現類型信息丟失了，只好強行轉換，這種類型轉換必然是不夠安全的。因此在使用合成模式的時候，建議多采用透明性的實現方式

相關的設計模式

• 組合模式和訪問者模式

可以使用訪問者模式來訪問組合模式中的遞歸結構

使用典範

• java.awt.Container
• java.util.HashMap#putAll
• Java.util.ArrayList#addAll
• org.apache.ibatis.scripting.xmltags.SqlNode/org.apache.ibatis.scripting.xmltags.MixedSqlNode

參考

• 設計模式：組合模式（Composite）
• java模式之合成模式-主要參考文章，推薦閱讀