設計模式 | 用實際案例詳解工廠模式 一、簡單工廠模式 1、基本介紹 二、工廠方法模式 1、基本介紹 三、抽象工廠模式 四、JDK源碼分析之工廠模式 五、工廠模式小結

我們來看一個具體需求
看一個披薩的項目，要便於披薩種類的擴展，要便於維護，有以下要求：

• 披薩的種類很多（比如GreekPizz、CheesePizz等）
• 披薩的製作有prepare，bake，cut，box
• 完成披薩店訂購功能

首先我們先編寫一個Pizza抽象類：

package com.cxc.factory.simplefactory.pizzastore.pizza;

/**
 * 抽象Pizza類
 */
public abstract class Pizza {
    //Pizza名字
    protected String name;

    //準備原材料，不同的披薩不一樣，因此我們做成抽象方法
    public abstract void preable();
    //切
    public void cut(){
        System.out.println("cut");
    }
    //烘烤
    public void bake(){
        System.out.println("bake");
    }
    //打包
    public void box(){
        System.out.println("box");
    }

    public void setName(String name) {
        this.name = name;
    }
}

然後編寫不同的種類的披薩類去繼承這個抽象類，並實現抽象方法：

package com.cxc.factory.simplefactory.pizzastore.pizza;

public class CheesePizza extends Pizza {
    @Override
    public void preable() {
        System.out.println("給製作奶酪披薩準備原材料");
    }
}

package com.cxc.factory.simplefactory.pizzastore.pizza;

public class GreekPizza extends Pizza {
    @Override
    public void preable() {
        System.out.println("給希臘披薩準備原材料");
    }
}

接下來是完成披薩訂單類，在這裏面根據輸入的披薩種類的不同來新建不同的披薩對象：

package com.cxc.factory.simplefactory.pizzastore.order;

import com.cxc.factory.simplefactory.pizzastore.pizza.CheesePizza;
import com.cxc.factory.simplefactory.pizzastore.pizza.GreekPizza;
import com.cxc.factory.simplefactory.pizzastore.pizza.Pizza;

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class OrderPizza {

    public OrderPizza() {
        Pizza pizza = null;
        String orderType;   //訂購披薩的類型
        do{
            orderType = getType();
            if (orderType.equals("greek")){
                pizza = new GreekPizza();
            }else if (orderType.equals("cheese")){
                pizza = new CheesePizza();
            }else {
                break;
            }
            pizza.preable();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }while (true);
    }

    private String getType(){
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type:");
            String str = strin.readLine();
            return str;
        }catch (Exception e){ }

        return "";
    }
}

披薩店訂購：

package com.cxc.factory.simplefactory.pizzastore.order;

/**
 * 相當於一個客戶端，發出訂購
 */
public class PizzaStore {

    public static void main(String[] args) {
        new OrderPizza();
    }
}

上面實現的這個案例中存在問題，因爲我們新建披薩的代碼編寫在披薩訂單類裏面，所以如果我們需要擴展一個新的披薩種類的時候，除了需要新建擴展類之外，還需要在此處改代碼，違反了開閉原則。在這個案例中需要用到工廠模式來更改。

一、簡單工廠模式

1、基本介紹

• 簡單工廠模式是屬於創建型模式，是工廠模式的一種。簡單工廠模式是由一個工廠對象決定創建出哪一種產品類的實例。簡單工廠模式是工廠模式家族中最簡單實用的模式。
• 簡單工廠模式：定義了一個創建對象的類，由這個類來封裝實例化對象的行爲。
• 在軟件開發中，當我們會用到大量的創建某種、某類或某批對象時，就會使用到工廠模式。

那對於上面的案例我們如何使用簡單工廠方法來更改呢？
首先我們需要將披薩訂單類OrderPizza中生產披薩的代碼抽取出來，形成一個簡單工廠類：

package com.cxc.factory.simplefactory.pizzastore.order;

import com.cxc.factory.simplefactory.pizzastore.pizza.CheesePizza;
import com.cxc.factory.simplefactory.pizzastore.pizza.GreekPizza;
import com.cxc.factory.simplefactory.pizzastore.pizza.Pizza;

/**
 * 簡單工廠模式
 */
public class SimpleFactory {

