2. 程式人生 > >不學無數——組合模式

不學無數——組合模式

阿新 • • 發佈：2018-12-09

組合模式

在DebugMybatis的原始碼時，在DynamicSqlSource.getBoundSql動態獲取sql的時候，Debug會發現相同的方法但是進去的實現類卻不相同，不明白為什麼會這樣，於是上網查了資料說是運用了組合的設計模式。

1. 資料結構

聊組合模式為什麼會聊到資料結構呢？看到最後你應該就會明白了

相信大家都知道資料結構這門學科，在資料結構中有樹這樣的概念，樹中會有根節點、葉子節點等等。樹狀的結構在現實生活中應用廣泛，例如我們熟知的XML格式就是一個樹形的結構

說個簡單的例子，在我們身邊常見的，公司的人事管理就是一個典型的樹形結構。

普遍的公司組織架構

根據這個樹形結構，我們可以抽象出來兩種不同性質的點：

  • 有分支的點

    1. 根節點
    2. 樹枝節點

  • 無分支的點：葉子節點

因此按照我們的思路走下去的，那麼可以簡單的抽象出三個介面。

資料結構類圖

這是最直接能夠想到的類圖表示資訊，但是這個類圖資訊目前表示是有些問題的，如果你已經看出來這個類圖的缺陷的話，那麼這一小部分就可以一目十行跳讀過去了。首先我們先寫出三個介面的程式碼：

--根節點
interface IRoot{
     //得到總經理的資訊
    String getInfo();
    //根節點下新增節點，例如總經理下面新增研發部經理
    void add(IBranch branch);
    //根節點下新增葉子節點，比如新增祕書
    void
 
 add(ILeaf leaf);
    //遍歷手下所有人的資訊
    List getSubordinateInfo();
}
--樹枝節點，資訊同上
interface IBranch{
    String getInfo();
    void add(IBranch branch);
    void add(ILeaf leaf);
    List getSubordinateInfo();
}
--葉子節點，因為葉子節點已經是最底層的了，所以不能增加任何資訊，只能獲得自身的資訊
interface ILeaf{
    String getInfo();
}

然後看下IRoot的實現類

class Root implements IRoot{
     //儲存根節點下的子節點資訊
    private List subordinateList=new ArrayList();
    //節點名稱
    private String name;
    //節點的薪資
    private Integer salary;
    //節點的職位
    private String position;

    public Root(String name, Integer salary, String position) {
        this.name = name;
        this.salary = salary;
        this.position = position;
    }

    @Override
    public String getInfo() {
        String info = "";
        info = "名稱: "+this.name;
        info = info + " 職位是: "+ this.position;
        info = info + " 薪水是: "+ this.salary;
        return null;
    }
    //增加樹枝節點
    @Override
    public void add(IBranch branch) {
        subordinateList.add(branch);
    }
    //增加子節點
    @Override
    public void add(ILeaf leaf) {
        subordinateList.add(leaf);
    }
    //得到下級的所有資訊
    @Override
    public List getSubordinateInfo() {
        return this.subordinateList;
    }
}

樹枝節點Branch和葉子節點Leaf的實現和Root的實現方式一樣，這裡就不一一展示了。然後我們所有的節點資訊都寫完了，最後我們的工作就是進行組裝成一個樹狀結構並且遍歷這棵樹。程式碼如下

