简单工厂模式 (Simple Factory Pattern) 在Spring Boot 中的应用

简单工厂模式（Simple Factory Pattern）固然不属于 GoF 23 种经典操持模式，但在实际开发中非经常用，尤其是在 Spring Boot 项目中。它提供了一种简单的方式来创建对象，将对象的创建逻辑会合到一个工厂类中。
一、简单工厂模式的界说
简单工厂模式的核心头脑是：

• 界说一个工厂类 (Factory Class)： 这个工厂类负责创建全部产物对象。
  
• 工厂类包罗一个静态方法 (Static Method)： 这个静态方法根据传入的参数（通常是字符串范例或罗列范例），来决定创建哪种详细的产物对象。
  
• 客户端代码通过工厂类的静态方法获取产物对象： 客户端代码不须要直接利用 new 关键字创建对象，而是调用工厂类的静态方法，并传入相应的参数。
  

简单工厂模式的结构：

• 工厂类 (Factory)： 负责创建全部产物对象的类。
  
• 抽象产物类/接口 (Product)： 全部产物对象的共同父类或接口。
  
• 详细产物类 (ConcreteProduct)： 工厂类创建的详细对象范例。
  

二、简单工厂模式的优缺点

• 优点：
  
  
  
  • 简单易用： 实现简单，代码量少，轻易明白。
    
  • 封装创建逻辑： 将对象的创建逻辑会合到工厂类中，客户端代码无需关心对象的创建细节。
    
  • 低沉耦合度： 客户端代码不直接依靠于详细的产物类，而是依靠于工厂类和抽象产物类/接口。
    
  
  
• 缺点：
  
  
  
  • 违背开闭原则： 当须要添加新的产物范例时，须要修改工厂类的代码（比方，添加新的 if-else 分支或 case 分支），这违背了开闭原则（对扩睁开放，对修改关闭）。
    
  • 工厂类职责过重： 工厂类负责创建全部产物对象，如果产物种类很多，工厂类的代码会变得很巨大，难以维护。
    
  • 可扩展性差： 由于违背开闭原则，简单工厂模式的可扩展性较差。
    
  
  

三、在 Spring Boot 中利用简单工厂模式
在 Spring Boot 中，你可以通过以下方式利用简单工厂模式：

• 直接利用静态方法：
  
  
  
  • 创建一个工厂类，并在此中界说一个静态方法，根据参数创建差别的对象。
    
  1. // 抽象产品接口
  2. interface Product {
  3.     void doSomething();
  4. }
  6. // 具体产品 A
  7. class ConcreteProductA implements Product {
  8.     @Override
  9.     public void doSomething() {
  10.         System.out.println("ConcreteProductA");
  11.     }
  12. }
  14. // 具体产品 B
  15. class ConcreteProductB implements Product {
  16.     @Override
  17.     public void doSomething() {
  18.         System.out.println("ConcreteProductB");
  19.     }
  20. }
  22. // 简单工厂类
  23. public class SimpleFactory {
  24.     public static Product createProduct(String type) {
  25.         if ("A".equals(type)) {
  26.             return new ConcreteProductA();
  27.         } else if ("B".equals(type)) {
  28.             return new ConcreteProductB();
  29.         } else {
  30.             return null; // 或者抛出异常
  31.         }
  32.     }
  33. }
  35. // 使用
  36. public class Client {
  37.     public static void main(String[] args) {
  38.         Product productA = SimpleFactory.createProduct("A");
  39.         productA.doSomething();
  41.         Product productB = SimpleFactory.createProduct("B");
  42.         productB.doSomething();
  43.     }
  44. }

  复制代码
• 团结 Spring 的 @Component 和 @Autowired：
  
  
  
  • 将工厂类注册为 Spring Bean（利用 @Component 注解）。
    
  • 在须要利用工厂的地方，通过 @Autowired 注入工厂 Bean。
    
  • 这种方式可以更好地利用 Spring 的依靠注入功能。
    
  1. import org.springframework.stereotype.Component;
  3. // ... (Product 接口和 ConcreteProductA, ConcreteProductB 类保持不变) ...
  5. // 简单工厂类，使用 @Component 注册为 Spring Bean
  6. @Component
  7. public class SimpleFactory {
  8.     public Product createProduct(String type) { // 不需要是静态方法了
  9.         if ("A".equals(type)) {
  10.             return new ConcreteProductA();
  11.         } else if ("B".equals(type)) {
  12.             return new ConcreteProductB();
  13.         } else {
  14.             return null;
  15.         }
  16.     }
  17. }
  19. // 使用
  20. import org.springframework.beans.factory.annotation.Autowired;
  21. import org.springframework.stereotype.Service;
  22. @Service
  23. public class Client {
  25.     @Autowired
  26.     private SimpleFactory simpleFactory; // 注入 SimpleFactory
  28.     public void run() {
  29.         Product productA = simpleFactory.createProduct("A");
  30.         productA.doSomething();
  32.         Product productB = simpleFactory.createProduct("B");
  33.         productB.doSomething();
  34.     }
  35. }

  复制代码
