设计模式——简单工厂模式（创建型）

摘要

本文主要介绍了简单工厂模式，包括其定义、结构、实现方式、适用场景、实战示例以及思考。简单工厂模式是一种创建型设计模式，通过工厂类根据参数决定创建哪一种产品类的实例，封装了对象创建的细节，使客户端无需关心具体类的创建逻辑。文章详细阐述了其角色组成、类图、时序图，探讨了两种常见的实现方式，分析了适合与不适合的场景，并提供了 Spring 项目和可插拔式策略工厂的实战示例。最后，还提出了支持 SPI 机制、注解标记策略名称和配置中心切换策略等思考方向。

1. 简单工厂模式定义

简单工厂模式是一种创建型设计模式，它通过一个工厂类根据传入的参数决定创建哪一种产品类的实例。

核心要点：

• 核心角色：工厂类（Factory）

• • 负责创建产品对象。
  • 客户端只需传递参数，不关心具体类的创建逻辑。

• 目标：封装对象创建的细节，将创建对象的逻辑从使用者中分离出来。

组成结构：

2. 简单工厂模式结构

2.1. 简单工厂类图

2.2. 简单工厂时序图

3. 简单工厂模式实现方式

实现方式主要分为两种：

3.1. ✅ 实现方式 1：静态方法创建产品对象（最常见）

// 抽象产品
public interface Product {
    void doWork();
}

// 具体产品 A
public class ProductA implements Product {
    public void doWork() {
        System.out.println("产品A正在工作");
    }
}

// 具体产品 B
public class ProductB implements Product {
    public void doWork() {
        System.out.println("产品B正在工作");
    }
}

// 简单工厂
public class SimpleFactory {
    public static Product createProduct(String type) {
        if ("A".equalsIgnoreCase(type)) {
            return new ProductA();
        } else if ("B".equalsIgnoreCase(type)) {
            return new ProductB();
        }
        throw new IllegalArgumentException("不支持的产品类型：" + type);
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        Product product = SimpleFactory.createProduct("A");
        product.doWork();  // 输出：产品A正在工作
    }
}

3.2. ✅ 实现方式 2：使用工厂实例方法创建产品对象（便于配置）

// 工厂类
public class SimpleFactory {
    
    public Product createProduct(String type) {
        if ("A".equalsIgnoreCase(type)) {
            return new ProductA();
        } else if ("B".equalsIgnoreCase(type)) {
            return new ProductB();
        }
        throw new IllegalArgumentException("不支持的产品类型：" + type);
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        SimpleFactory factory = new SimpleFactory();
        Product product = factory.createProduct("B");
        product.doWork();  // 输出：产品B正在工作
    }
}

3.3. 🧠 简单工厂实现总结

4. 简单工厂模式适合场景

4.1. ✅ 适合的场景（推荐使用简单工厂）：

📌 示例：日志输出、支付方式选择、消息发送器选择（短信/邮件/微信）等。

4.2. ❌ 不适合的场景（不推荐使用简单工厂）：

📌 示例：大型系统中涉及复杂对象生命周期控制的场景（如数据库连接池、线程池、配置驱动类等）。

4.3. ✅ 使用建议总结：

5. 简单工厂模式实战示例

5.1. Spring项目中简单工厂示例

我们以“消息发送系统”为例，演示如何使用简单工厂根据输入创建不同的消息发送器（如短信、邮件、微信等）。

5.1.1. ✅ 场景目标

在 Spring 项目中，根据配置选择不同的消息发送器进行发送，如：

• 配置为 sms：发送短信；
• 配置为 email：发送邮件；
• 配置为 wechat：发送微信。

5.1.2. ✅ 定义统一接口

public interface MessageSender {
    void send(String message);
}

5.1.3. ✅ 三种发送器的实现类

@Component("smsSender")
public class SmsSender implements MessageSender {
    public void send(String message) {
        System.out.println("发送短信：" + message);
    }
}

@Component("emailSender")
public class EmailSender implements MessageSender {
    public void send(String message) {
        System.out.println("发送邮件：" + message);
    }
}

