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

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

1. 簡單工廠模式

該模式對對象建立管理方式最爲簡單，由於其僅僅簡單的對不一樣類對象的建立進行了一層薄薄的封裝。該模式經過向工廠傳遞類型來指定要建立的對象，其UML類圖以下：

下面咱們使用手機生產來說解該模式：

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

public interface Phone {
    void make();
}

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

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

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

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

PhoneFactory類：手機代工廠（Factory）

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;
    }
}

 演示：

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!
    }
}

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

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

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

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

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

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

public interface AbstractFactory {
    Phone makePhone();
}

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

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

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

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

演示：

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!
    }
}

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

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

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

抽象工廠模式經過在AbstarctFactory中增長建立產品的接口，並在具體子工廠中實現新加產品的建立，固然前提是子工廠支持生產該產品。不然繼承的這個接口能夠什麼也不幹。

其UML類圖以下：

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

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

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

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

public interface PC {
    void make();
}

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

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

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

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

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

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

public interface AbstractFactory {
    Phone makePhone();
    PC makePC();
}

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

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

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

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

演示：

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!
    }
}

總結：

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

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