    /**
     * 根據orderType返回對應的Pizza對象
     * @param orderType
     * @return
     */
    public Pizza createPizza(String orderType){
        Pizza pizza = null;

        System.out.println("簡單工廠模式");
        if (orderType.equals("greek")){
            pizza = new GreekPizza();
        }else if (orderType.equals("cheese")){
            pizza = new CheesePizza();
        }

        return pizza;
    }
}

披薩訂單類OrderPizza1可以更改爲如下：

package com.cxc.factory.simplefactory.pizzastore.order;

import com.cxc.factory.simplefactory.pizzastore.pizza.CheesePizza;
import com.cxc.factory.simplefactory.pizzastore.pizza.GreekPizza;
import com.cxc.factory.simplefactory.pizzastore.pizza.Pizza;

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class OrderPizza1 {

    //定義一個簡單工廠對象
    private SimpleFactory simpleFactory;

    Pizza pizza = null;

    public OrderPizza1(SimpleFactory simpleFactory) {
        setFactory(simpleFactory);
    }

    public void setFactory(SimpleFactory simpleFactory){
        String orderType = "";  //用戶輸入的
        this.simpleFactory = simpleFactory; //設置簡單工廠對象

        do {
            orderType = getType();
            pizza = this.simpleFactory.createPizza(orderType);

            if (pizza != null){
                //訂購成功
                pizza.preable();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }else{
                System.out.println("訂購披薩失敗");
                break;
            }
        }while (true);
    }

    private String getType(){
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type:");
            String str = strin.readLine();
            return str;
        }catch (Exception e){ }

        return "";
    }
}

訂購客戶端：

package com.cxc.factory.simplefactory.pizzastore.order;

/**
 * 相當於一個客戶端，發出訂購
 */
public class PizzaStore {

    public static void main(String[] args) {
        //使用簡單工廠模式
        new OrderPizza1(new SimpleFactory());
    }
}

這樣改動後，如果我們需要擴展新的披薩種類，只需要在簡單工廠類中更改代碼，其它地方不需要進行更改。

接下來對於這個案例，還有一個新需求如下：
客戶在點披薩時，可以點不同口味的披薩，比如北京的奶酪Pizza、北京的胡椒Pizza或者是倫敦是奶酪Pizza、倫敦的胡椒Pizza。

這個時候有兩種思路：

• 思路1：使用簡單工廠模式，創建不同的簡單工廠類，比如BJPizzaSimpleFactory、LDPizzaSImpleFactory等，但是考慮到項目的規模，以及軟件的可維護性、可擴展性這個思路並不是很好。
• 思路2：使用工廠方法模式。

二、工廠方法模式

1、基本介紹

工廠方法模式：定義了一個創建對象的抽象方法，由子類決定要實例化的類。工廠方法模式將對象的實例化推遲到子類。

對於上述案例的新需求，我們使用工廠方法模式更改，OrderPizza是一個抽象的工廠類，其中的createPizza()方法爲抽象方法，然後定義了不同地區口味的披薩工廠類：北京口味披薩工廠類（BJOrderPizza），倫敦口味披薩工廠類（LDOrderPizze），這兩個披薩工廠類分別去生產各個地區的披薩，類圖如下所示：

Pizza類：

package com.cxc.factory.factorymethod.pizzastore.pizza;

/**
 * 抽象Pizza類
 */
public abstract class Pizza {
    //Pizza名字
    protected String name;

    //準備原材料，不同的披薩不一樣，因此我們做成抽象方法
    public abstract void preable();
    //切
    public void cut(){
        System.out.println("cut");
    }
    //烘烤
    public void bake(){
        System.out.println("bake");
    }
    //打包
    public void box(){
        System.out.println("box");
    }

    public void setName(String name) {
        this.name = name;
    }
}

BJCheesePizza類：

package com.cxc.factory.factorymethod.pizzastore.pizza;

public class BJCheesePizza extends Pizza {
    @Override
    public void preable() {
        System.out.println(" 北京的奶酪pizza準備原材料 ");
    }
}

BJPepperPizza類：

package com.cxc.factory.factorymethod.pizzastore.pizza;

public class BJPepperPizza extends Pizza {
    @Override
    public void preable() {
        System.out.println(" 北京的胡椒pizza準備原材料");
    }
}

LDCheesePizza類：

package com.cxc.factory.factorymethod.pizzastore.pizza;

public class LDCheesePizza extends Pizza {
    @Override
    public void preable() {
        System.out.println(" 倫敦的奶酪pizza準備原材料");
    }
}