@Component("wechatSender")
public class WechatSender implements MessageSender {
    public void send(String message) {
        System.out.println("发送微信：" + message);
    }
}

5.1.4. ✅ 简单工厂类（使用 Spring 容器管理）

@Component
public class MessageSenderFactory {

    @Autowired
    private ApplicationContext applicationContext;

    public MessageSender createSender(String type) {
        switch (type.toLowerCase()) {
            case "sms":
                return applicationContext.getBean("smsSender", MessageSender.class);
            case "email":
                return applicationContext.getBean("emailSender", MessageSender.class);
            case "wechat":
                return applicationContext.getBean("wechatSender", MessageSender.class);
            default:
                throw new IllegalArgumentException("不支持的消息类型：" + type);
        }
    }
}

5.1.5. ✅ 使用示例（Controller 或 Service）

@Service
public class NotifyService {

    @Autowired
    private MessageSenderFactory messageSenderFactory;

    // 模拟从配置文件或参数中读取类型
    @Value("${message.type:sms}")
    private String messageType;

    public void notifyUser(String content) {
        MessageSender sender = messageSenderFactory.createSender(messageType);
        sender.send(content);
    }
}

5.1.6. ✅ 应用入口（或 Controller）

@RestController
public class MessageController {

    @Autowired
    private NotifyService notifyService;

    @GetMapping("/send")
    public String send(@RequestParam String msg) {
        notifyService.notifyUser(msg);
        return "消息已发送";
    }
}

5.1.7. ✅ application.yml 示例配置

message:
  type: email

5.1.8. ✅ 简单工厂示例总结

5.2. 可插拔式策略工厂（使用 SPI、Map 注册） 示例

下面是一个 可插拔式策略工厂（基于 Map 注册 + Spring 管理） 的完整示例，非常适用于需要动态切换、按配置扩展的业务策略类，比如：消息发送、支付渠道、风控策略、营销活动处理器等。实现一种 灵活可扩展 的策略选择工厂，每个策略自动注册 到一个 Map<String, Strategy> 中，不需要手动 switch-case。

5.2.1. ✅ 定义统一接口（策略接口）

public interface MessageSender {
    String type(); // 每个实现类提供自己的标识
    void send(String message);
}

5.2.2. ✅ 三种发送实现类（@Component 自动注入）

@Component
public class SmsSender implements MessageSender {
    public String type() {
        return "sms";
    }

    public void send(String message) {
        System.out.println("【短信】发送：" + message);
    }
}

@Component
public class EmailSender implements MessageSender {
    public String type() {
        return "email";
    }

    public void send(String message) {
        System.out.println("【邮件】发送：" + message);
    }
}

@Component
public class WechatSender implements MessageSender {
    public String type() {
        return "wechat";
    }

    public void send(String message) {
        System.out.println("【微信】发送：" + message);
    }
}

5.2.3. ✅ 自动注册策略工厂（Map 注册方式）

@Component
public class MessageSenderFactory {

    private final Map<String, MessageSender> senderMap = new HashMap<>();

    // Spring 会自动注入所有 MessageSender 的实现类
    @Autowired
    public MessageSenderFactory(List<MessageSender> senders) {
        for (MessageSender sender : senders) {
            senderMap.put(sender.type(), sender);
        }
    }

    public MessageSender getSender(String type) {
        MessageSender sender = senderMap.get(type);
        if (sender == null) {
            throw new IllegalArgumentException("不支持的消息类型: " + type);
        }
        return sender;
    }
}

5.2.4. ✅ 使用策略工厂的服务类

@Service
public class NotifyService {

    @Autowired
    private MessageSenderFactory messageSenderFactory;

    public void notifyUser(String type, String content) {
        MessageSender sender = messageSenderFactory.getSender(type);
        sender.send(content);
    }
}

5.2.5. ✅ Controller 示例

@RestController
@RequestMapping("/msg")
public class MessageController {

    @Autowired
    private NotifyService notifyService;

    @GetMapping("/send")
    public String send(@RequestParam String type, @RequestParam String msg) {
        notifyService.notifyUser(type, msg);
        return "消息已发送";
    }
}

