一文搞懂設計模式—工廠方法模式
在面向對象設計中，經常需要創建對象實例。傳統的方式是在代碼中直接使用 new 關鍵字來創建對象，但這種方式可能會導致高耦合和難以擴展。
工廠方法模式屬于創建型模式，通過定義一個用于創建對象的接口，將具體的實例化延遲到子類中，提供了一種靈活、可擴展的對象創建方式，使得系統更加符合開閉原則。
使用場景
工廠方法模式適用于以下場景：
- 對象的創建過程比較復雜，包含一系列步驟或依賴關系，需要隱藏創建細節，只關注對象的使用。
- 需要在運行時動態決定創建哪個具體對象。
- 希望通過擴展工廠類來添加新的產品，而不是修改已有的代碼。
一個常見的工廠方法模式在 Spring 中的應用例子是通過 FactoryBean 接口來創建自定義的工廠 Bean。
假設我們有一個名為 UserService 的服務類，它依賴于另一個名為 UserRepository 的數據訪問對象。我們可以使用工廠方法模式來創建 UserService 實例，并將其作為一個 Bean 注冊到 Spring 容器中。
首先，我們創建一個實現了 FactoryBean<UserService> 接口的工廠類 UserServiceFactory：
public class UserServiceFactory implements FactoryBean<UserService> {
private UserRepository userRepository;
public void setUserRepository(UserRepository userRepository) {
this.userRepository = userRepository;
}
@Override
public UserService getObject() throws Exception {
UserService userService = new UserService();
userService.setUserRepository(userRepository);
return userService;
}
@Override
public Class<?> getObjectType() {
return UserService.class;
}
@Override
public boolean isSingleton() {
return true;
}
}在上述代碼中，UserServiceFactory 實現了 FactoryBean<UserService> 接口，并重寫了相關方法。在 getObject() 方法中，我們創建了一個 UserService實例，并設置了其依賴的 UserRepository。getObjectType() 方法返回了工廠創建的對象類型，isSingleton() 方法表示該工廠創建的對象是否為單例。
接下來，我們需要將 UserServiceFactory 和 UserRepository 注冊到Spring容器中。可以通過XML配置文件進行配置：
<bean id="userRepository" class="com.example.UserRepository"/>
<bean id="userServiceFactory" class="com.example.UserServiceFactory">
<property name="userRepository" ref="userRepository"/>
</bean>
<bean id="userService" factory-bean="userServiceFactory" factory-method="getObject"/>在上述配置中，我們首先創建了一個 UserRepository 的Bean，并將其注入到 UserServiceFactory 工廠類中。然后，通過 factory-bean 屬性指定使用userServiceFactory 工廠來創建 userService 的實例。
這樣，當Spring容器初始化時，會自動調用 UserServiceFactory 的 getObject() 方法來創建 UserService 實例，并將其作為一個 Bean 注冊到容器中。可以通過 @Autowired 或其他方式來注入 UserService 對象，并使用它的服務。
通過這種方式，我們成功地應用了工廠方法模式，在 Spring 中管理和創建了 UserService 實例，并解耦了對象的創建和依賴注入過程。
具體實現
工廠方法模式涉及以下幾個角色：
- 抽象產品（Abstract Product）：定義了產品的抽象接口或抽象類，具體產品需要實現這個接口或繼承這個抽象類。
- 具體產品（Concrete Product）：實現了抽象產品定義的接口或繼承抽象產品的抽象類，是工廠方法模式所創建的對象。
- 抽象工廠（Abstract Factory）：定義了一個創建產品對象的抽象工廠接口，其中包含了創建產品的抽象方法。
- 具體工廠（Concrete Factory）：實現了抽象工廠接口，負責創建具體的產品對象。具體工廠類通常含有與業務相關的邏輯，并在工廠方法中實例化具體產品對象。
在工廠方法模式中，抽象工廠和抽象產品是核心，而具體工廠和具體產品則根據實際需求進行擴展和實現。
通過這些角色的協作，工廠方法模式實現了將產品的創建過程封裝起來，使得客戶端與具體產品解耦，同時也提供了靈活性和可擴展性。
抽象產品類和具體產品類
首先定義一個抽象產品類 Product：
public abstract class Product {
public abstract void use();
}然后創建具體產品類，如 ConcreteProductA 和 ConcreteProductB，它們分別繼承自 Product 并實現了其中的抽象方法。
public class ConcreteProductA extends Product {
@Override
public void use(){
System.out.println("use ConcreteProductA");
}
}public class ConcreteProductB extends Product {
@Override
public void use(){
System.out.println("use ConcreteProductB");
}
}抽象工廠類和具體工廠類
接下來定義一個抽象工廠類 Factory，其中包含一個抽象的工廠方法 createProduct()，用于創建具體的產品對象：
public abstract class Factory {
public abstract Product createProduct();
}對于每個具體產品，創建相應的具體工廠類：
public class ConcreteFactoryA extends Factory {
@Override
public Product createProduct() {
return new ConcreteProductA();
}
}public class ConcreteFactoryB extends Factory {
@Override
public Product createProduct() {
return new ConcreteProductB();
}
}客戶端代碼
在客戶端代碼中，我們可以根據需要選擇不同的具體工廠類來創建產品對象。
public class Client {
public static void main(String[] args) {
Factory factory = new ConcreteFactoryA();
Product product = factory.createProduct();
product.use();
}
}通過工廠方法模式，我們將對象的創建過程分散到不同的具體工廠類中，每個具體工廠類只負責創建對應的產品對象。這樣可以降低代碼的耦合度，同時也方便添加新的產品和工廠。
優點
- 符合開閉原則：工廠方法模式將產品的創建過程封裝在具體工廠類中，新增產品時只需添加對應的工廠類，而無需修改已有的代碼。
- 客戶端與具體產品解耦：客戶端代碼只和抽象工廠類以及抽象產品類交互，無需關心具體的實現細節，從而實現了高層模塊和底層模塊的解耦。
- 擴展性好：通過添加新的具體工廠類和具體產品類，可以靈活地擴展系統，符合開放封閉原則。
- 容易進行單元測試：由于工廠方法模式將對象的創建過程封裝到具體工廠類中，我們可以輕松地替換具體工廠類來進行單元測試，提高代碼的可測試性。
缺點
- 類的數量增加：引入工廠方法模式會增加類的數量，增加了系統的復雜度。
- 增加了系統的抽象性和理解難度：相比于簡單工廠模式，工廠方法模式引入了更多的抽象類和接口，對于初學者來說可能更難理解。
注意：工廠方法模式適合復雜對象，而簡單對象，特別是只需要通過 new 就可以完成創建的對象，無需使用工廠模式。如果使用工廠模式，就需要引入一個工廠類，會增加系統的復雜度。
簡單工廠模式
當只有少量具體產品類時，并且對象的創建邏輯相對簡單，沒有必要為每個具體產品類創建一個對應的工廠類，此時使用簡單工廠模式會更加簡潔和直觀。
簡單工廠模式（Simple Factory Pattern）是工廠方法模式的弱化。
簡單工廠模式由三個主要角色組成：
- 工廠類（Factory Class）：負責創建對象的核心類，它通常包含一個靜態方法或者非靜態方法，根據客戶端傳入的參數來創建相應的對象實例。
- 抽象產品類（Abstract Product Class）：定義了具體產品類的共同接口或抽象類，描述了產品的通用行為。
- 具體產品類（Concrete Product Class）：實現了抽象產品類所定義的接口或抽象類，具體產品類是工廠類所創建的目標對象。
下面是一個簡單的示例代碼，演示了簡單工廠模式的實現：
// 抽象產品類
public interface Animal {
void speak();
}
// 具體產品類1
public class Cat implements Animal {
@Override
public void speak() {
System.out.println("Meow!");
}
}
// 具體產品類2
public class Dog implements Animal {
@Override
public void speak() {
System.out.println("Woof!");
}
}
// 工廠類
public class AnimalFactory {
public static Animal createAnimal(String type) {
if (type.equalsIgnoreCase("cat")) {
return new Cat();
} else if (type.equalsIgnoreCase("dog")) {
return new Dog();
}
throw new IllegalArgumentException("Invalid animal type: " + type);
}
}在上述代碼中，我們定義了一個抽象產品類 Animal，并有兩個具體產品類 Cat 和 Dog，它們都實現了 Animal 接口。工廠類 AnimalFactory 負責根據客戶端傳入的參數創建相應的具體產品對象。
使用簡單工廠模式，客戶端可以通過調用工廠類的靜態方法 createAnimal() 來獲取所需的具體產品對象。例如：
Animal cat = AnimalFactory.createAnimal("cat");
cat.speak(); // 輸出：Meow!
Animal dog = AnimalFactory.createAnimal("dog");
dog.speak(); // 輸出：Woof!簡單工廠模式因為工廠類定義了一個靜態方法，因此也叫做靜態工廠模式。其缺點是工廠類的擴展比較困難，不符合開閉原則，并且隨著產品類型增多，簡單工廠模式工廠類的代碼可能會變得復雜，因此不適用于大規模或復雜的應用程序，但它仍然是一個非常實用的設計模式。
延遲初始化
延遲初始化：一個對象被消費完畢后，并不立刻釋放，工廠類保持其初始狀態，等待再次被使用。
延遲加載的工廠類，參考代碼如下：
public class ProductFactory {
private static final Map<String, Product> prMap = new HashMap();
public static synchronized Product createProduct(String type) throws Exception {
Product product = null;
//如果Map中已經有這個對象
if (prMap.containsKey(type)) {
product = prMap.get(type);
} else {
if (type.equals("Product1")) {
product = new ConcreteProduct1();
} else {
product = new ConcreteProduct2();
}
//同時把對象放到緩存容器中
prMap.put(type, product);
}
return product;
}
}代碼算是比較簡單，通過定義一個Map容器，容納所有產生的對象，如果在Map容器中已經有的對象，則直接取出返回；如果沒有，則根據需要的類型產生一個對象并放入到Map容器中，以方便下次調用。
這樣的好處是可以限制某一個產品類的最大實例化數量，通過判斷Map中已有的對象數量來實現。
延遲加載在對象初始化比較復雜的情況下，可以降低對象的產生和銷毀帶來的復雜性。這是非常有意義的，例如 JDBC 連接數據庫，都會要求設置一個 MaxConnections 最大連接數量，該數量就是內存中最大實例化的數量。
總結
工廠方法模式使用的頻率非常高，工廠方法模式通過定義抽象工廠類和抽象產品類，將對象的創建委托給子類來實現。它提供了一種靈活、可擴展的對象創建方式，符合開閉原則，并且降低了代碼的耦合度。
通過合理地使用工廠方法模式，我們可以提高代碼的靈活性、可擴展性和可維護性，從而構建更優秀的軟件系統。