LDPepperPizza類：

package com.cxc.factory.factorymethod.pizzastore.pizza;

public class LDPepperPizza extends Pizza {
    @Override
    public void preable() {
        System.out.println(" 倫敦的胡椒pizza準備原材料");
    }
}

抽象的工廠類OrderPizza：

package com.cxc.factory.factorymethod.pizzastore.order;

import com.cxc.factory.factorymethod.pizzastore.pizza.Pizza;

import java.io.BufferedReader;
import java.io.InputStreamReader;

public abstract class OrderPizza {

    /**
     * 定義一個抽象的方法
     * @param orderType
     * @return
     */
    public abstract Pizza createPizze(String orderType);

    public OrderPizza() {
        Pizza pizza = null;
        String orderType;   //訂購披薩的類型
        do{
            orderType = getType();
            //抽象的方法，由工廠子類完成
            pizza = createPizze(orderType);
            pizza.preable();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }while (true);
    }

    private String getType(){
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type:");
            String str = strin.readLine();
            return str;
        }catch (Exception e){ }

        return "";
    }
}

兩個工廠子類分別去實現OrderPizza類：

package com.cxc.factory.factorymethod.pizzastore.order;

import com.cxc.factory.factorymethod.pizzastore.pizza.*;

public class LDOrderPizza extends OrderPizza {
    @Override
    public Pizza createPizze(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("cheese")){
            pizza = new LDCheesePizza();
        }else if (orderType.equals("pepper")){
            pizza = new LDPepperPizza();
        }
        return pizza;

    }
}

package com.cxc.factory.factorymethod.pizzastore.order;

import com.cxc.factory.factorymethod.pizzastore.pizza.BJCheesePizza;
import com.cxc.factory.factorymethod.pizzastore.pizza.BJPepperPizza;
import com.cxc.factory.factorymethod.pizzastore.pizza.Pizza;

public class BJOrderPizza extends OrderPizza {

    @Override
    public Pizza createPizze(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("cheese")){
            pizza = new BJCheesePizza();
        }else if (orderType.equals("pepper")){
            pizza = new BJPepperPizza();
        }
        return pizza;
    }
}

披薩訂購：

package com.cxc.factory.factorymethod.pizzastore.order;

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

        //在此示例創建北京口味的各種披薩
        new BJOrderPizza();
    }
}

三、抽象工廠模式

1、基本介紹

• 抽象工廠模式定義了一個接口（interface）用於創建相關或有依賴關係的對象簇，而無需指明具體的類
• 抽象工廠模式可以將簡單工廠模式和工廠方法模式進行整合
• 從設計層面看，抽象工廠模式就是對簡單工廠模式的改進（或者稱爲進一步的抽象）
• 將工廠抽象成兩層，抽象工廠和具體實現的工廠子類。程序員可以根據創建對象類型使用對應的工廠子類。這樣將單個的簡單工廠類變成了工廠簇，更利於代碼的維護和擴展

上面的披薩案例使用抽象工廠模式後類圖如下所示：

接下來我們再來將其實現一下，抽象的工廠接口如下：

package com.cxc.factory.absfactory.pizzastore.order;
import com.cxc.factory.absfactory.pizzastore.pizza.Pizza;
/**
 * 抽象工廠模式的抽象層
 */
public interface AbsFactory {

    /**
     * 由下面的具體子類實現
     * @param orderType
     * @return
     */
    public Pizza createPizza(String orderType);
}

兩個具體的工廠子類：

package com.cxc.factory.absfactory.pizzastore.order;

import com.cxc.factory.absfactory.pizzastore.pizza.BJCheesePizza;
import com.cxc.factory.absfactory.pizzastore.pizza.BJPepperPizza;
import com.cxc.factory.absfactory.pizzastore.pizza.Pizza;

/**
 * 具體的工廠子類
 */
public class BJFactory implements AbsFactory {
    @Override
    public Pizza createPizza(String orderType) {
        System.out.println("使用的是抽象工廠模式");
        Pizza pizza = null;
        if (orderType.equals("cheese")){
            pizza = new BJCheesePizza();
        }else if (orderType.equals("pepper")){
            pizza = new BJPepperPizza();
        }

        return pizza;
    }
}

package com.cxc.factory.absfactory.pizzastore.order;

import com.cxc.factory.absfactory.pizzastore.pizza.*;