public static void main(String[] args) {
        //根節點
        IRoot ceo = new Root("王大麻子",100000,"總經理");
        //部門經理,樹枝節點
        IBranch developCeo = new Branch("劉大瘸子",50000,"研發部經理");
        IBranch saleCeo = new Branch("馬二愣子",50000,"銷售部經理");
        IBranch finaceCeo = new Branch("趙三駝子",50000,"財務部經理");
        //組長,樹枝節點
        IBranch developOne = new Branch("吳大棒槌",20000,"研發一組組長");
        IBranch developTwo = new Branch("鄭老六",20000,"研發二組組長");
        //員工,葉子節點
        ILeaf a = new Leaf("開發人員A",1000,"開發");
        ILeaf b = new Leaf("開發人員B",1000,"開發");
        ILeaf c = new Leaf("開發人員C",1000,"開發");
        ILeaf d = new Leaf("開發人員D",1000,"開發");
        ILeaf e = new Leaf("開發人員E",1000,"開發");
        ILeaf f = new Leaf("開發人員F",1000,"開發");
        ILeaf g = new Leaf("銷售人員G",1000,"銷售");
        ILeaf h = new Leaf("銷售人員H",1000,"銷售");
        ILeaf i = new Leaf("財務人員I",1000,"財務");
        ILeaf j = new Leaf("祕書J",1000,"祕書");
        //進行組裝這個組織架構
        //總經理下的三大得力干將
        ceo.add(developCeo);
        ceo.add(saleCeo);
        ceo.add(finaceCeo);
        //總經理下的祕書
        ceo.add(j);
        //研發部經理下的組長
        developCeo.add(developOne);
        developCeo.add(developTwo);
        //銷售部經理下的員工
        saleCeo.add(g);
        saleCeo.add(h);
        //財務部經理下的員工
        finaceCeo.add(i);
        //研發一組下的員工
        developOne.add(a);
        developOne.add(b);
        developOne.add(c);
        //研發二組下的員工
        developTwo.add(d);
        developTwo.add(e);
        developTwo.add(f);
        System.out.println(ceo.getInfo());
        //遍歷總經理下的所有資訊
        getAllSubordinateInfo(ceo.getSubordinateInfo());
    }

    public static void getAllSubordinateInfo(List subordinateList){
        for (int i = 0; i < subordinateList.size(); i++) {
            Object object = subordinateList.get(i);
            if ( object instanceof ILeaf){
                ILeaf leaf = (ILeaf) object;
                System.out.println(leaf.getInfo());
            }
            else {
                IBranch branch = (IBranch) object;
                System.out.println(branch.getInfo());
                //遞迴呼叫
                getAllSubordinateInfo(branch.getSubordinateInfo());
            }
        }
    }

這樣我們就得到了我們想要的樹形結構，列印資訊如下

名稱: 王大麻子 職位是: 總經理 薪水是: 100000
名稱: 劉大瘸子 職位是: 研發部經理 薪水是: 50000
名稱: 吳大棒槌 職位是: 研發一組組長 薪水是: 20000
名稱: 開發人員A 職位是: 開發 薪水是: 1000
名稱: 開發人員B 職位是: 開發 薪水是: 1000
名稱: 開發人員C 職位是: 開發 薪水是: 1000
名稱: 鄭老六 職位是: 研發二組組長 薪水是: 20000
名稱: 開發人員D 職位是: 開發 薪水是: 1000
名稱: 開發人員E 職位是: 開發 薪水是: 1000
名稱: 開發人員F 職位是: 開發 薪水是: 1000
名稱: 馬二愣子 職位是: 銷售部經理 薪水是: 50000
名稱: 銷售人員G 職位是: 銷售 薪水是: 1000
名稱: 銷售人員H 職位是: 銷售 薪水是: 1000
名稱: 趙三駝子 職位是: 財務部經理 薪水是: 50000
名稱: 財務人員I 職位是: 財務 薪水是: 1000
名稱: 祕書J 職位是: 祕書 薪水是: 1000

此時我們會發現，我們有一大坨的程式碼都是公用的，例如每個類中都有getInfo()方法，我們為什麼不把它抽象出來呢，還有為什麼要分根節點和樹枝節點呢，根節點本質上也適合樹枝節點是一樣的。此時我們就能將之前的介面抽象成如下的。

簡化的類圖

介面資訊如下

interface Info{
    String getInfo();
}

interface ILeafNew extends Info{

}

interface IBranchNew extends Info{
    void add(Info info);
    List getSubordinateInfo();
}

其中BranchNew如下

class BranchNew implements IBranchNew{
    private List subordinateList=new ArrayList();
    private String name;
    private Integer salary;
    private String position;

    public BranchNew(String name, Integer salary, String position) {
        this.name = name;
        this.salary = salary;
        this.position = position;
    }

