教程簡介

1、閱讀物件
本篇教程適合新手閱讀，老手直接略過
2、教程難度
初級，本人水平有限，文章內容難免會出現問題，如果有問題歡迎指出，謝謝
3、Demo 地址：

正文

一、什麼是建造者模式

1、生活中的建造者模式

1、蓋房子

我們在生活中蓋房子，一般就是打地基，蓋框架「用磚頭或鋼筋混凝土」，然後是粉刷。基本上就是這個路子。當然我們這些工作全部可以自己做，可也以找幾個工人去幹，當然還可以可以直接找一個設計師，直接說我就要這樣的房子，然後就不管了，最後問設計師「設計師給一張紙給工人，工人就啪啪的幹了」驗收房子即可「至於你是如何建的過程我不關心，我只要結果」—這就是建造者模式

2、組裝電腦

我們買的電腦都是由主機板、記憶體、cpu、顯示卡等組成，如何把這些東西組裝起來給使用者這就是建造者模式的作用，不同的人對電腦的配置需求不一樣的「打遊戲的對顯示卡要求高」，但是電腦構成部件是固定的，我們找電腦城的裝機人員把電腦裝起來這一過程就是建造模式

3、軟體開發

我們開發一款產品，需要技術主管、產品經理、苦逼的程式設計師。在這裡，產品經理就是指揮者「Director」和客戶溝通，瞭解產品需求，技術主管是抽象的建造者[Builder]，讓猿們雜做就雜做，而程式設計師就是體力勞動者「即具體的建造者，按照技術主管下發的任務去做」— 這就是一個接近完美的建造者模式「為什麼說接近呢？因為沒有百分之百，靠：又忘記吃藥了」

2、程式中的建造者模式

建造者模式的定義

將一個複雜物件的構建與它的表示分離，使得同樣的構建過程可以建立不同的表示，這是官方定義，通俗的說就是：建造者模式就是如何一步步構建一個包含多個組成部件的物件，相同的構建過程可以建立不同的產品

建造者模式的特點

建造者模式是一種建立型模式，適用於那些流程固定「順序不一定固定」，建造的目標物件會有所改變這種場景「比如畫一條狗，這個目標不變，但是不同的是有黃狗，胖狗，瘦狗等」，還有一種場景是代替多引數構造器

建造者模式的作用

1、使用者不知道物件的建造過程和細節就可以建立出複雜的物件「遮蔽了建造的具體細節」
2、使用者只需給出複雜物件的內容和型別可以建立出物件
3、建造者模工按流程一步步的建立出複雜物件

建造者模式的結構

角色	類別	說明
Builder	介面或抽象類	抽象的建造者，不是必須的
ConcreateBuilder	具體的建造者	可以有多個「因為每個建造風格可能不一樣」
Product	普通的類	具體的產品「即被建造的物件」
Director	導演也叫指揮者	統一指揮建造者去建造目標，導演不是必須的

建造者模式簡單的 UML

二、建造者模式的舉例

1、組裝電腦

小明想組裝一個臺式電腦，小明對電腦配置一竅不通，就直接跑到電腦城給裝機老闆說我要一臺打遊戲非常爽的電腦，麻煩你給裝一下「配置什麼的你給我推薦一下吧」，於是老闆就讓它的員工「小美」按小明的要求裝了一個效能灰常牛 B 的電腦，1 個小時後電腦裝好了，小明交錢拿電腦走人。不一會兒小張又來了，要一個滿足平時寫文章就可以的電腦，老闆針對小張的要求給不同的裝機配置。不同的人有不同的配置方案「但是裝機流程是一樣的」，這就是一個典型的建造者模式

組裝電腦簡單的 UML

根據 UML 擼碼

1、建立被建造的物件電腦 — Computer.java

/**
 * Created by TigerChain
 * 產品類--被建造的物件
 */
public class Computer {
    private String cpu ; // cpu
    private String hardDisk ; //硬碟
    private String mainBoard ; // 主機板
    private String memory ; // 記憶體
    ... 省略 getter 和 setter
}

2、抽象的建造者 — Builder.java

/**
 * Created by TigerChain
 * 抽象的建造者，即裝電腦的步驟
 * 至於安裝什麼型號的主機板，不是我關心，而是具體的建造者關心的
 */
public interface Builder {
    // 安裝主機板
    void createMainBoard(String mainBoard) ;
    // 安裝 cpu
    void createCpu(String cpu) ;
    // 安裝硬碟
    void createhardDisk(String hardDisk) ;
    // 安裝記憶體
    void createMemory(String memory) ;
    // 組成電腦
    Computer createComputer() ;
}