5.2.6. ✅ 示例调用

请求：

GET /msg/send?type=sms&msg=Hello_SMS
GET /msg/send?type=email&msg=Hello_Email
GET /msg/send?type=wechat&msg=Hello_WeChat

输出：

【短信】发送：Hello_SMS
【邮件】发送：Hello_Email
【微信】发送：Hello_WeChat

5.2.7. 🚀 可插拔式策略工厂优势总结

5.3. 🔌 简单工厂设计模式可拓展方向（高级）

• 支持 SPI 机制（META-INF/services），用于插件式加载（可用于 jar 扩展、热插拔）；
• 支持 注解标记策略名称；
• 支持配置中心切换策略，如使用 @Value("${message.type}") 注入默认策略。

6. 简单工厂模式思考

6.1. 支持 SPI 机制（META-INF/services），用于插件式加载（可用于 jar 扩展、热插拔）；

下面是一个完整的 基于 Java SPI（Service Provider Interface）机制的插件式策略工厂实现示例，它常用于实现模块解耦、可插拔、动态扩展功能。以“消息发送策略”为例，不使用 Spring 注解扫描，而是通过 SPI 机制动态加载所有实现类。

6.1.1. 🧩 定义 SPI 接口（策略接口）

// src/main/java/com/example/spi/MessageSender.java
package com.example.spi;

public interface MessageSender {
    String type();             // 返回类型标识符
    void send(String message); // 发送消息逻辑
}

6.1.2. 📝 实现类（位于独立模块 / jar 中）

// src/main/java/com/example/impl/SmsSender.java
package com.example.impl;

import com.example.spi.MessageSender;

public class SmsSender implements MessageSender {

    @Override
    public String type() {
        return "sms";
    }

    @Override
    public void send(String message) {
        System.out.println("【短信发送】" + message);
    }
}

6.1.3. 🗂️ 3SPI 注册文件

在 jar 包中的 resources/META-INF/services/ 路径下创建文件：

META-INF/services/com.example.spi.MessageSender

内容如下（每一行一个实现类的全限定名）：

com.example.impl.SmsSender

✅ 当你有多个策略实现时，添加多行即可，如：

com.example.impl.SmsSender
com.example.impl.EmailSender

6.1.4. ⚙️ 工厂类：动态加载所有策略实现

package com.example.factory;

import com.example.spi.MessageSender;

import java.util.*;

public class MessageSenderFactory {

    private final Map<String, MessageSender> senderMap = new HashMap<>();

    public MessageSenderFactory() {
        // 加载spi接口所有接口实现类
        ServiceLoader<MessageSender> loader = ServiceLoader.load(MessageSender.class);
        for (MessageSender sender : loader) {
            senderMap.put(sender.type(), sender);
        }
    }

    public MessageSender getSender(String type) {
        MessageSender sender = senderMap.get(type);
        if (sender == null) {
            throw new IllegalArgumentException("不支持的消息类型: " + type);
        }
        return sender;
    }
}

ServiceLoader<MessageSender> loader = ServiceLoader.load(MessageSender.class);

是 Java 原生 SPI（Service Provider Interface）机制 的核心。它的底层原理其实并不复杂，是通过读取类路径下的 META-INF/services/ 目录下的文件，并利用反射机制加载实现类。以下是 ServiceLoader 的简化执行逻辑：

// 从 META-INF/services/ 下查找接口对应的配置文件
Enumeration<URL> urls = classLoader.getResources("META-INF/services/" + serviceClass.getName());

// 读取文件中的类名
BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream()));
String implClassName = reader.readLine();

// 通过反射实例化对象
Class<?> clazz = Class.forName(implClassName);
Object instance = clazz.newInstance();

每个实现类会被加载成一个对象，并返回一个延迟加载的迭代器。

6.1.5. 🧪 使用示例（main 方法中调用）

public class Main {
    public static void main(String[] args) {
        MessageSenderFactory factory = new MessageSenderFactory();
        MessageSender sender = factory.getSender("sms");
        sender.send("Hello SPI!");
    }
}