    @Override
    public String getInfo() {
        String info = "";
        info = "名稱: "+this.name;
        info = info + " 職位是: "+ this.position;
        info = info + " 薪水是: "+ this.salary;
        return info;
    }
    //此處將之前的兩個add方法合成了一個,因為葉子節點和樹枝節點都實現了一樣的介面
    @Override
    public void add(Info info) {
        subordinateList.add(info);
    }

    @Override
    public List getSubordinateInfo() {
        return this.subordinateList;
    }
}

其中LeafNew如下

class LeafNew implements ILeafNew{
    private String name;
    private Integer salary;
    private String position;

    public LeafNew(String name, Integer salary, String position) {
        this.name = name;
        this.salary = salary;
        this.position = position;
    }

    @Override
    public String getInfo() {
        String info = "";
        info = "名稱: "+this.name;
        info = info + " 職位是: "+ this.position;
        info = info + " 薪水是: "+ this.salary;
        return info;
    }
}

此時我們經過上面的優化以後還會覺得有些冗雜，因為在LeafNew和BranchNew中還有有一模一樣的程式碼。即兩個類中都有重複的getInfo()方法，實現方式也一樣，此時我們完全可以將其抽象出來。類圖表示如下

再次精簡的類圖

看見這個圖，似乎已經是最完美的了，因為減少了很多的工作量，介面也沒了，改成了抽象類。省了很多的程式碼。具體看程式碼如下

首先看一下抽象類抽象出來的公共東西

abstract class Info{
    private String name;
    private Integer salary;
    private String position;

    public Info(String name, Integer salary, String position) {
        this.name = name;
        this.salary = salary;
        this.position = position;
    }
    public String getInfo() {
        String info = "";
        info = "名稱: "+this.name;
        info = info + " 職位是: "+ this.position;
        info = info + " 薪水是: "+ this.salary;
        return info;
    }
}

抽象類的下面的兩個子類

class BranchNew extends Info{
    private List<Info> subordinateList=new ArrayList();

    public BranchNew(String name, Integer salary, String position) {
       super(name,salary,position);
    }

    //此處將之前的兩個add方法合成了一個,因為葉子節點和樹枝節點都實現了一樣的介面
    public void add(Info info) {
        subordinateList.add(info);
    }

    public List getSubordinateInfo() {
        return this.subordinateList;
    }
}

class LeafNew extends Info{
    public LeafNew(String name, Integer salary, String position) {
       super(name,salary,position);
    }
}

而此時在建立樹形結構的時候如下，和之前建立的沒多大的差別。

public static void main(String[] args) {
        BranchNew ceo = new BranchNew("王大麻子",100000,"總經理");
        //部門經理,樹枝節點
        BranchNew developCeo = new BranchNew("劉大瘸子",50000,"研發部經理");
        BranchNew saleCeo = new BranchNew("馬二愣子",50000,"銷售部經理");
        BranchNew finaceCeo = new BranchNew("趙三駝子",50000,"財務部經理");
        //組長,樹枝節點
        BranchNew developOne = new BranchNew("吳大棒槌",20000,"研發一組組長");
        BranchNew developTwo = new BranchNew("鄭老六",20000,"研發二組組長");
        //員工,葉子節點
        LeafNew a = new LeafNew("開發人員A",1000,"開發");
        LeafNew b = new LeafNew("開發人員B",1000,"開發");
        LeafNew c = new LeafNew("開發人員C",1000,"開發");
        LeafNew d = new LeafNew("開發人員D",1000,"開發");
        LeafNew e = new LeafNew("開發人員E",1000,"開發");
        LeafNew f = new LeafNew("開發人員F",1000,"開發");
        LeafNew g = new LeafNew("銷售人員G",1000,"銷售");
        LeafNew h = new LeafNew("銷售人員H",1000,"銷售");
        LeafNew i = new LeafNew("財務人員I",1000,"財務");
        LeafNew j = new LeafNew("祕書J",1000,"祕書");
        //進行組裝這個組織架構
        //總經理下的三大得力干將
        ceo.add(developCeo);
        ceo.add(saleCeo);
        ceo.add(finaceCeo);
        //總經理下的祕書
        ceo.add(j);
        //研發部經理下的組長
        developCeo.add(developOne);
        developCeo.add(developTwo);
        //銷售部經理下的員工
        saleCeo.add(g);
        saleCeo.add(h);
        //財務部經理下的員工
        finaceCeo.add(i);
        //研發一組下的員工
        developOne.add(a);
        developOne.add(b);
        developOne.add(c);
        //研發二組下的員工
        developTwo.add(d);
        developTwo.add(e);
        developTwo.add(f);
        System.out.println(ceo.getInfo());
        getAllList(ceo);
    }