3、具體建造者，也就是裝機工人小美 — AssemblerBuilder.java

/**
 * Created by TigerChain
 * 具體的建造者，這裡是商場的一個裝機人員
 */
public class AssemblerBuilder implements Builder {

    private Computer computer = new Computer() ;
    @Override
    public void createCpu(String cpu) {
        computer.setCpu(cpu);
    }

    @Override
    public void createhardDisk(String hardDisk) {
        computer.setHardDisk(hardDisk);
    }

    @Override
    public void createMainBoard(String mainBoard) {
        computer.setMainBoard(mainBoard);
    }

    @Override
    public void createMemory(String memory) {
        computer.setMemory(memory);
    }

    @Override
    public Computer createComputer() {
        return computer;
    }
}

4、還有老闆「“指手畫腳的人”」安排裝機工工作 — Direcror.java

/**
 * Created by TigerChain
 * 宣告一個導演類「指揮者，這裡可以裝電腦的老闆」，用來指揮組裝過程，也就是組裝電腦的流程
 */
public class Director {
    private Builder builder ;
	// 使用多型，裝機工非常多，我管你小美，小蘭，小豬，我統統收了
    public Direcror(Builder builder){
        this.builder = builder ;
    }
	// 老闆最後只想看到裝成的成品---要交到客戶手中
    public Computer createComputer(String cpu,String hardDisk,String mainBoard,String memory){
        // 具體的工作是裝機工去做
        this.builder.createMainBoard(mainBoard);
        this.builder.createCpu(cpu) ;
        this.builder.createMemory(memory);
        this.builder.createhardDisk(hardDisk);
        return this.builder.createComputer() ;
    }
}

5、測試類

/**
 * Created by TigerChain
 * 測試類
 */
public class Test {
  public static void main(String args[]){
	  // 裝機員小美
      Builder builder = new AssemblerBuilder() ;
      // 老闆把小明的需求轉給小美
      Direcror direcror = new Direcror(builder) ;
      // 老闆最後拿到成品機子，工作全由小美去做
      Computer computer = direcror.createComputer("Intel 酷睿i9 7900X","三星M9T 2TB （HN-M201RAD）","技嘉AORUS Z270X-Gaming 7","科賦Cras II 紅燈 16GB DDR4 3000") ;
      System.out.println("小明這臺電腦使用的是：n"+computer.getMainBoard()+" 主機板
"+computer.getCpu()+" CPUn"+computer.getHardDisk()+"硬碟n"+computer.getMainBoard()+" 記憶體n");

  }
}

6、執行檢視結果

怎麼樣，至於小張，小豬要裝機把自己要的配置給老闆即可，然後老闆如何裝機不用你管，你就等著收裝好的機子吧

2、蓋房子

蓋房子的基本步驟和流程是固定的無非就是打地基、蓋框架、然後澆築「至於蓋平房、還是樓房那是每個客戶的具體需求」。總體來說蓋房子以有以三種方式：

1、自己蓋房子「沒有辦法有的人就是牛 B ,自己設計，自己動手，當然這屬於小房子，你讓一個人蓋個32 層讓我看看」
2、想蓋房子的人是一個包工頭，自己找一幫工人自己就把房子搞定了
3、想蓋房子的人就是一個普通人，啥也不會，找一個設計師說“我就要蓋個房子，南北通透，四秀常春”，設計師說沒有問題，設計師把設計出來的圖紙扔給包工頭說：“就照這個樣子蓋”，包工頭拿著圖紙給工人們分工派活，最後完工

蓋房子建造者模式簡單的 UML

根據 UML 擼碼

1、房子物件 House.java

/**
 * Created by TigerChain
 * 最終的產品---房子
 */
public class House {
    // 打地基
    private String foundation ;
    // 蓋框架
    private String frame ;
    // 澆築
    private String pouring ;
    ... 省略 setter 和 getter 
}

2、抽象建造者「包工頭」 HouseBuilder.java

public interface HouseBuilder {
    // 打地基
    void doFoundation() ;
    // 蓋框架
    void doFrame() ;
    // 澆灌
    void dpPouring() ;
    // 房子建成 
    House getHouse() ;
}

3、具體建造者「工人」–蓋平房 PingFangBuilder.java

/**
 * Created by TigerChain
 * 蓋平房
 */
public class PingFangBuilder implements HouseBuilder {

    private House house = new House() ;

    @Override
    public void doFoundation() {
        house.setFoundation("蓋平房的地基");
    }

