摘要：與以往的使用的方式不同，工廠模式使用工廠實(shí)例化對(duì)象。抽象工廠模式亮相抽象工廠模式抽象工廠模式提供一個(gè)接口，用于創(chuàng)建相關(guān)或依賴對(duì)象的家族，而不需要明確指定具體類。

這篇博文介紹設(shè)計(jì)模式的形式將與其他篇博文不太一樣，這里我們將從一個(gè)問(wèn)題入手，逐步了解到簡(jiǎn)單工廠、工廠方法與抽象工廠模式。

PS：這篇博文涉及的內(nèi)容較多，所以篇幅有點(diǎn)長(zhǎng)，請(qǐng)耐心閱讀。

為什么要使用工廠模式？

在 OO 設(shè)計(jì)中，有一個(gè)重要的設(shè)計(jì)原則：針對(duì)接口編程而不針對(duì)實(shí)現(xiàn)編程。每當(dāng)我們使用 new 去實(shí)例化一個(gè)對(duì)象時(shí)，用到的就是實(shí)現(xiàn)編程，而不是接口。這樣以來(lái)代碼綁定著具體類，會(huì)導(dǎo)致代碼更脆弱，缺乏彈性。

在技術(shù)上，使用 new 沒(méi)有錯(cuò)，畢竟這是 Java 的基礎(chǔ)部分。真正錯(cuò)的是“改變”，以及它會(huì)影響 new 的使用。針對(duì)接口編程，可以隔離掉以后系統(tǒng)可能發(fā)生的一堆改變。原因是，如果代碼針對(duì)接口編程，那么通過(guò)多態(tài)，它可以與任何新類實(shí)現(xiàn)該接口。

與以往的使用 new 的方式不同，工廠模式使用“工廠”實(shí)例化對(duì)象。這樣一來(lái)代碼的擴(kuò)展性變得更強(qiáng)，又可以降低代碼之間的耦合。

1.1 問(wèn)題描述

比薩店：假設(shè)你有一家比薩店，為了吸引更多的顧客，所以你們的比薩店提供了很多種類型的比薩，比如奶酪比薩，希臘比薩等。針對(duì)這個(gè)問(wèn)題設(shè)計(jì)比薩從生產(chǎn)到售賣相關(guān)的類。

設(shè)計(jì)圖

1.2 代碼實(shí)現(xiàn)

比薩類 Pizza

package com.jas.simplefactory;

public abstract class Pizza {
    public String name;
    public String sauce;
    
    public void prepare(){
        System.out.println("準(zhǔn)備 ..." + name);
        System.out.println("添加配料 ..." + sauce);
    }
    
    public void bake(){
        System.out.println("烘烤 25 分鐘。");
    }
    
    public void cut(){
        System.out.println("把比薩餅切成對(duì)角片。");
    }
    
    public void box(){
        System.out.println("將比薩放到比薩商店的盒子中。");
    }
}

奶酪比薩類 CheesePizza

package com.jas.simplefactory;

public class CheesePizza extends Pizza {
    public CheesePizza(){
        name = "奶酪比薩";
        sauce = "大蒜番茄醬";
    }
}

希臘比薩類 GreekPizza

package com.jas.simplefactory;

public class GreekPizza extends Pizza{
    public GreekPizza(){
        name = "希臘比薩";
        sauce = "大蒜番茄醬";
    }
}

比薩商店類 PizzaStore

package com.jas.simplefactory;

public class PizzaStore {
    public Pizza orderPizza(String type){
        Pizza pizza = null;
        
        //比薩商店負(fù)責(zé)生產(chǎn)比薩
        if("cheese".equals(type)){
            pizza = new CheesePizza();
        }else if("greek".equals(type)){
            pizza = new GreekPizza();
        }
        
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        
        return pizza;
    }
}

測(cè)試類 PizzaTestDrive

package com.jas.simplefactory;

public class PizzaTestDrive {
    public static void main(String[] args) {
        
        PizzaStore pizzaStore = new PizzaStore();
        // 點(diǎn)一份奶酪比薩
        pizzaStore.orderPizza("cheese");
    }
}

    /**
     * 輸出
     * 
     * 準(zhǔn)備 ...奶酪比薩
     * 添加配料 ...大蒜番茄醬
     * 烘烤 25 分鐘。
     * 把比薩餅切成對(duì)角片。
     * 將比薩放到比薩商店的盒子中。
     * 
     */

1.3 設(shè)計(jì)引發(fā)的問(wèn)題

