文章出處

一、引言


  這個系列也是自己對設計模式的一些學習筆記,希望對一些初學設計模式的人有所幫助的,在上一個專題中介紹了單例模式,在這個專題中繼續為大家介紹一個比較容易理解的模式——簡單工廠模式。

二、簡單工廠模式的介紹


  說到簡單工廠,自然的第一個疑問當然就是什么是簡單工廠模式了? 在現實生活中工廠是負責生產產品的,同樣在設計模式中,簡單工廠模式我們也可以理解為負責生產對象的一個類, 我們平常編程中,當使用"new"關鍵字創建一個對象時,此時該類就依賴與這個對象,也就是他們之間的耦合度高,當需求變化時,我們就不得不去修改此類的源碼,此時我們可以運用面向對象(OO)的很重要的原則去解決這一的問題,該原則就是——封裝改變,既然要封裝改變,自然也就要找到改變的代碼,然后把改變的代碼用類來封裝,這樣的一種思路也就是我們簡單工廠模式的實現方式了。下面通過一個現實生活中的例子來引出簡單工廠模式。

  在外面打工的人,免不了要經常在外面吃飯,當然我們也可以自己在家做飯吃,但是自己做飯吃麻煩,因為又要自己買菜,然而,出去吃飯就完全沒有這些麻煩的,我們只需要到餐館點菜就可以了,買菜的事情就交給餐館做就可以了,這里餐館就充當簡單工廠的角色,下面讓我們看看現實生活中的例子用代碼是怎樣來表現的。

自己做飯的情況:

/// <summary>
/// 自己做飯的情況
/// 沒有簡單工廠之前,客戶想吃什么菜只能自己炒的
/// </summary>
public class Customer
{
    /// <summary>
    /// 燒菜方法
    /// </summary>
    /// <param name="type"></param>
    /// <returns></returns>
    public static Food Cook(string type)
    {
        Food food = null;
        // 客戶A說:我想吃西紅柿炒蛋怎么辦?
        // 客戶B說:那你就自己燒啊
        // 客戶A說: 好吧,那就自己做吧
        if (type.Equals("西紅柿炒蛋"))
        {
            food = new TomatoScrambledEggs();
        }
        // 我又想吃土豆肉絲, 這個還是得自己做
        // 我覺得自己做好累哦,如果能有人幫我做就好了?
        else if (type.Equals("土豆肉絲"))
        {
            food = new ShreddedPorkWithPotatoes();
        }
        return food;
    }
    static void Main(string[] args)
    {
        // 做西紅柿炒蛋
        Food food1 = Cook("西紅柿炒蛋");
        food1.Print();
        Food food2 = Cook("土豆肉絲");
        food1.Print();
        Console.Read();
    }
}
/// <summary>
/// 菜抽象類
/// </summary>
public abstract class Food
{
    // 輸出點了什么菜
    public abstract void Print();
}
/// <summary>
/// 西紅柿炒雞蛋這道菜
/// </summary>
public class TomatoScrambledEggs : Food
{
    public override void Print()
    {
        Console.WriteLine("一份西紅柿炒蛋!");
    }
}
/// <summary>
/// 土豆肉絲這道菜
/// </summary>
public class ShreddedPorkWithPotatoes : Food
{
    public override void Print()
    {
        Console.WriteLine("一份土豆肉絲");
    }
}

自己做飯,如果我們想吃別的菜時,此時就需要去買這種菜和洗菜這些繁瑣的操作,有了餐館(也就是簡單工廠)之后,我們就可以把這些操作交給餐館去做,此時消費者(也就是我們)對菜(也就是具體對象)的依賴關系從直接變成的間接的,這樣就是實現了面向對象的另一個原則——降低對象之間的耦合度,下面就具體看看有了餐館之后的實現代碼(即簡單工廠的實現):