    @Override
    public void doFrame() {
        house.setFrame("蓋平房的框架");
    }

    @Override
    public void dpPouring() {
        house.setPouring("蓋平房不用澆灌，直接人工手刷就可以");
    }

    @Override
    public House getHouse() {
        return house;
    }
}

4、具體建造者「工人」–蓋樓房 LouFangBuilder.java

/**
 * Created by TigerChain
 * 蓋樓房
 */
public class LouFangBuilder implements HouseBuilder {

    private House house = new House() ;
    @Override
    public void doFoundation() {
        house.setFoundation("蓋樓房的地基就打十米深");
    }

    @Override
    public void doFrame() {
        house.setFrame("樓房的框架要使用非常堅固鋼筋混凝土");
    }

    @Override
    public void dpPouring() {
        house.setPouring("樓房拿個罐車把框架拿混凝土灌滿即可");
    }

    @Override
    public House getHouse() {
        return house;
    }
}

5、指揮者「設計師」 HouseDirector.java

/**
 * Created by TigerChain
 * 設計師
 */
public class HouseDirector {
    // 指揮包工頭
    public void buildHouse(HouseBuilder houseBuilder){
        houseBuilder.doFoundation();
        houseBuilder.doFrame();
        houseBuilder.dpPouring();
    }
}

6、測試一下 Test.java

/**
 * Created by TigerChain
 * 測試
 */
public class Test {
    public static void main(String args[]){

        // 方式一、客戶自己蓋房子，親力親為
        System.out.println("========客戶自己建房子，必須知道蓋房的細節========");
        House house = new House() ;
        house.setFoundation("使用者自己建造房子：打地基");
        house.setFrame("使用者自己建造房子：蓋框架");
        house.setPouring("使用者自己建造房子：澆築");

        System.out.println(house.getFoundation());
        System.out.println(house.getFrame());
        System.out.println(house.getPouring());


        // 方式二、客戶找一個建造者蓋房子「充當包工頭角色」，但是要知道如何蓋房子「呼叫建造者蓋房子的順序」
        System.out.println("========客戶直接找蓋房子的工人「建造者」，客戶要呼叫建造者方法去蓋房子，客戶必須得知道房子如何造========");

        HouseBuilder houseBuilder = new PingFangBuilder() ;
        houseBuilder.doFoundation();
        houseBuilder.doFrame();
        houseBuilder.dpPouring();
        House house1 = houseBuilder.getHouse() ;
        System.out.println(house1.getFoundation());
        System.out.println(house1.getFrame());
        System.out.println(house1.getPouring());

        // 方式三、使用建造者模式，找一個設計師「設計師拉一幫建造者去幹活」，告訴他我想要什麼樣的房子，最後客戶只問設計師要房子即可
        System.out.println("========客戶直接找一個設計師，設計師統一指揮建造者蓋房子，房子雜蓋，客戶不關心，最後只是找設計師要房子即可========");

        HouseBuilder pingFangBuilder = new PingFangBuilder() ;
        HouseDirector houseDirector = new HouseDirector() ;
        houseDirector.buildHouse(pingFangBuilder);
        House houseCreateByBuilder = pingFangBuilder.getHouse() ;

        System.out.println(houseCreateByBuilder.getFoundation());
        System.out.println(houseCreateByBuilder.getFrame());
        System.out.println(houseCreateByBuilder.getPouring());
    }
}

我們對比了三種方式，自己蓋房子，找工人蓋房子，找設計師蓋房子來逐步感受一下建造者模式的優點

6、執行檢視結果

可以看到最後一種最舒服，蓋房子的時候直接外包給設計師自己就不用管了，到時候問設計師要建好的成品房子即可，這樣對客戶來說具體如何蓋房子我不需要知道，遮蔽細節「只能說有錢就是任性」

3、替代多引數建構函式的建造者模式，以組裝電腦為例子

前面我們說了在建造者模式中 Director 不是必須的，Director 的作用不是構造產品「建造產品是建造者的事情」而是指揮協調建造的步驟「當有一個新的建造者的時候直接實現抽象建造者，而不用關心具體的執行步驟，這就是 Director 乾的事情」，我們直接看程式碼吧

1、原始的 Computer.java

public class Computer {
    private String mainBoard ;     // 主機板
    private String cpu ;           // cpu
    private String hd ;            // 硬碟
    private String powerSupplier ; // 電源
    private String graphicsCard;   // 顯示卡

    // 其它一些可選配置
    private String mouse ; // 滑鼠
    private String computerCase ; //機箱
    private String mousePad ;   //滑鼠墊
    private String other ;  //其它配件


