設計模式（9）工廠模式（講解+應用）

目錄

1. 工廠模式

2. 爲何使用工廠模式

3. 應用實例

工廠模式

工廠模式：是一種經常使用的對象建立型設計模式,此模式的核心精神是封裝類中不變的部分，提取其中個性化善變的部分爲獨立類，經過依賴注入以達到解耦、複用和方便後期維護拓展的目的。它的核心結構有四個角色，分別是抽象工廠；具體工廠；抽象產品；具體產品

這裏所提到的依賴注入，對於依賴的建立思想又引出一個概念：依賴倒置即爲高層組件再也不依賴底層組件，而底層組件也再也不依賴高層組件，而是出現一個工廠類，高底層組建依賴於這個工廠類。下面針對具體的例子來進行講解。

爲何使用工廠模式

工廠，生產物品的地方。工廠模式就是用來建立對象，生產對象的。通常，咱們會經過new來進行對象的建立，一旦經過new，那麼就必定會有具體的實例出現，也就會使得該對象和當前類出現緊耦合，產生依賴，使得咱們代碼的可擴展性和靈活性都變低。繼續咱們上篇文章中工廠生產機器的例子。

//機器裝配的基類
public abstract class Machine{
//機器裝配的流程，final不可被複寫，保證方裝配算法不被破壞
    final void produce(){
        createFrame();
        addHead();
        addBody();
        if(ifDressup())
            dressUp();
    }
//建立框架
    public abstract void createFrame();
//添加一個機器頭
    public abstract void addHead();
//添加一個機器的身子
    public abstract void addBody();
//爲機器進行裝扮
    public abstract void dressUp();
//判斷是否爲該機器進行裝扮
    public boolean ifDressup(){
        return true;
    }

}
//繼承自基類的一個子類
public class InflatableDoll extends Machine{
    public void createFrame(){
        System.out.println("This is a Frame");
    }

    public void addBody(){
        System.out.println("This is a body");
    }

    public void dressUp(){
        System.out.println("This is a beautiful cloth");
    }

}

這是咱們經過模板方法建立來建立咱們機器的一個例子，那麼如今咱們有了一個新的需求，咱們要對這些全部的機器在出售的時候要進行一個包裝，根據客戶點的類型，而後對其進行相應的包裝以後，而後才能夠出售。不一樣機器的包裝流程大體類似的，因此咱們能夠這樣來寫咱們的前臺銷售部門。

public class Store{

    public void order(String type){
         Machine machine;
        if(type=="inflatedoll"){
            machine = new InflatableDoll();
        }else if(type==""){
            ....
        }
        machine.produce();
        machine.firstPack();
        machine.secondPack();
        machine.thirdPack();
        machine.fourthPack();
    }

}
public class InflatableDoll extends Machine{

    public void firstPack(){
        System.out.prinltn("Add first pack to protect");
    }

    public void secondPack(){
        System.out.prinltn("Add second pack to protect");
    }

    public void thirdPack(){
        System.out.prinltn("Add third pack to protect");
    }

    public void fourthPack(){
        System.out.prinltn("Add fourth pack to protect");
    }
}

可是問題來了，當咱們的機器種類不斷增多，對於機器類型的判斷，而後建立會使得咱們的代碼變得很繁瑣，並且靈活性不好，按照設計模式的原則，封裝變化的，咱們將對與機器類型的判斷和機器的建立封裝起來，咱們該這個封裝起來的類起了個名字叫作工廠類，由於這個工廠類是能夠用來產生新的對象的。封裝代碼以下。

public class MachineFactory{
    public Machine create(String type){
        Machine machine;
        if(type=="inflatabledoll"){
            machine = new InflatableDoll();
        }else if(){
            do something;
        }
        machine.produce();
        return machine;
    }
}

經過這個工廠類，咱們的商店出售類就能夠改變了,和具體的機器實例實現解耦和。

public class Store{

    Store(){
        MachineFactory factory = new MachineFactory();
    }

    public void order(String type){
         Machine machine= factory.create(type);
        machine.firstPack();
        machine.secondPack();
        machine.thirdPack();
        machine.fourthPack();
    }
}

頓時就感受代碼簡潔了好多，並且條理也變得很清晰了。
經過例子，再去對咱們以前的概念去理解，就會變得清晰不少，抽象工廠，具體工廠，抽象產品，具體產品。依賴注入，依賴倒置。首先對於抽象工廠和具體的工廠的理解，由於咱們不一樣的產品可能在其生產上仍是存在一些差別，因此經過一個抽象工廠類做爲基類，而後針對不一樣的地方分別創建不一樣的類，根據這些類，咱們來建立咱們相應的產品，爲了實現商店類和產品的鬆耦合，咱們定義一個抽象產品類，而後全部的產品都將從這個抽象類繼承，而後實現本身的相應的方法，而後經過一個工廠類工廠方法注入實例，實例以委託的形式，來執行相應的操做。
依賴倒置：按照咱們的傳統思路，咱們商店要出售商品，那麼咱們的商店就要依賴商品，而這裏咱們從底層的角度去向高層進階，咱們有商品，商品的建立須要一個工廠類，而商店類，則再也不依賴於產品，產品也再也不依賴於商店類，咱們的第一種寫法，在商店類中對於咱們要建立的類進行的判斷，咱們就能夠將其理解爲商品對於商店類的依賴。而如今，其所有依賴於工廠類，經過一個工廠類，實現解耦。同時也使得以前的依賴出現了倒置，又高層依賴底層轉爲底層依賴高層。

應用實例

實際設計中，工廠模式用的也是比較多，並且這種模式也會比較好辨識，帶有Factory。好比Android中的

public interface ThreadFactory {
    Thread newThread(Runnable r);
}

下篇更新狀態模式