設計模式之工廠模式（factory pattern）

工廠顧名思義就是創建產品，根據產品是具體產品還是具體工廠可分為簡單工廠模式和工廠方法模式，根據工廠的抽象程度可分為工廠方法模式和抽象工廠模式。該模式用於封裝和管理對象的創建，是一種創建型模式。本文從一個具體的例子逐步深入分析，來體會三種工廠模式的應用場景和利弊。

1. 簡單工廠模式

該模式對對象創建管理方式最為簡單，因為其僅僅簡單的對不同類對象的創建進行了一層薄薄的封裝。該模式通過向工廠傳遞類型來指定要創建的對象，其UML類圖如下：

下面我們使用手機生產來講解該模式：

Phone類：手機標準規範類(AbstractProduct)

<code>public interface Phone {
    void make();
}/<code>

MiPhone類：製造小米手機（Product1）

<code>public class MiPhone implements Phone {
    public MiPhone() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make xiaomi phone!");
    }
}/<code>

IPhone類：製造蘋果手機（Product2）

<code>public class IPhone implements Phone {
    public IPhone() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make iphone!");
    }
}/<code>

PhoneFactory類：手機代工廠（Factory）

<code>public class PhoneFactory {
    public Phone makePhone(String phoneType) {
        if(phoneType.equalsIgnoreCase("MiPhone")){
            return new MiPhone();
        }
        else if(phoneType.equalsIgnoreCase("iPhone")) {
            return new IPhone();
        }
        return null;
    }
}/<code>

演示：

<code>public class Demo {
    public static void main(String[] arg) {
        PhoneFactory factory = new PhoneFactory();
        Phone miPhone = factory.makePhone("MiPhone");            // make xiaomi phone!
        IPhone iPhone = (IPhone)factory.makePhone("iPhone");    // make iphone!
    }
}/<code>

2. 工廠方法模式(Factory Method)

和簡單工廠模式中工廠負責生產所有產品相比，工廠方法模式將生成具體產品的任務分發給具體的產品工廠，其UML類圖如下：

也就是定義一個抽象工廠，其定義了產品的生產接口，但不負責具體的產品，將生產任務交給不同的派生類工廠。這樣不用通過指定類型來創建對象了。

接下來繼續使用生產手機的例子來講解該模式。

其中和產品相關的Phone類、MiPhone類和IPhone類的定義不變。

AbstractFactory類：生產不同產品的工廠的抽象類

<code>public interface AbstractFactory {
    Phone makePhone();
}/<code>

XiaoMiFactory類：生產小米手機的工廠（ConcreteFactory1）

<code>public class XiaoMiFactory implements AbstractFactory{
    @Override
    public Phone makePhone() {
        return new MiPhone();
    }
}/<code>

AppleFactory類：生產蘋果手機的工廠（ConcreteFactory2）

<code>public class AppleFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new IPhone();
    }
}/<code>

演示：

<code>public class Demo {
    public static void main(String[] arg) {
        AbstractFactory miFactory = new XiaoMiFactory();
        AbstractFactory appleFactory = new AppleFactory();
        miFactory.makePhone();            // make xiaomi phone!
        appleFactory.makePhone();        // make iphone!
    }
}/<code>

3. 抽象工廠模式(Abstract Factory)

上面兩種模式不管工廠怎麼拆分抽象，都只是針對一類產品Phone（AbstractProduct），如果要生成另一種產品PC，應該怎麼表示呢？

最簡單的方式是把2中介紹的工廠方法模式完全複製一份，不過這次生產的是PC。但同時也就意味著我們要完全複製和修改Phone生產管理的所有代碼，顯然這是一個笨辦法，並不利於擴展和維護。

抽象工廠模式通過在AbstarctFactory中增加創建產品的接口，並在具體子工廠中實現新加產品的創建，當然前提是子工廠支持生產該產品。否則繼承的這個接口可以什麼也不幹。

其UML類圖如下：

從上面類圖結構中可以清楚的看到如何在工廠方法模式中通過增加新產品接口來實現產品的增加的。

接下來我們繼續通過小米和蘋果產品生產的例子來解釋該模式。

為了弄清楚上面的結構，我們使用具體的產品和工廠來表示上面的UML類圖，能更加清晰的看出模式是如何演變的：

PC類：定義PC產品的接口(AbstractPC)

<code>public interface PC {
    void make();
}/<code>

MiPC類：定義小米電腦產品(MIPC)

<code>public class MiPC implements PC {
    public MiPC() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make xiaomi PC!");
    }
}/<code>

MAC類：定義蘋果電腦產品(MAC)

<code>public class MAC implements PC {
    public MAC() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make MAC!");
    }
}/<code>

下面需要修改工廠相關的類的定義：

AbstractFactory類：增加PC產品製造接口

<code>public interface AbstractFactory {
    Phone makePhone();
    PC makePC();
}/<code>

XiaoMiFactory類：增加小米PC的製造（ConcreteFactory1）

<code>public class XiaoMiFactory implements AbstractFactory{
    @Override
    public Phone makePhone() {
        return new MiPhone();
    }
    @Override
    public PC makePC() {
        return new MiPC();
    }
}/<code>

AppleFactory類：增加蘋果PC的製造（ConcreteFactory2）

<code>public class AppleFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new IPhone();
    }
    @Override
    public PC makePC() {
        return new MAC();
    }
}/<code>

演示：

<code>public class Demo {
    public static void main(String[] arg) {
        AbstractFactory miFactory = new XiaoMiFactory();
        AbstractFactory appleFactory = new AppleFactory();
        miFactory.makePhone();            // make xiaomi phone!
        miFactory.makePC();                // make xiaomi PC!
        appleFactory.makePhone();        // make iphone!
        appleFactory.makePC();            // make MAC!
    }
}/<code>

總結：

上面介紹的三種工廠模式有各自的應用場景，實際應用時能解決問題滿足需求即可，可靈活變通，無所謂高級與低級。

此外無論哪種模式，由於可能封裝了大量對象和工廠創建，新加產品需要修改已定義好的工廠相關的類，因此對於產品和工廠的擴展不太友好，利弊需要權衡一下。

歡迎轉載博客文章,轉載請標明出處!