遍歷的程式碼稍微有些變化

public static void getAllList(BranchNew branchNew){
    List<Info> subordinateInfo = branchNew.getSubordinateInfo();
    for (Info info:subordinateInfo){
        if (info instanceof LeafNew){
            System.out.println(info.getInfo());
        }else {
            System.out.println(info.getInfo());
            getAllList((BranchNew) info);
        }
    }
}

此時發現執行結果和之前的結果一模一樣，這就是組合模式

2. 什麼是組合模式

在剛才的資料結構中我們用程式碼實現了樹形結構。這個就是組合模式。組合模式主要是用來描述部分與整體的關係。

將物件組合成樹形結構以表示“部分-整體”的層次結構，使得使用者對單個物件和組合物件的使用具有一致性

2.1 組合模式的組成

其實我們在上面已經實現了一個組合模式，組合模式的組合就是資料結構中樹形結構的組成並且將其程式碼簡化，抽象出來樹枝節點和葉子節點的公共部分形成抽象類或者介面，並且通過呼叫此抽象類或者介面將組合物件和簡單物件進行一致的處理。

組合模式的類圖

其中組合模式涉及到了三個角色

  • Component：抽象構件，定義了參加組合物件的共有方法和屬性。當然也可以定義為介面
  • Leaf：葉子節點構件，組合模式中最小的遍歷單位
  • Composite：樹枝節點構件，與葉子節點構成一個樹形結構

接下來我們可以寫出實際的組合模式程式碼示例，首先可以先看抽象的構建，它是組合模式的精髓所在

public abstract class Component{
    //無論是個體還是整體都是共享此程式碼的
    public void doSomething(){
    //具體的業務邏輯程式碼
    }
}

Composite類

class Composite extends Component{
    List<Component> list = new ArrayList<>();
    void add(Component component){
        list.add(component);
    }
    void remove(Component component){
        list.remove(component);
    }
    List<Component> getChild(){
        return list;
    }
}

通用Leaf類可以重寫父類的方法。

通過建立場景類模擬建立樹狀的資料結構，並且通過遞迴的方式遍歷整個樹

public static void main(String[] args) {
    Composite root = new Composite();
    root.doSomething();
    LeafM leafM = new LeafM();
    Composite branch = new Composite();
    root.add(branch);
    branch.add(leafM);
}
//通過遞迴遍歷樹
public static void display(Composite composite){
    for (Component component : composite.getChild()){
        if (component instanceof LeafM){
            component.doSomething();
        }else {
            display((Composite) component);
        }
    }
}

2.2 透明組合模式

組合模式分為兩種，一種是安全模式，一種是透明模式。我們上面講的是安全模式，那麼透明模式是什麼呢？可以看下透明模式的類圖。

透明模式類圖

通過類圖的對比我們便可知道，透明模式是將方法都放在抽象類中或者介面中。透明模式下的葉子節點和樹枝節點都會有相同的結構，通過判斷是否他下面還有子節點可以知道是葉子節點還是樹枝節點。

3. MyBatis中的組合模式應用

此時我們學完了組合模式以後就知道了在Mybatis中動態組裝Sql中用到了組合模式，那麼Mybatis是如何應用的呢。比如下面的一段Sql。

<select id="queryAllDown" resultType="map" parameterType="String">
    select * from 表名 where  cpt_pro=#{cpt}
    <if test="cpt!=''">
    and cpt_pro=#{cpt}
    </if>
</select>

Mybatis在進行XML解析的時候會解析兩個標籤，一個是select一個是if，然後通過SqlNode進行解析標籤中的內容，下面是SqlNode中的實現類