    public Computer(String mainBoard,String cpu,String hd,String powerSupplier,
                      String graphicsCard,String mouse,String computerCase,String mousePad,String other){
        this.mainBoard = mainBoard ;
        this.cpu = cpu ;
        this.hd = hd ;
        this.powerSupplier = powerSupplier ;
        this.graphicsCard = graphicsCard ;
        this.mouse = mouse ;
        this.computerCase = computerCase ;
        this.mousePad = mousePad ;
        this.other = other ;
    }

    public Computer(String mainBoard,String cpu,String hd,String powerSupplier,
                    String graphicsCard,String mouse,String computerCase,String mousePad){
        this.mainBoard = mainBoard ;
        this.cpu = cpu ;
        this.hd = hd ;
        this.powerSupplier = powerSupplier ;
        this.graphicsCard = graphicsCard ;
        this.mouse = mouse ;
        this.computerCase = computerCase ;
        this.mousePad = mousePad ;
    }
    ... 省略其它的構造方法和 setter 和 getter 方法
}

如果我們想要呼叫這個類就得在構引數方法中傳遞“無數個引數”「如果有的參是一些可選項，我們還得重寫構造方法」，要麼就要呼叫多個 setter 方法，才能給一個物件賦值，方法雖然可行，但是也太扯淡了「誰能記住那些引數呀」，那麼建造者模式可以解決多引數構造方法來建造物件

2、使用建造者建立 ComputerB.java

/**
 * Created by TigerChain
 * 替代多參構造方法--建造者模式
 */
public class ComputerB {

    private String mainBoard ;     // 主機板
    private String cpu ;           // cpu
    private String hd ;            // 硬碟
    private String powerSupplier ; // 電源
    private String graphicsCard;   // 顯示卡

    // 其它一些可選配置
    private String mouse ; // 滑鼠
    private String computerCase ; //機箱
    private String mousePad ;   //滑鼠墊
    private String other ;  //其它配件

	// ComputerB 自己充當 Director 
    private ComputerB(ComputerBuilder builder) {
        this.mainBoard = builder.mainBoard ;
        this.cpu = builder.cpu ;
        this.hd = builder.hd ;
        this.powerSupplier = builder.powerSupplier ;
        this.graphicsCard = builder.graphicsCard ;

        this.mouse = builder.mouse ;
        this.computerCase = builder.computerCase ;
        this.mousePad = builder.mousePad ;
        this.other = builder.other ;
    }
	// 宣告一個靜態記憶體類 Builder
    public static class ComputerBuilder{
        // 一個電腦的必須配置
        private String mainBoard ;     // 主機板
        private String cpu ;           // cpu
        private String hd ;            // 硬碟
        private String powerSupplier ; // 電源
        private String graphicsCard;   // 顯示卡

        // 其它一些可選配置
        private String mouse ; // 滑鼠
        private String computerCase ; //機箱
        private String mousePad ;   //滑鼠墊
        private String other ;  //其它配件

		// 這裡宣告一些必須要傳的引數「規定這些引數是必須傳的，這裡只是舉例，再實中可能引數都是可選的」
        public ComputerBuilder(String mainBoard,String cpu,String hd,String powerSupplier,String graphicsCard){
            this.mainBoard = mainBoard ;
            this.cpu = cpu ;
            this.hd = hd ;
            this.powerSupplier = powerSupplier ;
            this.graphicsCard = graphicsCard ;
        }

        public ComputerBuilder setMainBoard(String mainBoard) {
            this.mainBoard = mainBoard;
            return this ;
        }

        public ComputerBuilder setCpu(String cpu) {
            this.cpu = cpu;
            return this ;
        }

       	... 其它的一些 setXXX() 方法
		
