当前位置：首页 > article >正文

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

article 2025/2/23 18:00:35

简单工厂模式（Simple Factory Pattern）虽然不属于 GoF 23 种经典设计模式，但在实际开发中非常常用，尤其是在 Spring Boot 项目中。它提供了一种简单的方式来创建对象，将对象的创建逻辑集中到一个工厂类中。

一、简单工厂模式的定义

简单工厂模式的核心思想是：

定义一个工厂类 (Factory Class)： 这个工厂类负责创建所有产品对象。
工厂类包含一个静态方法 (Static Method)： 这个静态方法根据传入的参数（通常是字符串类型或枚举类型），来决定创建哪种具体的产品对象。
客户端代码通过工厂类的静态方法获取产品对象： 客户端代码不需要直接使用 new 关键字创建对象，而是调用工厂类的静态方法，并传入相应的参数。

简单工厂模式的结构：

工厂类 (Factory)： 负责创建所有产品对象的类。
抽象产品类/接口 (Product)： 所有产品对象的共同父类或接口。
具体产品类 (ConcreteProduct)： 工厂类创建的具体对象类型。

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

优点：
- 简单易用： 实现简单，代码量少，容易理解。
- 封装创建逻辑： 将对象的创建逻辑集中到工厂类中，客户端代码无需关心对象的创建细节。
- 降低耦合度： 客户端代码不直接依赖于具体的产品类，而是依赖于工厂类和抽象产品类/接口。
缺点：
- 违反开闭原则： 当需要添加新的产品类型时，需要修改工厂类的代码（例如，添加新的 if-else 分支或 case 分支），这违反了开闭原则（对扩展开放，对修改关闭）。
- 工厂类职责过重： 工厂类负责创建所有产品对象，如果产品种类很多，工厂类的代码会变得很庞大，难以维护。
- 可扩展性差： 由于违反开闭原则，简单工厂模式的可扩展性较差。

三、在 Spring Boot 中使用简单工厂模式

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

直接使用静态方法：

创建一个工厂类，并在其中定义一个静态方法，根据参数创建不同的对象。

// 抽象产品接口
interface Product {
    void doSomething();
}

// 具体产品 A
class ConcreteProductA implements Product {
    @Override
    public void doSomething() {
        System.out.println("ConcreteProductA");
    }
}

// 具体产品 B
class ConcreteProductB implements Product {
    @Override
    public void doSomething() {
        System.out.println("ConcreteProductB");
    }
}

// 简单工厂类
public class SimpleFactory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ConcreteProductA();
        } else if ("B".equals(type)) {
            return new ConcreteProductB();
        } else {
            return null; // 或者抛出异常
        }
    }
}

// 使用
public class Client {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.doSomething();

        Product productB = SimpleFactory.createProduct("B");
        productB.doSomething();
    }
}

结合 Spring 的 @Component 和 @Autowired：

将工厂类注册为 Spring Bean（使用 @Component 注解）。
在需要使用工厂的地方，通过 @Autowired 注入工厂 Bean。
这种方式可以更好地利用 Spring 的依赖注入功能。

import org.springframework.stereotype.Component;

// ... (Product 接口和 ConcreteProductA, ConcreteProductB 类保持不变) ...

// 简单工厂类，使用 @Component 注册为 Spring Bean
@Component
public class SimpleFactory {
    public Product createProduct(String type) { // 不需要是静态方法了
        if ("A".equals(type)) {
            return new ConcreteProductA();
        } else if ("B".equals(type)) {
            return new ConcreteProductB();
        } else {
            return null;
        }
    }
}

// 使用
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class Client {

    @Autowired
    private SimpleFactory simpleFactory; // 注入 SimpleFactory

    public void run() {
        Product productA = simpleFactory.createProduct("A");
        productA.doSomething();

        Product productB = simpleFactory.createProduct("B");
        productB.doSomething();
    }
}

使用枚举 (Enum) 实现单例的简单工厂：

如果你的产品对象是无状态的, 并且每种类型只需要一个实例，可以使用枚举来实现简单工厂，同时保证单例。

interface Product {
    void doSomething();
}

// 具体产品 A
class ConcreteProductA implements Product {
    @Override
    public void doSomething() {
        System.out.println("ConcreteProductA");
    }
}

// 具体产品 B
class ConcreteProductB implements Product {
    @Override
    public void doSomething() {
        System.out.println("ConcreteProductB");
    }
}
// 使用枚举实现简单工厂
enum ProductFactory {
  INSTANCE;

  public Product createProduct(String type) {
    if ("A".equals(type)) {
      return new ConcreteProductA();
    } else if ("B".equals(type)) {
      return new ConcreteProductB();
    } else {
      return null;
    }
  }
}
//使用
Product product = ProductFactory.INSTANCE.createProduct("A");

结合@Configuration和@Bean:

你可以使用 @Configuration 和 @Bean 注解来定义工厂方法，并将工厂方法创建的对象注册为 Spring Bean。这种方式更符合 Spring 的配置风格。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

// ... (Product 接口和 ConcreteProductA, ConcreteProductB 类保持不变) ...

@Configuration
public class AppConfig {

    @Bean
    public Product productA() { // 工厂方法，创建 ConcreteProductA
        return new ConcreteProductA();
    }

    @Bean
    public Product productB() { // 工厂方法，创建 ConcreteProductB
        return new ConcreteProductB();
    }

    // 你也可以定义一个更通用的工厂方法，根据参数创建不同的 Bean
    @Bean
    public Product product(@Value("${product.type}") String productType) {
          if("A".equals(productType)){
              return new ConcreteProductA();
          } else {
              return new ConcreteProductB();
          }
    }
}

四、使用场景

简单工厂模式适用于以下场景：

创建对象种类较少： 如果需要创建的对象种类不多，并且创建逻辑比较简单，可以使用简单工厂模式。
客户端不需要关心对象的创建细节： 客户端只需要知道如何通过工厂类获取对象即可。
对象创建逻辑相对稳定： 如果对象的创建逻辑不经常变化，可以使用简单工厂模式。

五、与 Spring Boot 特性的结合

@Component 和 @Autowired： 将工厂类注册为 Spring Bean，方便依赖注入。
@Configuration 和 @Bean： 使用 @Bean 注解定义工厂方法，将工厂方法创建的对象注册为 Spring Bean。
@Value： 可以使用 @Value 注解从配置文件中读取参数，传递给工厂方法，实现更灵活的对象创建。
@Conditional： 可以使用 @Conditional 注解（例如 @ConditionalOnProperty、@ConditionalOnClass 等）来根据条件决定是否创建某个 Bean，实现更灵活的工厂配置。

六. 简单工厂模式退化为简单工具类

如果简单工厂模式中，工厂类只负责创建对象，没有任何其他的业务逻辑，那么这个工厂类实际上就退化成了一个简单的工具类。在这种情况下,是否使用工厂模式就看个人喜好了，因为并没有带来特别大的好处，也没有明显的坏处。

总结

简单工厂模式是一种简单易用的创建型设计模式，它可以封装对象的创建逻辑，降低代码耦合度。在 Spring Boot 中，你可以通过多种方式使用简单工厂模式，并结合 Spring 的特性来实现更灵活、更可维护的对象创建。但是，需要注意简单工厂模式违反开闭原则的缺点，如果需要频繁添加新的产品类型，可以考虑使用工厂方法模式或抽象工厂模式。

查看全文

http://www.kler.cn/a/552836.html