上面代碼中我們只列出了兩種類型的比薩，在實(shí)際生產(chǎn)的過(guò)程中肯定不止這兩種比薩。為了解決這個(gè)問(wèn)題我們可以在 PizzaStore 類中的 orderPizza() 方法中添加類型判斷，從而生產(chǎn)不同類型的比薩。所以，隨著比薩類型的增多，這個(gè)方法會(huì)不停的進(jìn)行判斷。

假如某個(gè)比薩的銷量不好，我們不想再生產(chǎn)這種類型的比薩，那么我們必須要找到 PizzaStore 類中的 orderPizza() 方法，將該種類型的比薩刪除。

所以我們總結(jié)出：比薩的類型是多變的。這時(shí)候我們就要重新考慮設(shè)計(jì)的方式，簡(jiǎn)單工廠模式就可以幫我們解決這個(gè)問(wèn)題。它將一些容易改變的代碼抽取出來(lái)，多帶帶封裝。

正好符合我們的一個(gè)設(shè)計(jì)原則：找出應(yīng)用中可能需要變化之處，把它們獨(dú)立出來(lái)，不要和那些不需要變化的代碼混在一起。

2.1 簡(jiǎn)單工廠模式亮相

（1）簡(jiǎn)單工廠模式

在《Head First 設(shè)計(jì)模式》一書(shū)中這樣描述簡(jiǎn)單工廠：簡(jiǎn)單工廠其實(shí)并不是一個(gè)設(shè)計(jì)模式，反而比較像一種編程習(xí)慣。但是由于經(jīng)常被使用，所以我們給它一個(gè)“Head First Pattern 榮譽(yù)獎(jiǎng)”。

（2）簡(jiǎn)單工廠組成結(jié)構(gòu)

工廠類角色：含有一定的商業(yè)邏輯和判斷邏輯，用來(lái)創(chuàng)建產(chǎn)品。

抽象產(chǎn)品角色：它一般是具體產(chǎn)品繼承的父類或者實(shí)現(xiàn)的接口。

具體產(chǎn)品角色：工廠類所創(chuàng)建的對(duì)象就是此角色的實(shí)例。

（3）簡(jiǎn)單工廠設(shè)計(jì)圖

（4）簡(jiǎn)單工廠代碼實(shí)現(xiàn)

工廠類 SimplePizzaFactory

package com.jas.simplefactory;

public class SimplePizzaFactory {
    private SimplePizzaFactory(){};
    
    public static Pizza createPizzs(String type){
        Pizza pizza = null;
        
        if("cheese".equals(type)){
            pizza = new CheesePizza();
        }else if("greek".equals(type)){
            pizza = new GreekPizza();
        }

        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();

        return pizza;
    }
}

改寫(xiě)比薩商店類 PizzaStore

package com.jas.simplefactory;

public class PizzaStore {
    public Pizza orderPizza(String type){
        Pizza pizza = null;
        
        pizza = SimplePizzaFactory.createPizzs(type);
        
        return pizza;
    }
}

測(cè)試類 PizzaTestDrive

package com.jas.simplefactory;

public class PizzaTestDrive {
    public static void main(String[] args) {
        
        PizzaStore pizzaStore = new PizzaStore();
        //點(diǎn)一份希臘比薩
        pizzaStore.orderPizza("greek");
        
    }
}

    /**
     * 輸出
     * 
     * 準(zhǔn)備 ...希臘比薩
     * 添加配料 ...大蒜番茄醬
     * 烘烤 25 分鐘。
     * 把比薩餅切成對(duì)角片。
     * 將比薩放到比薩商店的盒子中。
     * 
     */

（5） 簡(jiǎn)單工廠總結(jié)

使用簡(jiǎn)單工廠模式，我們將 PizzaStroe 中易改變的代碼抽取出來(lái)單，獨(dú)用一個(gè)工廠類封裝起來(lái)。當(dāng)我們想要增加或減少比薩種類時(shí)，我們不必在去修改 PizzaStroe 類，直接修改 SimplePizzaFactory 類中的代碼即可。

這樣以來(lái)代碼變得更靈活了，代碼的復(fù)用性變得更強(qiáng)。當(dāng)其他類中也需要 Pizza 實(shí)例時(shí)，也可以直接從 SimplePizzaFactory 類中獲得。

2.2 工廠方法模式亮相

（1）工廠方法模式

工廠方法模式定義了一個(gè)創(chuàng)建對(duì)象的接口，但由子類決定要實(shí)例化的類是哪一個(gè)。工廠方法讓類把實(shí)例化推遲到子類。