		// 生成最終的產品
        public ComputerB build(){
            return new ComputerB(this) ;
        }
    }
}

程式碼註釋非常詳細，乍一看好像和建造者模式沒有毛關係，但是我們細細一分析這個確實是一個建造者模式，我們看一看：產品是–>ComputerB,具體的建造者是一個靜態記憶體類–>ComputerBuilder,但是沒有抽象的建造者和指揮者「其實 ComputerB 充當的就是指揮者的角色」，我們說過建造者模式中指揮者和抽象建造者都不是必須的，所以這是一個典型的建造者模式

3、如何呼叫來個測試類 Test.java

public class Test {
    public static void main(String args[]){

        // 不使用建造者模式
        Computer computer = new Computer("主機板","cpu","hd","電源","顯示卡"
        ,"滑鼠","機箱","滑鼠墊") ;
        System.out.println("使用普通的構造方法組裝電腦："+computer.toString());

        // 使用建造者模式
        ComputerB computerB = new ComputerB.ComputerBuilder("主機板","cpu","hd","電源","顯示卡")
                .setMouse("滑鼠").setMousePad("墊子").build() ;
        System.out.println("使用建造者模式組裝電腦："+computerB.toString());
    }
}

我們分別使用普通構造方法「呼叫者能吐血」和建造者模式組裝電腦，可以看到建造者模式呼叫 new ComputerB.ComputerBuilder(xxx).setxxx().setxxx().build() 呼叫方法直接打點呼叫「也叫流式呼叫，這樣呼叫方便多了，想點那個就點那個」，如果使用過 rx 的話會非常有感覺

4、執行檢視一下結果

如果在以後如果遇到多引數構造物件的時候不仿考慮使用建造者模式

三、Android 原始碼中的建造者模式

1、AlertDialog

做 Android 的朋友一定不會對 AlertDialog 陌生，它是一個可以新增列表、單選列表、文字輸入框，多選列表等彈窗元件，內部使用的是典型的建造者模式，我們看看 AlertDialog 的基本使用方法

// 建立構建器
   AlertDialog.Builder builder = new AlertDialog.Builder(this);
// 使用建造者模式代替多參建構函式
   Dialog dialog= builder.setTitle(XXX).setIcon(XXX).setXXX(xxx).create() ;
   dialog.show() ;

AlertDialog 簡單的 UML

AlertDialog 核心程式碼剝離

上圖明顯的顯示出了 AlertDialog 的建造者模式「AlertDialog.Builder 同時扮演了 Builder、ConcreateBuilder、Director 等角色」

2、Notification 的 setLatestEventInfo 方法「過時了，但是思想可以學習」

我們看看 Notification 的 setLatestEventInfo 一看便知道使用的是建造者模式，我們看下圖

以上的方法被 Notification.Builder 替代了「setLatestEventInfo 從終也是呼叫 Notification.Builder」，真正的建造者模式是 Notification.Builder

如果要支援到低版本可以使用 android.support.v4.app.NotificationCompat.Builder 來建立 Notification 名字一看又是一個建造者模式，感興趣的可以看看 NotificationCompat.Builder 的原始碼

3、AnimatorSet.Builder

AnimatorSet 用作將一個動畫集合按選定的順序執行，我們可以使用 AnimatorSet.Builder 新增播放動畫順序「這只是其中一個方法」

使用方法舉例

AnimatorSet animSet = new AnimatorSet();  
//AnimatorSet.Builder 不能直接建立 ，只能透過 play(Animation)
AnimatorSet.Builder builder = animSet.play(anim2);  
builder.with(anim3).after(anim1).before(anim4);// anim1先執行，然後再同步執行anim2、anim3，最後執行anim4  
animSet.setDuration(200);  
animSet.start();

核心程式碼

四、建造者模式的優缺點

優點

1、使建立產品的步驟「把建立產品步驟放在不同的方法中，更加清晰直觀」和產品本身分離，即使用相同的建立過程要吧建立出不同的產品
2、每個建造者都是獨立的互不影響，這樣就達到解耦的目的，所以如果想要替換現有的建造者那非常方便，新增一個實現即可。

缺點

1、只適用於產品具有相同的特點「過程和步驟」，如果產品之間差異非常大，則不適用「使用範圍受限」
2、萬一那天產品內部發生改變，那多個建造者都要修改，成本太大

五、建造者模式的使用場景

1、如果一個物件有非常複雜的內部結構「這些產品通常有很多屬性」，那麼使用建造者模式
2、如果想把複雜物件的建立和使用分離開來，那麼使用建造者模式「使用相同的建立步驟可以建立不同的產品」

六、建造者模式 VS 簡單工廠模式

相似點

它們都屬於建立型模式「都是建立產品的」

區別

1、建立物件的粒度不同

工廠模式建立的物件都是一個鳥樣子，而建造者模式建立的是一個複合產品，由各個複雜的部件組成，部件不同所構成的產品也不同

2、關注點不同：

工廠模式注重只要把這個物件建立出來就 o 了「不關心這個產品的組成部分」，而建造者模式不似要創造出這個產品，還有知道這個產品的組成部分

到此為止，我們就介紹完了建造者模式，一定要動手試一下，關注博主有更多精彩的文章等著你，順便伸出你的小手點一個贊吧。

人人都會設計模式： 07、建造者模式--Builder