Java設計模式（一） 簡單工廠模式不簡單

weixin_34365417發表於2016-06-08
Java設計模式

原創文章，同步發自作者人個部落格，轉載請務必將下面這段話置於文章開頭處。
　　本文轉發自Jason's Blog，原文連結　http://www.jasongj.com/design_pattern/simple_factory

簡單工廠模式使用案例

有一種抽象產品——汽車（Car），同時有多種具體的子類產品，如BenzCar，BMWCar，LandRoverCar。類圖如下


1398961-21fe49b5ae8bde3f.png
Product class diagram

作為司機，如果要開其中一種車，比如BenzCar，最直接的做法是直接建立BenzCar的例項，並執行其drive方法，如下

package com.jasongj.client;

import com.jasongj.product.BenzCar;

public class Driver1 {

  public static void main(String[] args) {
    BenzCar car = new BenzCar();
    car.drive();
  }

}

此時如果要改為開Land Rover，則需要修改程式碼，建立Land Rover的例項並執行其drive方法。這也就意味著任何時候需要換一輛車開的時候，都必須修改客戶端程式碼。

一種稍微好點的方法是，通過讀取配置檔案，獲取需要開的車，然後建立相應的例項並由父類Car的引用指向它，利用多型執行不同車的drive方法。如下

package com.jasongj.client;

import org.apache.commons.configuration.ConfigurationException;
import org.apache.commons.configuration.XMLConfiguration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.jasongj.product.BMWCar;
import com.jasongj.product.BenzCar;
import com.jasongj.product.Car;
import com.jasongj.product.LandRoverCar;

public class Driver2 {
  
  private static final Logger LOG = LoggerFactory.getLogger(Driver2.class);

  public static void main(String[] args) throws ConfigurationException {
    XMLConfiguration config = new XMLConfiguration("car.xml");
    String name = config.getString("driver2.name");
    Car car;

    switch (name) {
    case "Land Rover":
      car = new LandRoverCar();
      break;
    case "BMW":
      car = new BMWCar();
      break;
    case "Benz":
      car = new BenzCar();
      break;
    default:
      car = null;
      break;
    }
    LOG.info("Created car name is {}", name);
    car.drive();
  }

}

對於Car的使用方而言，只需要通過引數即可指定所需要Car的各類並得到其例項，同時無論使用哪種Car，都不需要修改後續對Car的操作。至此，簡單工廠模式的原型已經形成。如果把上述的邏輯判斷封裝到一個專門的類的靜態方法中，則實現了簡單工廠模式。工廠程式碼如下

package com.jasongj.factory;

import org.apache.commons.configuration.ConfigurationException;
import org.apache.commons.configuration.XMLConfiguration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.jasongj.product.BMWCar;
import com.jasongj.product.BenzCar;
import com.jasongj.product.Car;
import com.jasongj.product.LandRoverCar;

public class CarFactory1 {
  
  private static final Logger LOG = LoggerFactory.getLogger(CarFactory1.class);

  public static Car newCar() {
    Car car = null;
    String name = null;
    try {
      XMLConfiguration config = new XMLConfiguration("car.xml");
      name = config.getString("factory1.name");
    } catch (ConfigurationException ex) {
      LOG.error("parse xml configuration file failed", ex);
    }

    switch (name) {
    case "Land Rover":
      car = new LandRoverCar();
      break;
    case "BMW":
      car = new BMWCar();
      break;
    case "Benz":
      car = new BenzCar();
      break;
    default:
      car = null;
      break;
    }
    LOG.info("Created car name is {}", name);
    return car;
  }

}

呼叫方程式碼如下

package com.jasongj.client;

import com.jasongj.factory.CarFactory1;
import com.jasongj.product.Car;

public class Driver3 {

  public static void main(String[] args) {
    Car car = CarFactory1.newCar();
    car.drive();
  }

}

與Driver2相比，所有的判斷邏輯都封裝在工廠(CarFactory1)當中，Driver3不再需要關心Car的例項化，實現了物件的建立和使用的隔離。

當然，簡單工廠模式並不要求一定要讀配置檔案來決定例項化哪個類，可以把引數作為工廠靜態方法的引數傳入。

簡單工廠模式進階

使用反射實現擴充套件性

從Driver2和CarFactory1的實現中可以看到，當有新的車加入時，需要更新Driver2和CarFactory1的程式碼也實現對新車的支援。這就違反了開閉原則（Open-Close Principle）。可以利用反射（Reflection）解決該問題。

package com.jasongj.factory;