（2）工廠方法模式組成結(jié)構(gòu)

抽象工廠角色：是具體工廠角色必須實(shí)現(xiàn)的接口或者必須繼承的父類。在 java 中它由抽象類或者接口來(lái)實(shí)現(xiàn)。聲明了抽象的工廠方法。

具體工廠角色：它含有和具體業(yè)務(wù)邏輯有關(guān)的代碼。由應(yīng)用程序調(diào)用以創(chuàng)建對(duì)應(yīng)的具體產(chǎn)品的對(duì)象。實(shí)現(xiàn)了父類或接口中定義的抽象工廠方法。

抽象產(chǎn)品角色：它是具體產(chǎn)品繼承的父類或者是實(shí)現(xiàn)的接口。在 java 中一般由抽象類或者接口來(lái)實(shí)現(xiàn)。

具體產(chǎn)品角色：具體工廠角色所創(chuàng)建的對(duì)象就是此角色的實(shí)例。在 java 中由具體的類來(lái)實(shí)現(xiàn)。

（3）工廠方法模式的 UML 圖解

（4） 比薩店連鎖啦

由于比薩店的銷量比較好，你掙了一大筆錢(qián)，因此你想開(kāi)幾家分店。最終你選擇在北京和上海各開(kāi)一家分店。但是由于地區(qū)的差異，北京和上海兩地的口味也不一樣。

北京人希望比薩的調(diào)料會(huì)多一些，而上海人則希望比薩的調(diào)料少一些。所以根據(jù)口味的不同，你要制造不同口味的比薩來(lái)滿足顧客。

我們已經(jīng)有了一個(gè)簡(jiǎn)單的比薩生產(chǎn)工廠 SimplePizzaFactory，但是這個(gè)工廠加工的比薩并不對(duì)北京和上海兩地人的胃口。于是就想著再建兩個(gè)比薩生產(chǎn)工廠 (BJPizzaFactory 和 SHPizzaFactory)，分別生產(chǎn)不同口味的比薩。

但是這樣做有一個(gè)不好的地方，雖然不同的比薩生產(chǎn)工廠能夠生產(chǎn)出對(duì)應(yīng)的比薩，但是其他的方法比如：烘焙，切片和包裝卻使用著自己的生產(chǎn)流程 (生產(chǎn)一致則存在大量重復(fù)代碼)。但是你希望這些生產(chǎn)流程在每個(gè)工廠都應(yīng)該一樣 (復(fù)用烘焙，切片和包裝的代碼，或者覆蓋它們)，使用簡(jiǎn)單工廠的方式就不再能夠行的通了。

于是工廠方法就站了出來(lái)。

（5）工廠方法模式設(shè)計(jì)圖

（6）工廠方法模式代碼實(shí)現(xiàn)

代碼用了上面的 Pizza 類。

抽象工廠角色 PizzaStore 抽象類

package com.jas.factorymethod;

import com.jas.simplefactory.Pizza;

public abstract class PizzaStore {
    public Pizza orderPizza(String type){
        Pizza pizza = null;
        
        pizza = createPizza(type);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        
        return pizza;
    }

    /**
     * 工廠方法，將生產(chǎn)比薩的方法定義成抽象方法，讓子類去實(shí)現(xiàn)
     * @param type 比薩的類型
     * @return 對(duì)應(yīng)的比薩實(shí)例
     */
    protected abstract Pizza createPizza(String type);
}

具體工廠角色 BJPizzaStore 類 (這里為了防止篇幅過(guò)長(zhǎng)，省略了 SHPizzaStore 類和對(duì)應(yīng)的比薩類)

package com.jas.factorymethod;

import com.jas.simplefactory.Pizza;

public class BJPizzaStore extends PizzaStore {
    @Override
    protected Pizza createPizza(String type) {
        Pizza pizza = null;
        
        if("cheese".equals(type)){
            pizza =  new BJCheesePizza();
        }else if("greek".equals(type)){
            pizza = new BJGreekPizza();
        }
        
        return pizza;
    }
}

具體產(chǎn)品角色 BJCheesePizza 類 (這里只定義一種比薩的種類)

package com.jas.factorymethod;

import com.jas.simplefactory.Pizza;

public class BJCheesePizza extends Pizza {
    public BJCheesePizza(){
        name = "北京人喜歡吃的奶酪比薩";
        sauce = "濃濃的大蒜番茄醬";
    }