• 利用罗列 (Enum) 实现单例的简单工厂：
  
  
  
  • 如果你的产物对象是无状态的, 而且每种范例只须要一个实例，可以利用罗列来实现简单工厂，同时包管单例。
    
  1. interface Product {
  2.     void doSomething();
  3. }
  5. // 具体产品 A
  6. class ConcreteProductA implements Product {
  7.     @Override
  8.     public void doSomething() {
  9.         System.out.println("ConcreteProductA");
  10.     }
  11. }
  13. // 具体产品 B
  14. class ConcreteProductB implements Product {
  15.     @Override
  16.     public void doSomething() {
  17.         System.out.println("ConcreteProductB");
  18.     }
  19. }
  20. // 使用枚举实现简单工厂
  21. enum ProductFactory {
  22.   INSTANCE;
  24.   public Product createProduct(String type) {
  25.     if ("A".equals(type)) {
  26.       return new ConcreteProductA();
  27.     } else if ("B".equals(type)) {
  28.       return new ConcreteProductB();
  29.     } else {
  30.       return null;
  31.     }
  32.   }
  33. }
  34. //使用
  35. Product product = ProductFactory.INSTANCE.createProduct("A");

  复制代码
• 团结@Configuration和@Bean:
  
  
  
  • 你可以利用 @Configuration 和 @Bean 注解来界说工厂方法，并将工厂方法创建的对象注册为 Spring Bean。 这种方式更符合 Spring 的设置风格。
    1. import org.springframework.context.annotation.Bean;
    2. import org.springframework.context.annotation.Configuration;
    4. // ... (Product 接口和 ConcreteProductA, ConcreteProductB 类保持不变) ...
    6. @Configuration
    7. public class AppConfig {
    9.     @Bean
    10.     public Product productA() { // 工厂方法，创建 ConcreteProductA
    11.         return new ConcreteProductA();
    12.     }
    14.     @Bean
    15.     public Product productB() { // 工厂方法，创建 ConcreteProductB
    16.         return new ConcreteProductB();
    17.     }
    19.     // 你也可以定义一个更通用的工厂方法，根据参数创建不同的 Bean
    20.     @Bean
    21.     public Product product(@Value("${product.type}") String productType) {
    22.           if("A".equals(productType)){
    23.               return new ConcreteProductA();
    24.           } else {
    25.               return new ConcreteProductB();
    26.           }
    27.     }
    28. }

    复制代码
  
  

四、利用场景
简单工厂模式实用于以了局景：

• 创建对象种类较少： 如果须要创建的对象种类不多，而且创建逻辑比力简单，可以利用简单工厂模式。
  
• 客户端不须要关心对象的创建细节： 客户端只须要知道怎样通过工厂类获取对象即可。
  
• 对象创建逻辑相对稳固：  如果对象的创建逻辑不经常变革，可以利用简单工厂模式。
  

五、与 Spring Boot 特性的团结

• @Component 和 @Autowired： 将工厂类注册为 Spring Bean，方便依靠注入。
  
• @Configuration 和 @Bean： 利用 @Bean 注解界说工厂方法，将工厂方法创建的对象注册为 Spring Bean。
  
• @Value： 可以利用 @Value 注解从设置文件中读取参数，转达给工厂方法，实现更机动的对象创建。
  
• @Conditional： 可以利用 @Conditional 注解（比方 @ConditionalOnProperty、@ConditionalOnClass 等）来根据条件决定是否创建某个 Bean，实现更机动的工厂设置。
  

六. 简单工厂模式退化为简单工具类
如果简单工厂模式中，工厂类只负责创建对象，没有任何其他的业务逻辑，那么这个工厂类实际上就退化成了一个简单的工具类。在这种情况下,是否利用工厂模式就看个人喜欢了，由于并没有带来特别大的利益，也没有显着的毛病。
总结
简单工厂模式是一种简单易用的创建型操持模式，它可以封装对象的创建逻辑，低沉代码耦合度。 在 Spring Boot 中，你可以通过多种方式利用简单工厂模式，并团结 Spring 的特性来实现更机动、更可维护的对象创建。 但是，须要留意简单工厂模式违背开闭原则的缺点，如果须要频仍添加新的产物范例，可以思量利用工厂方法模式或抽象工厂模式。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。