import org.apache.commons.configuration.ConfigurationException;
import org.apache.commons.configuration.XMLConfiguration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.jasongj.product.Car;

public class CarFactory2 {
  
  private static final Logger LOG = LoggerFactory.getLogger(CarFactory2.class);

  public static Car newCar() {
    Car car = null;
    String name = null;
    try {
      XMLConfiguration config = new XMLConfiguration("car.xml");
      name = config.getString("factory2.class");
    } catch (ConfigurationException ex) {
      LOG.error("Parsing xml configuration file failed", ex);
    }
    
    try {
      car = (Car)Class.forName(name).newInstance();
      LOG.info("Created car class name is {}", name);
    } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
      LOG.error("Instantiate car {} failed", name);
    }
    return car;
  }

}

從上面程式碼中可以看到，之後如果需要引入新的Car，只需要在配置檔案中指定該Car的完整類名（包括package名），CarFactory2即可通過反射將其例項化。實現了對擴充套件的開放，同時保證了對修改的關閉。熟悉Spring的讀者應該會想到Spring IoC的實現。

註解讓簡單工廠模式不簡單

上例中使用反射做到了對擴充套件開放，對修改關閉。但有些時候，使用類的全名不太方便，使用別名會更合適。例如Spring中每個Bean都會有個ID，引用Bean時也會通過ID去引用。像Apache Nifi這樣的資料流工具，在流程上使用了職責鏈模式，而對於單個Processor的建立則使用了工廠，對於使用者自定義的Processor並不需要通過程式碼去註冊，而是使用註解（為了更方便理解下面這段程式碼，請先閱讀筆者另外一篇文章《Java系列（一）Annotation（註解）》）。

下面就繼續在上文案例的基礎上使用註解升級簡單工廠模式。

package com.jasongj.factory;

import java.util.Collections;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

import org.apache.commons.configuration.ConfigurationException;
import org.apache.commons.configuration.XMLConfiguration;
import org.reflections.Reflections;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.jasongj.annotation.Vehicle;
import com.jasongj.product.Car;

public class CarFactory3 {

  private static final Logger LOG = LoggerFactory.getLogger(CarFactory3.class);

  private static Map<String, Class> allCars;

  static {
    Reflections reflections = new Reflections("com.jasongj.product");
    Set<Class<?>> annotatedClasses = reflections.getTypesAnnotatedWith(Vehicle.class);
    allCars = new ConcurrentHashMap<String, Class>();
    for (Class<?> classObject : annotatedClasses) {
      Vehicle vehicle = (Vehicle) classObject.getAnnotation(Vehicle.class);
      allCars.put(vehicle.type(), classObject);
    }
    allCars = Collections.unmodifiableMap(allCars);
  }

  public static Car newCar() {
    Car car = null;
    String type = null;
    try {
      XMLConfiguration config = new XMLConfiguration("car.xml");
      type = config.getString("factory3.type");
      LOG.info("car type is {}", type);
    } catch (ConfigurationException ex) {
      LOG.error("Parsing xml configuration file failed", ex);
    }

    if (allCars.containsKey(type)) {
      LOG.info("created car type is {}", type);
      try {
        car = (Car) allCars.get(type).newInstance();
      } catch (InstantiationException | IllegalAccessException ex) {
        LOG.error("Instantiate car failed", ex);
      }
    } else {
      LOG.error("specified car type {} does not exist", type);
    }
    return car;
  }

}

從上面程式碼中可以看到，該工廠會掃描所有被Vehicle註解的Car（每種Car都在註解中宣告瞭自己的type，可作為該種Car的別名）然後建立起Car別名與具體Car的Class原對映。此時工廠的靜態方法即可根據目標別名例項化對應的Car。

本文所有程式碼都可從作者GitHub下載.

簡單工廠模式詳解

簡單工廠模式定義

簡單工廠模式（Simple Factory Pattern）又叫靜態工廠方法模式（Static FactoryMethod Pattern）。專門定義一個類（如上文中的CarFactory1、CarFactory2、CarFactory3）來負責建立其它類的例項，由它來決定例項化哪個具體類，從而避免了在客戶端程式碼中顯式指定，實現瞭解耦。該類由於可以建立同一抽象類（或介面）下的不同子類物件，就像一個工廠一樣，因此被稱為工廠類。

簡單工廠模式類圖

簡單工廠模式類圖如下所示


1398961-eeec654465661fb9.png
Simple factory pettern class diagram