    /**
     * 覆蓋 curt() 方法將比薩切成塊狀
     */
    @Override
    public void cut(){
        System.out.println("把比薩餅切成方塊狀。");
    }
}

測(cè)試類

package com.jas.factorymethod;

public class PizzaTestDrive {
    public static void main(String[] args) {
        
        PizzaStore pizzaStore = new BJPizzaStore();
        //根據(jù)北京人的口味要一個(gè)奶酪比薩
        pizzaStore.orderPizza("greek");
        
    }
}

    /**
     * 輸出
     * 
     * 準(zhǔn)備 ...北京人喜歡吃的希臘比薩
     * 添加配料 ...濃濃的大蒜番茄醬
     * 烘烤 25 分鐘。
     * 把比薩餅切成方塊狀。
     * 將比薩放到比薩商店的盒子中。
     * 
     */

（7）工廠方法模式總結(jié)

簡(jiǎn)單工廠模式中將生產(chǎn)比薩的代碼多帶帶抽取了出來(lái)，用一個(gè)工廠進(jìn)行封裝，由該工廠生產(chǎn)比薩實(shí)例。但是由于開(kāi)了比薩連鎖店，建立多個(gè)比薩工廠并不是好的解決辦法。

所以我們使用了工廠方法模式，在比薩 PizzaStore 抽象類中定義了一個(gè)抽象方法 createPizza() 方法，由其子類去實(shí)現(xiàn)該方法，這樣以來(lái)不同的連鎖店就能生產(chǎn)自己的比薩了。

如果增加產(chǎn)品或者改變產(chǎn)品的實(shí)現(xiàn)，PizzaStore 并不需要做任何的改變。以很好的方式實(shí)現(xiàn)了 PizzaStore 與具體比薩之間的解耦。

2.3 抽象工廠模式亮相

（1） 抽象工廠模式

抽象工廠模式提供一個(gè)接口，用于創(chuàng)建相關(guān)或依賴對(duì)象的家族，而不需要明確指定具體類。

抽象工廠允許客戶使用抽象的接口來(lái)創(chuàng)建一組相關(guān)的產(chǎn)品，而不需要知道或關(guān)心產(chǎn)出的具體產(chǎn)品類是什么。這樣一來(lái)，客戶就從具體的產(chǎn)品中被解耦。

（2） 抽象工廠模式的 UML 圖解

（3）比薩店連鎖店出了一些狀況

比薩連鎖店成功的關(guān)鍵是在于新鮮、高質(zhì)量的原料。但是有的連鎖店開(kāi)始使用低價(jià)的原料來(lái)增加利潤(rùn)，為了防止比薩店的聲譽(yù)遭到破壞，你必須采取相對(duì)應(yīng)的措施。為了解決這個(gè)問(wèn)題，你打算新建一家生產(chǎn)原料的工廠，并將原料運(yùn)往各家加盟店，這樣以一來(lái)，所有的加盟店都使用你生產(chǎn)的原料來(lái)制作比薩。

但是這樣做卻有一個(gè)問(wèn)題：因?yàn)榧用说曜溆诓煌牡赜?，比如北京和上海，它們需要的醬料是不一樣的。所以為了滿足需求，你為它們準(zhǔn)備了兩組不同的原料。
于是你有了一個(gè)想法，你打算創(chuàng)建一個(gè)原料接口，由不同地域的工廠自己去實(shí)現(xiàn)。

（4）抽象工廠模式設(shè)計(jì)圖

（5） 抽象工廠模式代碼實(shí)現(xiàn)

抽象原料工廠 PizzaInfgredientFactory 接口

package com.jas.abstractfactory;

public interface PizzaInfgredientFactory {
    Dough createDough();
    Cheese createCheese();
}

具體原料工廠 SHPizzaInfgredientFactory 類

package com.jas.abstractfactory;

/**
 * 這里是上海原料加工廠，生產(chǎn)的原料是薄面團(tuán)與 Reggiano 干酪
 */
public class SHPizzaInfgredientFactory implements PizzaInfgredientFactory {
    @Override
    public Dough createDough() {
        return new ThinCrustDough();
    }

    @Override
    public Cheese createCheese() {
        return new ReggianoCheese();
    }
}

抽象 Pizza 類

package com.jas.abstractfactory;

public abstract class Pizza {
    public String name;
    //為了篇幅過(guò)長(zhǎng)，不再貼出原料相關(guān)代碼
    public Dough dough;
    public Cheese cheese;

    public abstract void prepare();

    public void bake(){
        System.out.println("烘烤 25 分鐘。");
    }

