簡單工廠、工廠方法、抽象工廠區別
結合簡單示例和UML圖，講解工廠模式簡單原理。
一、引子
話說十年前，有一個爆發戶，他家有三輛汽車（Benz（賓士）、Bmw（寶馬）、Audi（奧迪）），還僱了司機為他開車。不過，爆發戶坐車時總是這樣：上Benz車後跟司機說“開賓士車！”，坐上Bmw後他說“開寶馬車！”，坐上 Audi後他說“開奧迪車！”。
你一定說：這人有病！直接說開車不就行了？！而當把這個爆發戶的行為放到我們程式語言中來，我們發現C語言一直是通過這種方式來坐車的！
幸運的是這種有病的現象在OO語言中可以避免了。下面以Java語言為基礎來引入我們本文的主題：工廠模式！
二、簡介
工廠模式主要是為建立物件提供了介面。工廠模式按照《Java與模式》中的提法分為三類：
1. 簡單工廠模式(Simple Factory)
2. 工廠方法模式(Factory Method)
3. 抽象工廠模式(Abstract Factory)
這三種模式從上到下逐步抽象，並且更具一般性。還有一種分類法，就是將簡單工廠模式看為工廠方法模式的一種特例，兩個歸為一類。兩者皆可，這本為使用《Java與模式》的分類方法。
在什麼樣的情況下我們應該記得使用工廠模式呢？大體有兩點：
1.在編碼時不能預見需要建立哪種類的例項。
2.系統不應依賴於產品類例項如何被建立、組合和表達的細節
工廠模式能給我們的OOD、OOP帶來哪些好處呢？？
三、簡單工廠模式
這個模式本身很簡單而且使用在業務較簡單的情況下。一般用於小專案或者具體產品很少擴充套件的情況（這樣工廠類才不用經常更改）。
它由三種角色組成：
工廠類角色：這是本模式的核心，含有一定的商業邏輯和判斷邏輯，根據邏輯不同，產生具體的工廠產品。如例子中的Driver類。
抽象產品角色：它一般是具體產品繼承的父類或者實現的介面。由介面或者抽象類來實現。如例中的Car介面。
具體產品角色：工廠類所建立的物件就是此角色的例項。在java中由一個具體類實現，如例子中的Benz、Bmw類。
來用類圖來清晰的表示下的它們之間的關係：
下面就來給那個暴發戶治病：在使用了簡單工廠模式後，現在暴發戶只需要坐在車裡對司機說句：“開車”就可以了。來看看怎麼用程式碼實現的：（為方便起見，所有的類放在一個檔案中，故有一個類被宣告為public）
//抽象產品 abstract class Car{ private String name; public abstract void drive(); public String getName() { return name; } public void setName(String name) { this.name = name; } } //具體產品 class Benz extends Car{ public void drive(){ System.out.println(this.getName()+"----go-----------------------"); } } class Bmw extends Car{ public void drive(){ System.out.println(this.getName()+"----go-----------------------"); } } //簡單工廠 class Driver{ public static Car createCar(String car){ Car c = null; if("Benz".equalsIgnoreCase(car)) c = new Benz(); else if("Bmw".equalsIgnoreCase(car)) c = new Bmw(); return c; } } //老闆 public class BossSimplyFactory { public static void main(String[] args) throws IOException { //老闆告訴司機我今天坐賓士 Car car = Driver.createCar("benz"); car.setName("benz"); //司機開著賓士出發 car.drive(); } }
如果老闆要坐奧迪，同理。
這便是簡單工廠模式了。那麼它帶了了什麼好處呢？
首先，符合現實中的情況；而且客戶端免除了直接建立產品物件的責任，而僅僅負責“消費”產品（正如暴發戶所為）。
下面我們從開閉原則上來分析下簡單工廠模式。當暴發戶增加了一輛車的時候，只要符合抽象產品制定的合同，那麼只要通知工廠類知道就可以被客戶使用了。（即建立一個新的車類，繼承抽象產品Car）那麼 對於產品部分來說，它是符合開閉原則的——對擴充套件開放、對修改關閉；但是工廠類不太理想，因為每增加一輛車，都要在工廠類中增加相應的商業邏輯和判 斷邏輯，這顯自然是違背開閉原則的。
而在實際應用中，很可能產品是一個多層次的樹狀結構。由於簡單工廠模式中只有一個工廠類來對應這些產品，所以這可能會把我們的上帝類壞了。
正如我前面提到的簡單工廠模式適用於業務簡單的情況下或者具體產品很少增加的情況。而對於複雜的業務環境可能不太適應了。這就應該由工廠方法模式來出場了！！
四、工廠方法模式
抽象工廠角色： 這是工廠方法模式的核心，它與應用程式無關。是具體工廠角色必須實現的介面或者必須繼承的父類。在java中它由抽象類或者介面來實現。
具體工廠角色：它含有和具體業務邏輯有關的程式碼。由應用程式呼叫以建立對應的具體產品的物件。在java中它由具體的類來實現。
抽象產品角色：它是具體產品繼承的父類或者是實現的介面。在java中一般有抽象類或者介面來實現。
具體產品角色：具體工廠角色所建立的物件就是此角色的例項。在java中由具體的類來實現。
來用類圖來清晰的表示下的它們之間的關係：
話說暴發戶生意越做越大，自己的愛車也越來越多。這可苦了那位司機師傅了，什麼車它都要記得，維護，都要經過他來使用！於是暴發戶同情他說：我給你分配幾個人手，你只管管好他們就行了！於是工廠方法模式的管理出現了。程式碼如下：
//抽象產品
abstract class Car{
private String name;
public abstract void drive();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
//具體產品
class Benz extends Car{
public void drive(){
System.out.println(this.getName()+"----go-----------------------");
}
}
class Bmw extends Car{
public void drive(){
System.out.println(this.getName()+"----go-----------------------");
}
}
//抽象工廠
abstract class Driver{
public abstract Car createCar(String car) throws Exception;
}
//具體工廠（每個具體工廠負責一個具體產品）
class BenzDriver extends Driver{
public Car createCar(String car) throws Exception {
return new Benz();
}
}
class BmwDriver extends Driver{
public Car createCar(String car) throws Exception {
return new Bmw();
}
}
//老闆
public class Boss{
public static void main(String[] args) throws Exception {
Driver d = new BenzDriver();
Car c = d.createCar("benz");
c.setName("benz");
c.drive();
}
} 使用開閉原則來分析下工廠方法模式。當有新的產品（即暴發戶的汽車）產生時，只要按照抽象產品角色、抽象工廠角色提供的合同來生成，那麼就可以被客戶使用，而不必去修改任何已有的程式碼。（即當有新產品時，只要建立並基礎抽象產品；新建具體工廠繼承抽象工廠；而不用修改任何一個類）工廠方法模式是完全符合開閉原則的！
使用工廠方法模式足以應付我們可能遇到的大部分業務需求。但是當產品種類非常多時，就會出現大量的與之對應的工廠類，這不應該是我們所希望的。所以我建議在這種情況下使用簡單工廠模式與工廠方法模式相結合的方式來減少工廠類：即對於產品樹上類似的種類（一般是樹的葉子中互為兄弟的）使用簡單工廠模式來實現。
當然特殊的情況，就要特殊對待了：對於系統中存在不同的產品樹，而且產品樹上存在產品族（下一節將解釋這個名詞）。那麼這種情況下就可能可以使用抽象工廠模式了。
五、小結
讓我們來看看簡單工廠模式、工廠方法模式給我們的啟迪：
如果不使用工廠模式來實現我們的例子，也許程式碼會減少很多——只需要實現已有的車，不使用多型。但是在可維護性上，可擴充套件性上是非常差的（你可以想象一下新增一輛車後要牽動的類）。因此為了提高擴充套件性和維護性，多寫些程式碼是值得的。
六、抽象工廠模式
先來認識下什麼是產品族： 位於不同產品等級結構中，功能相關聯的產品組成的家族。
圖中的BmwCar和BenzCar就是兩個產品樹（產品層次結構）；而如圖所示的BenzSportsCar和BmwSportsCar就是一個產品族。他們都可以放到跑車家族中，因此功能有所關聯。同理BmwBussinessCar和BenzBusinessCar也是一個產品族。
可以這麼說，它和工廠方法模式的區別就在於需要建立物件的複雜程度上。而且抽象工廠模式是三個裡面最為抽象、最具一般性的。抽象工廠模式的用意為：給客戶端提供一個介面，可以建立多個產品族中的產品物件。
而且使用抽象工廠模式還要滿足一下條件：
1.系統中有多個產品族，而系統一次只可能消費其中一族產品
2.同屬於同一個產品族的產品以其使用。
來看看抽象工廠模式的各個角色（和工廠方法的如出一轍）：
抽象工廠角色： 這是工廠方法模式的核心，它與應用程式無關。是具體工廠角色必須實現的介面或者必須繼承的父類。在java中它由抽象類或者介面來實現。
具體工廠角色：它含有和具體業務邏輯有關的程式碼。由應用程式呼叫以建立對應的具體產品的物件。在java中它由具體的類來實現。
抽象產品角色：它是具體產品繼承的父類或者是實現的介面。在java中一般有抽象類或者介面來實現。
具體產品角色：具體工廠角色所建立的物件就是此角色的例項。在java中由具體的類來實現。
//抽象產品（Bmw和Audi同理）
abstract class BenzCar{
private String name;
public abstract void drive();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
//具體產品（Bmw和Audi同理）
class BenzSportCar extends BenzCar{
public void drive(){
System.out.println(this.getName()+"----BenzSportCar-----------------------");
}
}
class BenzBusinessCar extends BenzCar{
public void drive(){
System.out.println(this.getName()+"----BenzBusinessCar-----------------------");
}
}
abstract class BmwCar{
private String name;
public abstract void drive();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class BmwSportCar extends BmwCar{
public void drive(){
System.out.println(this.getName()+"----BmwSportCar-----------------------");
}
}
class BmwBusinessCar extends BmwCar{
public void drive(){
System.out.println(this.getName()+"----BmwBusinessCar-----------------------");
}
}
abstract class AudiCar{
private String name;
public abstract void drive();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class AudiSportCar extends AudiCar{
public void drive(){
System.out.println(this.getName()+"----AudiSportCar-----------------------");
}
}
class AudiBusinessCar extends AudiCar{
public void drive(){
System.out.println(this.getName()+"----AudiBusinessCar-----------------------");
}
}
//抽象工廠
abstract class Driver3{
public abstract BenzCar createBenzCar(String car) throws Exception;
public abstract BmwCar createBmwCar(String car) throws Exception;
public abstract AudiCar createAudiCar(String car) throws Exception;
}
//具體工廠
class SportDriver extends Driver3{
public BenzCar createBenzCar(String car) throws Exception {
return new BenzSportCar();
}
public BmwCar createBmwCar(String car) throws Exception {
return new BmwSportCar();
}
public AudiCar createAudiCar(String car) throws Exception {
return new AudiSportCar();
}
}
class BusinessDriver extends Driver3{
public BenzCar createBenzCar(String car) throws Exception {
return new BenzBusinessCar();
}
public BmwCar createBmwCar(String car) throws Exception {
return new BmwBusinessCar();
}
public AudiCar createAudiCar(String car) throws Exception {
return new AudiBusinessCar();
}
}
//老闆
public class BossAbstractFactory {
public static void main(String[] args) throws Exception {
Driver3 d = new BusinessDriver();
AudiCar car = d.createAudiCar("");
car.drive();
}
} 其中：BenzSportCar和BenzBusinessCar屬於產品樹；同理BmwSportCar和BmwBusinessCar。而BenzSportCar和BmwSportCar和AudiSportCar屬於產品族。
所以抽象工廠模式一般用於具有產品樹和產品族的場景下。
抽象工廠模式的缺點：如果需要增加新的產品樹，那麼就要新增三個產品類，比如VolvoCar，VolvoSportCar,VolvoSportCar，並且要修改三個工廠類。這樣大批量的改動是很醜陋的做法。
所以可以用簡單工廠配合反射來改進抽象工廠：
UML圖略。
abstract class BenzCar{
private String name;
public abstract void drive();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class BenzSportCar extends BenzCar{
public void drive(){
System.out.println(this.getName()+"----BenzSportCar-----------------------");
}
}
class BenzBusinessCar extends BenzCar{
public void drive(){
System.out.println(this.getName()+"----BenzBusinessCar-----------------------");
}
}
abstract class BmwCar{
private String name;
public abstract void drive();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class BmwSportCar extends BmwCar{
public void drive(){
System.out.println(this.getName()+"----BmwSportCar-----------------------");
}
}
class BmwBusinessCar extends BmwCar{
public void drive(){
System.out.println(this.getName()+"----BmwBusinessCar-----------------------");
}
}
abstract class AudiCar{
private String name;
public abstract void drive();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class AudiSportCar extends AudiCar{
public void drive(){
System.out.println(this.getName()+"----AudiSportCar-----------------------");
}
}
class AudiBusinessCar extends AudiCar{
public void drive(){
System.out.println(this.getName()+"----AudiBusinessCar-----------------------");
}
}
/**
* 簡單工廠通過反射改進抽象工廠及其子工廠
* @author Administrator
*
*/
class Driver3{
public static BenzCar createBenzCar(String car) throws Exception {
return (BenzCar) Class.forName(car).newInstance();
}
public static BmwCar createBmwCar(String car) throws Exception {
return (BmwCar) Class.forName(car).newInstance();
}
public static AudiCar createAudiCar(String car) throws Exception {
return (AudiCar) Class.forName(car).newInstance();
}
}
//客戶端
public class SimpleAndAbstractFactory {
public static void main(String[] args) throws Exception {
AudiCar car = Driver3.createAudiCar("com.java.pattendesign.factory.AudiSportCar");
car.drive();
}
}