public class LDFactory implements AbsFactory {
    @Override
    public Pizza createPizza(String orderType) {
        System.out.println("使用的是抽象工廠模式");
        Pizza pizza = null;
        if (orderType.equals("cheese")){
            pizza = new LDCheesePizza();
        }else if (orderType.equals("pepper")){
            pizza = new LDPepperPizza();
        }

        return pizza;
    }
}

披薩訂單類：

package com.cxc.factory.absfactory.pizzastore.order;

import com.cxc.factory.absfactory.pizzastore.pizza.Pizza;

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class OrderPizza {

    AbsFactory absFactory;

    public OrderPizza(AbsFactory absFactory){
        this.setAbsFactory(absFactory);
    }

    private void setAbsFactory(AbsFactory factory){
        Pizza pizza = null;
        String orderType = "";//用戶輸入
        this.absFactory = factory;

        do{
            orderType = getType();
            pizza = factory.createPizza(orderType);
            if (pizza != null){
                pizza.preable();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }else{
                System.out.println("訂購失敗");
                break;
            }
        }while (true);
    }

    private String getType(){
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type:");
            String str = strin.readLine();
            return str;
        }catch (Exception e){ }

        return "";
    }
}

披薩商店類：

package com.cxc.factory.absfactory.pizzastore.order;

public class PizzaStore {

    public static void main(String[] args) {
        new OrderPizza(new BJFactory());  //這裏演示北京的工廠子類
    }
}

四、JDK源碼分析之工廠模式

Calendar是一個簡單工廠模式。
例如下面這個創建Calendar實例的方法：

Calendar calendar = Calendar.getInstance();

看getInstance方法的實現：

    /**
     * Gets a calendar using the default time zone and locale. The
     * <code>Calendar</code> returned is based on the current time
     * in the default time zone with the default
     * {@link Locale.Category#FORMAT FORMAT} locale.
     *
     * @return a Calendar.
     */
    public static Calendar getInstance()
    {
        return createCalendar(TimeZone.getDefault(), Locale.getDefault(Locale.Category.FORMAT));
    }

這裏返回的createCalendar方法點進去：

    private static Calendar createCalendar(TimeZone zone,
                                           Locale aLocale)
    {
        CalendarProvider provider =
            LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale)
                                 .getCalendarProvider();
        if (provider != null) {
            try {
                return provider.getInstance(zone, aLocale);
            } catch (IllegalArgumentException iae) {
                // fall back to the default instantiation
            }
        }

        Calendar cal = null;

        if (aLocale.hasExtensions()) {
            String caltype = aLocale.getUnicodeLocaleType("ca");
            if (caltype != null) {
                switch (caltype) {
                case "buddhist":
                cal = new BuddhistCalendar(zone, aLocale);
                    break;
                case "japanese":
                    cal = new JapaneseImperialCalendar(zone, aLocale);
                    break;
                case "gregory":
                    cal = new GregorianCalendar(zone, aLocale);
                    break;
                }
            }
        }
        if (cal == null) {
            // If no known calendar type is explicitly specified,
            // perform the traditional way to create a Calendar:
            // create a BuddhistCalendar for th_TH locale,
            // a JapaneseImperialCalendar for ja_JP_JP locale, or
            // a GregorianCalendar for any other locales.
            // NOTE: The language, country and variant strings are interned.
            if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") {
                cal = new BuddhistCalendar(zone, aLocale);
            } else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja"
                       && aLocale.getCountry() == "JP") {
                cal = new JapaneseImperialCalendar(zone, aLocale);
            } else {
                cal = new GregorianCalendar(zone, aLocale);
            }
        }
        return cal;
    }

可以看到在創建實例的時候是根據你傳入的參數不同而來創建不同的實例的，這是一個簡單工廠模式。

五、工廠模式小結

1、工廠模式的意義

將實例化對象的代碼抽象出來，放到一個類中統一管理和維護，達到和主項目的依賴關係的解耦，從而提高項目的擴展和維護性。

2、三種工廠模式

• 簡單工廠模式
• 工廠方法模式
• 抽象工廠模式

3、設計模式的依賴抽象原則

• 創建對象實例時，不要直接new類，而是把這個new類的動作放在一個工廠的方法中，並返回。也可說爲：變量不要直接持有具體類的引用。
• 不要讓類繼承具體類，而是繼承抽象類或者實現interface（接口）。
• 不要覆蓋基類中已經實現的方法。