6.1.6. 🎯 整体结构

src/
├── main/
│   ├── java/
│   │   ├── com.example.spi/MessageSender.java
│   │   ├── com.example.impl/SmsSender.java
│   │   └── com.example.factory/MessageSenderFactory.java
│   └── resources/
│       └── META-INF/services/com.example.spi.MessageSender

6.1.7. 📌 SPI 模式的优点

6.1.8. 🚫 注意事项

• SPI 默认是懒加载 + 非线程安全（如有并发需求请做好缓存）；
• IDE 无法提示类名（注册文件中填写错误 IDE 不会报警）；
• 多个 jar 中存在相同接口实现可能冲突；
• 如果你使用的是 SpringBoot，推荐改用 Spring 的 SPI（如 spring.factories 或 spring.factories → spring/org.springframework.boot.autoconfigure.EnableAutoConfiguration）机制配合。

6.2. 支持注解标记策略名称

在 策略模式 中，支持通过 注解 来标记每个策略的名称，可以极大提升策略类的可读性和扩展性，尤其适用于 SPI、Map 注册、Spring 容器注册等场景。

• 多个 MessageSender 策略实现类
• 每个类通过注解标记其类型名称（如 @MessageType("sms")）
• 使用 Map 注册所有策略，支持动态获取

6.2.1. ✅ 定义注解

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MessageType {
    String value();  // 策略类型标识
}

6.2.2. ✅ 定义接口

public interface MessageSender {
    void send(String message);
}

6.2.3. ✅ 实现策略类 + 注解标记

@MessageType("sms")
public class SmsSender implements MessageSender {
    @Override
    public void send(String message) {
        System.out.println("发送短信: " + message);
    }
}

@MessageType("email")
public class EmailSender implements MessageSender {
    @Override
    public void send(String message) {
        System.out.println("发送邮件: " + message);
    }
}

6.2.4. ✅ 自动注册工厂类（注解扫描）

public class MessageSenderFactory {

    private final Map<String, MessageSender> senderMap = new HashMap<>();

    public MessageSenderFactory() {
        // SPI 加载所有 MessageSender 实现类
        ServiceLoader<MessageSender> loader = ServiceLoader.load(MessageSender.class);
        for (MessageSender sender : loader) {
            MessageType annotation = sender.getClass().getAnnotation(MessageType.class);
            if (annotation != null) {
                senderMap.put(annotation.value(), sender);
            }
        }
    }

    public MessageSender getSender(String type) {
        MessageSender sender = senderMap.get(type);
        if (sender == null) {
            throw new IllegalArgumentException("不支持的消息类型: " + type);
        }
        return sender;
    }
}

6.2.5. ✅ 使用示例

public class Main {
    public static void main(String[] args) {
        MessageSenderFactory factory = new MessageSenderFactory();
        factory.getSender("sms").send("验证码123456");
        factory.getSender("email").send("欢迎邮件");
    }
}

6.2.6. ✅ 优点

• 注解直观标记类型，无需硬编码注册
• 扩展一个新策略只需添加一个类并标注注解
• 与 ServiceLoader/Spring 配合使用，支持动态发现

6.3. 支持配置中心切换策略，如使用 @Value("${message.type}") 注入默认策略。

你希望实现一种 支持配置中心动态切换策略 的能力，例如通过配置中心的属性（如 Nacos、Apollo、Spring Cloud Config 等）控制当前策略的类型：实现思路（Spring + 注解 + Map 注册 + 配置驱动）

6.3.1. ✅ 定义策略注解

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MessageType {
    String value();
}

6.3.2. ✅ 定义通用接口

public interface MessageSender {
    void send(String message);
}

6.3.3. ✅ 多个策略实现类

@Component
@MessageType("sms")
public class SmsSender implements MessageSender {
    public void send(String message) {
        System.out.println("发送短信: " + message);
    }
}

@Component
@MessageType("email")
public class EmailSender implements MessageSender {
    public void send(String message) {
        System.out.println("发送邮件: " + message);
    }
}

6.3.4. ✅ 策略工厂（Spring 容器自动注册 + 配置驱动）