    public void cut(){
        System.out.println("把比薩餅切成對(duì)角片。");
    }

    public void box(){
        System.out.println("將比薩放到比薩商店的盒子中。");
    }
}

具體 CheesePizza 類 (這里只新建了一個(gè)比薩具體實(shí)現(xiàn)類)

package com.jas.abstractfactory;

public class CheesePizza extends Pizza {
    PizzaInfgredientFactory infgredientFactory = null;
    
    public CheesePizza(PizzaInfgredientFactory infgredientFactory){
        this.infgredientFactory = infgredientFactory;
    }
    
    @Override
    public void prepare() {
        System.out.println("準(zhǔn)備" + name);
        dough = infgredientFactory.createDough();
        cheese = infgredientFactory.createCheese();
    }
}

具體 SHPizzaStore 類

package com.jas.abstractfactory;

public class SHPizzaStore {
    PizzaInfgredientFactory infgredientFactory = new SHPizzaInfgredientFactory();
    
    protected Pizza createPizza(String type){
        Pizza pizza = null;
        
        if("cheese".equals(type)){
            //生產(chǎn)比薩的原料來(lái)自上海的原料加工工廠
            pizza = new CheesePizza(infgredientFactory);
            pizza.name = "原料來(lái)自上海工廠加工的奶酪比薩";
        }
        
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}

測(cè)試類 PizzaTestDrive

package com.jas.abstractfactory;

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

        SHPizzaStore pizzaStore = new SHPizzaStore();
        pizzaStore.createPizza("cheese");
    }
}

     /**
     * 準(zhǔn)備原料來(lái)自上海工廠加工的奶酪比薩
     * 烘烤 25 分鐘。
     * 把比薩餅切成對(duì)角片。
     * 將比薩放到比薩商店的盒子中。
     */

（6）抽象工廠模式總結(jié)

通過(guò)抽象工廠所提供的接口，可以創(chuàng)建產(chǎn)品的家族，利用這個(gè)接口書(shū)寫(xiě)代碼，我們的代碼將從實(shí)際工廠解耦，以便在不同上下文中實(shí)現(xiàn)各式各樣的工廠，制造各樣不同的產(chǎn)品。

工廠方法與抽象工廠的工作都是負(fù)責(zé)創(chuàng)建對(duì)象，但是工廠方法使用的方法是繼承，而抽象工廠使用的是組合。

這意味著，利用工廠方法創(chuàng)建對(duì)象，需要擴(kuò)展一個(gè)類，并實(shí)現(xiàn)其中的工廠方法。由這個(gè)方法創(chuàng)建對(duì)象，只不過(guò)這個(gè)方法通過(guò)子類創(chuàng)建對(duì)象，用這種做法，客戶只需要知道他們所使用的抽象類型就可以了，而由子類負(fù)責(zé)決定具體類型。所以，工廠方法只負(fù)責(zé)將客戶從具體類型中解耦。

抽象工廠提供一個(gè)類來(lái)創(chuàng)建一個(gè)產(chǎn)品家族的抽象類型，這個(gè)類型的子類定義了產(chǎn)品被產(chǎn)生的方法。要使用這個(gè)工廠，必須先要實(shí)例化它，然后將它傳入一些針對(duì)抽象類型所寫(xiě)的代碼中。

所以，和工廠方法一樣，抽象工廠也可以實(shí)現(xiàn)客戶從所使用地實(shí)際具體產(chǎn)品中解耦。但是它還有另一個(gè)優(yōu)點(diǎn)：可以把一群相關(guān)的產(chǎn)品集合起來(lái)創(chuàng)建。但是這也有一個(gè)缺點(diǎn)：如果新加入創(chuàng)建的產(chǎn)品，就必須要改變接口...這樣做的后果是很嚴(yán)重的。

其實(shí)抽象工廠中的具體工廠經(jīng)常使用工廠方法來(lái)創(chuàng)建產(chǎn)品。總之，它們兩個(gè)都可以將對(duì)象的創(chuàng)建封裝起來(lái)，使應(yīng)用程序解耦，因此降低程序之間的依賴。

當(dāng)你需要?jiǎng)?chuàng)建產(chǎn)品家族和想讓制造的相關(guān)產(chǎn)品集合起來(lái)時(shí)，你可以使用抽象工廠。當(dāng)你需要?jiǎng)?chuàng)建一種類型的對(duì)象時(shí)，你可以選擇使用工廠方法。

《Head First 設(shè)計(jì)模式》