SqlNode中的實現類

這些類就構成了SqlNode樹形結構中的各個節點。所有的子節點都是同一類節點，可以遞迴的向下執行。例如StaticTextSqlNode是最底層的節點，因此它直接將Sql拼接到sqlBuilder中。

  @Override
  public boolean apply(DynamicContext context) {
    for (SqlNode sqlNode : contents) {
      sqlNode.apply(context);
    }
    return true;
  }

而如果是碰到了if標籤，那麼可以看IfSqlNode，在IfSqlNode中會先做表示式的判斷，如果通過的話，那麼進行呼叫遞迴解析。如果不通過就直接跳過。

@Override
public boolean apply(DynamicContext context) {
if (evaluator.evaluateBoolean(test, context.getBindings())) {
  contents.apply(context);
  return true;
}
return false;
}

因此Mybatis就是通過組合模式以一致的方式處理個別對象或者是帶有標籤的物件。

4. 參考文章

相關推薦

不學無數——組合模式

組合模式 在DebugMybatis的原始碼時，在DynamicSqlSource.getBoundSql動態獲取sql的時候，Debug會發現相同的方法但是進去的實現類卻不相同，不明白為什麼會這樣，於是上網查了資料說是運用了組合的設計模式。 1. 資料

不學無數——裝飾模式

裝飾模式 在開始之前 我們可以用一個簡單的例子引出來裝飾模式，在小的時候，相信大家都有過這樣的經歷：小學每年會有好幾次的考試，如果有一次成績非常差，而且考完以後學校會有個很損的招，就是打印出來成績單，然後讓家長簽字。那麼拿著這個成績單，肯定是不會直接告訴家長成績什麼的，肯定是會加一些，例如，

不學無數——Java代理模式

1. 代理 Provide a surrogate or placeholder for another object to control access to it（為其他物件提供一種代理以控制對這個物件的訪問） 1.1 什麼是代理 代理是基本的設計模式之一，它是你為了提供額外或者不同的行為，而插入的用

不學無數——Java中IO和NIO

JAVA中的I/O和NIO I/O 問題是任何程式語言都無法迴避的問題，可以說 I/O 問題是整個人機互動的核心問題，因為 I/O 是機器獲取和交換資訊的主要渠道。在當今這個資料大爆炸時代，I/O 問題尤其突出，很容易成為一個性能瓶頸。 什麼是I/O I/O ? 或者輸入/輸出

不學無數——SpringBoot入門Ⅷ

SpringBoot--Actuator 1. 初識Actuator 在開發過程中，專案被放置到生產伺服器上執行時，有可能需要我們全方位的監控應用服務的執行情況。此時SpringBoot提供了Actuator模組進行監控和管理 2. 使用方法 在gradle中新增依賴 compi

不學無數——SpringBoot入門Ⅶ

SpringBoot 1.建立自己的Auto-configuration 無論是在公司中你想開發自己的一套框架，定製一些東西，或者是在開源網站中分享自己做的一些東西。你可能想要開發屬於自己的Auto-configuration。Auto-configuration的類能夠捆綁到外部的jar包

不學無數——SpringBoot入門VI

SpringBoot 1 連線資料庫 Spring框架為連線資料庫提供了許多的幫助，從JDBC連線到使用JdbcTemplate完成元素之間的對映技術。例如Hibernate、Spring Data提供了更高級別的功能，建立Repository的實現，用介面中的方法和xml檔案具體SQL的對

不學無數——SpringBoot入門V

SpringBoot 1.開發一個Web程式 SpringBoot是非常適合開發Web應用的，因為他內嵌有Tomcat、Jetty、Undertow或者Netty。大部分的應用可以通過載入spring-boot-starter-web模組能夠快速的建立並啟動一個Web應用。 1.1Spr

不學無數——SpringBoot入門IV