/// <summary>
/// 顧客充當客戶端,負責調用簡單工廠來生產對象
/// 即客戶點菜,廚師(相當于簡單工廠)負責燒菜(生產的對象)
/// </summary>
class Customer
{
    static void Main(string[] args)
    {
        // 客戶想點一個西紅柿炒蛋      
        Food food1 = FoodSimpleFactory.CreateFood("西紅柿炒蛋");
        food1.Print();
        // 客戶想點一個土豆肉絲
        Food food2 = FoodSimpleFactory.CreateFood("土豆肉絲");
        food2.Print();
        Console.Read();
    }
}
/// <summary>
/// 菜抽象類
/// </summary>
public abstract class Food
{
    // 輸出點了什么菜
    public abstract void Print();
}
/// <summary>
/// 西紅柿炒雞蛋這道菜
/// </summary>
public class TomatoScrambledEggs : Food
{
    public override void Print()
    {
        Console.WriteLine("一份西紅柿炒蛋!");
    }
}
/// <summary>
/// 土豆肉絲這道菜
/// </summary>
public class ShreddedPorkWithPotatoes : Food
{
    public override void Print()
    {
        Console.WriteLine("一份土豆肉絲");
    }
}
/// <summary>
/// 簡單工廠類, 負責 炒菜
/// </summary>
public class FoodSimpleFactory
{
    public static Food CreateFood(string type)
    {
        Food food = null;
        if (type.Equals("土豆肉絲"))
        {
            food = new ShreddedPorkWithPotatoes();
        }
        else if (type.Equals("西紅柿炒蛋"))
        {
            food = new TomatoScrambledEggs();
        }
        return food;
    }
}

三、優點與缺點


  看完簡單工廠模式的實現之后,你和你的小伙伴們肯定會有這樣的疑惑(因為我學習的時候也有)——這樣我們只是把變化移到了工廠類中罷了,好像沒有變化的問題,因為如果客戶想吃其他菜時,此時我們還是需要修改工廠類中的方法(也就是多加case語句,沒應用簡單工廠模式之前,修改的是客戶類)。我首先要說:你和你的小伙伴很對,這個就是簡單工廠模式的缺點所在(這個缺點后面介紹的工廠方法可以很好地解決),然而,簡單工廠模式與之前的實現也有它的優點:

簡單工廠模式解決了客戶端直接依賴于具體對象的問題,客戶端可以消除直接創建對象的責任,而僅僅是消費產品。簡單工廠模式實現了對責任的分割
簡單工廠模式也起到了代碼復用的作用,因為之前的實現(自己做飯的情況)中,換了一個人同樣要去在自己的類中實現做菜的方法,然后有了簡單工廠之后,去餐館吃飯的所有人都不用那么麻煩了,只需要負責消費就可以了。此時簡單工廠的燒菜方法就讓所有客戶共用了。(同時這點也是簡單工廠方法的缺點——因為工廠類集中了所有產品創建邏輯,一旦不能正常工作,整個系統都會受到影響,也沒什么不好理解的,就如事物都有兩面性一樣道理)
雖然上面已經介紹了簡單工廠模式的缺點,下面還是總結下簡單工廠模式的缺點:

工廠類集中了所有產品創建邏輯,一旦不能正常工作,整個系統都會受到影響(通俗地意思就是:一旦餐館沒飯或者關門了,很多不愿意做飯的人就沒飯吃了)
系統擴展困難,一旦添加新產品就不得不修改工廠邏輯,這樣就會造成工廠邏輯過于復雜。
了解了簡單工廠模式之后的優缺點之后,我們之后就可以知道簡單工廠的應用場景了:

當工廠類負責創建的對象比較少時可以考慮使用簡單工廠模式
客戶如果只知道傳入工廠類的參數,對于如何創建對象的邏輯不關心時可以考慮使用簡單工廠模式


四、簡單工廠模式UML圖


簡單工廠模式又叫靜態方法模式(因為工廠類都定義了一個靜態方法),由一個工廠類根據傳入的參數決定創建出哪一種產品類的實例(通俗點表達:通過客戶下的訂單來負責燒那種菜)。簡單工廠模式的UML圖如下:

五、.NET中簡單工廠模式的實現


  介紹完了簡單工廠模式之后,我學習的時候就像:.NET類庫中是否有實現了簡單工廠模式的類呢?后面確實有,.NET中System.Text.Encoding類就實現了簡單工廠模式,該類中的GetEncoding(int codepage)就是工廠方法,具體的代碼可以通過Reflector反編譯工具進行查看,下面我也貼出該方法中部分代碼:

public static Encoding GetEncoding(int codepage)
{
    Encoding unicode = null;
    if (encodings != null)
    {
        unicode = (Encoding)encodings[codepage];
    }
    if (unicode == null)
    {
        object obj2;
        bool lockTaken = false;
        try
        {
            Monitor.Enter(obj2 = InternalSyncObject, ref lockTaken);
            if (encodings == null)
            {
                encodings = new Hashtable();
            }
            unicode = (Encoding)encodings[codepage];
            if (unicode != null)
            {
                return unicode;
            }
            switch (codepage)
            {
                case 0:
                    unicode = Default;
                    break;
                case 1:
                case 2:
                case 3:
                case 0x2a:
                    throw new ArgumentException(Environment.GetResourceString("Argument_CodepageNotSupported", new object[] { codepage }), "codepage");
                case 0x4b0:
                    unicode = Unicode;
                    break;
                case 0x4b1:
                    unicode = BigEndianUnicode;
                    break;
                case 0x6faf:
                    unicode = Latin1;
                    break;
                case 0xfde9:
                    unicode = UTF8;
                    break;
                case 0x4e4:
                    unicode = new SBCSCodePageEncoding(codepage);
                    break;
                case 0x4e9f:
                    unicode = ASCII;
                    break;
                default:
                    unicode = GetEncodingCodePage(codepage);
                    if (unicode == null)
                    {
                        unicode = GetEncodingRare(codepage);
                    }
                    break;
            }
            encodings.Add(codepage, unicode);
            return unicode;
        }
}

.NET 中Encoding的UML圖為:

Encoding類中實現的簡單工廠模式是簡單工廠模式的一種演變,此時簡單工廠類由抽象產品角色扮演,然而.NET中Encoding類是如何解決簡單工廠模式中存在的問題的呢(即如果新添加一種編碼怎么辦)?在GetEncoding方法里的switch函數有如下代碼:

switch (codepage)
{
    .......
    default:
    unicode = GetEncodingCodePage(codepage);
    if (unicode == null)
    {
        unicode = GetEncodingRare(codepage); //當編碼很少見時
    }
    break;
    ......
}

在GetEncodingRare方法里有一些不常用編碼的實例化代碼,微軟正式通過這個方法來解決新增加一種編碼的問題。(其實也就是列出所有可能的編碼情況),微軟之所以以這樣的方式來解決這個問題,可能是由于現在編碼已經穩定了,添加新編碼的可能性比較低,所以在.NET 4.5仍然未改動這部分代碼。

六、總結


到這里,簡單工廠模式的介紹都到這里了,后面將介紹工廠方法模式來解決簡單工廠模式中存在的問題。

 

以上內容摘自:http://learninghard.blog.51cto.com/6146675/1289553

 

  軟件模式是人們在進行軟件開發的過程中,總結出的對各種問題域的解決方法,不同的問題域有不同的模式來解決。新的問題域會出現,那么解決新的問題域的模式也會出現,隨著人們對問題域理解的進步,模式也在進步,舊的模式很可能被新的模式推翻,模式不是真理,而是經過GS不斷摸索,總結出的一套解決方法。 工廠模式細分可以分為3中:簡單工廠模式,工廠方法模式和抽象工廠模式。 在簡單工廠模式中有一個工廠類,還有一個所有產品的超類(在系統中是以接口的形式出現的)和各個具體產品類。為了讓客戶在系統運行期間動態的決定需要那種產品,所以提供了所有產品的超類,這是利用的面向對象的多態機制。 通過提供了一個產品的超類類,在我們的系統需要別的形狀的時候只要加入一個實現這個超類的具體產品類就可以了。產品中確實自動添加了我們需要的新產品,但工廠沒有可以提供新產品的邏輯,必須修改源代碼,在if語言中加上創建新產品的邏輯,重新編譯系統才可以。這一點違反了“開閉原則”,如何才可以不違反原則呢,工廠方法模式的其他兩個模式作出了解決的方法,但不完全。但簡單工廠模式也是有優點的,要不然也沒有存在的理由了,優點就在于實現起來很簡單,對于一些本身就很簡單的系統沒有必要使用復雜的模式。


文章列表


不含病毒。www.avast.com
arrow
arrow
    全站熱搜
    創作者介紹
    創作者 大師兄 的頭像
    大師兄

    IT工程師數位筆記本

    大師兄 發表在 痞客邦 留言(0) 人氣()