@Component
public class MessageSenderFactory implements InitializingBean {

    @Value("${message.type:email}")  // 默认email，可由配置中心动态更新
    private String defaultType;

    @Autowired
    private List<MessageSender> senderList;

    private final Map<String, MessageSender> senderMap = new HashMap<>();

    @Override
    public void afterPropertiesSet() {
        for (MessageSender sender : senderList) {
            MessageType annotation = sender.getClass().getAnnotation(MessageType.class);
            if (annotation != null) {
                senderMap.put(annotation.value(), sender);
            }
        }
    }
    /*
    * 如果使用默认方式，采用的就是nacos 配置策略
    */
    public MessageSender getSender() {
        MessageSender sender = senderMap.get(defaultType);
        if (sender == null) {
            throw new IllegalArgumentException("未找到对应的策略类型: " + defaultType);
        }
        return sender;
    }
    
    /*
    * 使用入参对应的策略
    */
    public MessageSender getSender(String type) {
        MessageSender sender = senderMap.get(type);
        if (sender == null) {
            throw new IllegalArgumentException("未找到对应的策略类型: " + type);
        }
        return sender;
    }
}

6.3.5. ✅ 使用示例

@RestController
public class MessageController {

    @Autowired
    private MessageSenderFactory factory;

    /*
    * 如果使用默认方式，采用的就是nacos配置策略
    */
    @GetMapping("/send")
    public String send(@RequestParam String msg) {
        factory.getSender().send(msg);
        return "消息已发送";
    }

    /*
    * 如果使用入参对应方式发送
    */
    @GetMapping("/email/send")
    public String send(@RequestParam String sendType, @RequestParam String msg) {
        factory.getSender(sendType).send(msg);
        return "消息已发送";
    }
}

6.3.6. ✅ 配置变更如何生效（支持热刷新）？

如果你使用配置中心（如 Nacos），你还可以让 @Value("${message.type}") 自动刷新：

@RefreshScope
@Component
public class MessageSenderFactory implements InitializingBean {
    ...
}

这样，在 Nacos 修改 message.type=email 为 sms，会实时切换策略。

6.3.7. ✅ 总结优势

6.4. 使用SPI 机制（META-INF/services），用于插件式加载（可用于 jar 扩展、热插拔）；与普通简单工厂方法实现区别？

使用 SPI 机制（META-INF/services） 和 普通简单工厂模式 都是实现“根据类型返回不同实现类”的策略工厂思想，但它们在实现机制、应用场景和扩展性上有很大不同。以下是详细对比和说明：

6.4.1. 🔍 核心区别对比表

6.4.2. 🧩 SPI机制（JDK ServiceLoader）工作原理

• 你要做的：

1. 1. 定义一个接口，比如：MessageSender
   2. 实现多个类，比如：EmailSender、SmsSender 并实现该接口
   3. 在 resources/META-INF/services/com.example.spi.MessageSender 文件中列出所有实现类的 全限定类名

com.example.sender.EmailSender
com.example.sender.SmsSender

• 运行时使用 ServiceLoader 自动扫描并实例化：

ServiceLoader<MessageSender> loader = ServiceLoader.load(MessageSender.class);
for (MessageSender sender : loader) {
    senderMap.put(sender.type(), sender);
}

📦 实现类可以是外部 jar 包，插件式部署。无需改主程序代码。

6.4.3. 🛠️ 简单工厂模式实现方式

实现逻辑通常在代码里“硬编码”注册每种类型与实现类的关系：

public class SenderFactory {
    private static final Map<String, MessageSender> map = new HashMap<>();

    static {
        map.put("email", new EmailSender());
        map.put("sms", new SmsSender());
    }

    public static MessageSender getSender(String type) {
        return map.get(type);
    }
}

🧱 实现类和工厂强耦合，新增类型时，必须改代码、重编、重新部署。

6.4.4. 🚦 使用场景对比

7. 博文参考

• 1. 简单工厂模式( Simple Factory Pattern ) — Graphic Design Patterns
• 创建型 - 简单工厂(Simple Factory) | Java 全栈知识体系