簡單工廠模式角色劃分

  • 工廠角色（如上文中的CarFactory1/2/3）：這是簡單工廠模式的核心，由它負責建立所有的類的內部邏輯。當然工廠類必須能夠被外界呼叫，建立所需要的產品物件。一般而言，工廠類提供一個靜態方法，外部程式通過該方法建立所需物件。
  • 抽象產品角色(如上文中的Car)：簡單工廠模式所建立的所有物件的父類。注意，這裡的父類可以是介面也可以是抽象類，它負責描述所建立例項共有的公共介面。
  • 具體產品角色（如上文中的BMWCar，BenzCar，LandRoverCar）：簡單工廠所建立的具體例項物件，這些具體的產品往往都擁有共同的父類。

簡單工廠模式優點

  • 工廠類是整個簡單工廠模式的關鍵所在。它包含必要的判斷邏輯，能夠根據外界給定的資訊（配置，或者引數），決定究竟應該建立哪個具體類的物件。使用者在使用時可以直接根據工廠類去建立所需的例項，而無需瞭解這些物件是如何建立以及如何組織的。有利於整個軟體體系結構的優化。
  • 通過引入配置檔案和反射，可以在不修改任何客戶端程式碼的情況下更換和增加新的具體產品類，在一定程度上提高了系統的靈活性（如CarFactory2）。
  • 客戶端無須知道所建立的具體產品類的類名，只需要知道具體產品類所對應的引數即可，對於一些複雜的類名，通過簡單工廠模式可以減少使用者的記憶量（如CarFactory3）。

簡單工廠模式缺點

  • 由於工廠類集中了所有例項的建立邏輯，這就直接導致一旦這個工廠出了問題，所有的客戶端都會受到牽連。
  • 由於簡單工廠模式的產品是基於一個共同的抽象類或者介面，這樣一來，產品的種類增加的時候，即有不同的產品介面或者抽象類的時候，工廠類就需要判斷何時建立何種介面的產品，這就和建立何種種類的產品相互混淆在了一起，違背了單一職責原則，導致系統喪失靈活性和可維護性。
  • 正如上文提到的，一般情況下（如CarFactory1），簡單工廠模式違背了“開放-關閉原則”，因為當我們新增加一個產品的時候必須修改工廠類，相應的工廠類就需要重新編譯一遍。但這一點可以利用反射（CarFactory3在本質上也是利用反射）在一定程度上解決（如CarFactory2）。
  • 使用反射可以使簡單工廠在一定條件下滿足“開放-關閉原則”，但這僅限於產品類的構造及初始化相同的場景。對於各產品例項化或者初始化不同的場景，很難利用反射滿足“開放-關閉”原則。
  • 簡單工廠模式由於使用了靜態工廠方法，造成工廠角色無法形成基於繼承的等級結構。這一點筆者持保留態度，因為繼承不是目的，如果沒有這樣的需求，這一點完全不算缺點，例如JDBC的DriverManager。

簡單工廠模式與OOP原則

已遵循的原則

  • 依賴倒置原則
  • 迪米特法則
  • 里氏替換原則
  • 介面隔離原則

未遵循的原則

  • 開閉原則（如上文所述，利用配置檔案+反射或者註解可以避免這一點）
  • 單一職責原則（工廠類即要負責邏輯判斷又要負責例項建立）

簡單工廠模式在JDK中的典型應用

簡單工廠模式在JDK中最典型的應用要數JDBC了。可以把關係型資料庫認為是一種抽象產品，各廠商提供的具體關係型資料庫（MySQL，PostgreSQL，Oracle）則是具體產品。DriverManager是工廠類。應用程式通過JDBC介面使用關係型資料庫時，並不需要關心具體使用的是哪種資料庫，而直接使用DriverManager的靜態方法去得到該資料庫的Connection。

package com.jasongj.client;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class JDBC {
  
  private static final Logger LOG = LoggerFactory.getLogger(JDBC.class);

  public static void main(String[] args) {
    Connection conn = null;
    try {
      Class.forName("org.apache.hive.jdbc.HiveDriver");
      conn = DriverManager.getConnection("jdbc:hive2://127.0.0.1:10000/default");
      PreparedStatement ps = conn.prepareStatement("select count(*) from test.test");
      ps.execute();
    } catch (SQLException ex) {
      LOG.warn("Execute query failed", ex);
    } catch(ClassNotFoundException e) {
      LOG.warn("Load Hive driver failed", e);
    } finally {
      if(conn != null ){
        try {
          conn.close();
        } catch (SQLException e) {
          // NO-OPT
        }
      }
    }
  }
}

Java設計模式系列

相關文章