SpringBoot 1.Profiles Spring Profiles能夠在不同的環境中使不同的應用配置生效。@Component和@Configuration兩個註解都能夠通過@Profiles來標記。下面是例子： @Configuration @Profile("buxuewus

不學無數——SpringBoot入門Ⅲ

SpringBoot-外部資源的配置 1.外部資源的配置優先順序 為了能夠在不同的環境執行不同的配置檔案，或者有些程式碼的一些變數是跟隨著環境的改變而改變的，這時候就需要在外部做一些配置。SpringBoot允許這麼做，並且有一套配置規則。可以通過@Value註解進行將一些變數動態的取出來。

不學無數——SpringBoot入門Ⅱ

SpringBoot 1.Starters Starters是一套技術，是什麼技術呢？是SpringBoot整理出來，人們經常要用的技術。有了starters人們在想要使用這些技術的時候，就不用扒之前的老程式碼將那些依賴啊或者配置的都拷貝過來，只需要加上SpringBoot提供的依賴就行，它

不學無數——SpringBoot入門Ⅰ

SpringBoot 1.SpringBoot簡介 在剛接觸SSM框架的時候，想必都會被這個框架的配置檔案所煩擾，需要自己手動配置的東西非常多，哪怕有些東西自己不需要也是需要配置的。而SpringBoot此時就應運而生，減少了大家的配置過程。相信都聽過“約定優於配置”的這樣一句話，就是說系統

不學無數——反射和內省的區別

反射和內省的區別 內省是基於反射實現的，主要用來操作JavaBean，通過內省可以很方便的動態獲得bean的set/get方法，屬性，方法名，他相當於是反射的工具類一樣 1. 反射 反射其實簡單來說就是通過類的名字獲得對於這個類的描述，這種描述包括方法、構造器、屬性的描述。

不學無數——初識反射

反射：執行時的類資訊 執行時型別資訊使得你可以在程式執行時發現和使用型別資訊 1. Class物件 通過Class物件可以在執行時發現一個物件完整的類繼承結構 類是程式的一部分，每一個類都會有一個Class物件。換句話說既每編寫一個新的類，就會產生一個Cl

不學無數——Gson原始碼解析

Gson 在用Gson解析時傳過來的Json串時，如果將其解析為物件A，而這個物件A繼承了物件B。這兩個物件都有屬性名為name的值，那麼在進行解析的時候就會報如下錯誤。 Exception in thread "main" java.lang.IllegalArgumentExceptio

不學無數——InterruptedException異常

InterruptedException異常 在瞭解InterruptedException異常之前應該瞭解以下的幾個關於執行緒的一些基礎知識。 執行緒的狀態 執行緒在一定的條件下會發生狀態的改變，下面是執行緒的一些狀態 <center><img src="http://p9jfg

不學無數——Java動態代理

動態代理 1. 什麼是動態代理 在上一章節中，我們講的是代理其實都是靜態代理，動態代理是在執行階段動態的建立代理並且動態的處理對所代理方法的呼叫。在動態代理上所做的所有呼叫都會被重定向到單一的呼叫處理器中。在現在很流行的Spring中有一個AOP（面向切面）的其中核心實現技術就是動態代理的技術。 2. 為什麼

不學無數——Mybatis自動對映器Mapper原理分析

在使用MyBatis時，有時候會想，為什麼只寫一個介面沒有編寫任何的實現類，但是就能返回介面的例項，並且呼叫介面的方法返回資料庫中的資料？此時腦海中浮現了寫動態代理時候的記憶，記得動態代理也是接管了介面，不需要實際的代理角色。然後經過原始碼的Debug發現果然是

不學無數——Spring注入後反射的空指標異常

Spring注入後反射的空指標異常 自動裝配是在spring環境下當使用該類的例項時由spring容器完成了類的例項化過程，包括對依賴物件的例項化過程。 而通過反射建立例項時，是根據你呼叫的建構函式完成的例項化過程，沒有容器的自動化建立例項了，所以需要自己

自我聯想學設計模式（初級版）-4-組合模式

WHAT？ 既然說了是組合，那麼肯定參與組合的不止一個，是多個。但是不是任意物件組合起來都可以成為組合模式呢？ 其實不然。 這多個物件，它們彼此之間必須有“整體/部分”的關係，並且你想用一致的方式對待這些兌現時，你就需要組合模式。 那麼所謂的“整體/部分”關係，指的是什麼呢？