告别new的蛮荒时代,走进对象制造的"精致车间"
大家好!欢迎来到设计模式系列的第三篇!🎉 今天我们要聊的是排行榜第二,堪称"最实用"的模式——工厂模式 (Factory Pattern)。它是我们告别硬编码new关键字,走向灵活对象创建的第一步!
一、为什么需要工厂模式?🤔
先来看一个常见的场景:
// 传统方式 - 硬编码
if (paymentType.equals("alipay")) {
payment = new Alipay();
} else if (paymentType.equals("wechat")) {
payment = new WechatPay();
} else if (paymentType.equals("union")) {
payment = new UnionPay();
}
// 每增加一种支付方式,就要修改这里的代码
😫 痛点分析:
-
违反开闭原则:新增支付类型需要修改原有代码
-
耦合度高:客户端需要知道所有具体实现类
-
难以维护:if-else泛滥,代码臃肿
二、工厂模式的三兄弟 👨👦👦
工厂模式其实是一个"家族",包含三种不同的形态:

2.1 简单工厂模式 (Simple Factory) 🏭
核心思想:把对象的创建封装在一个工厂类中
// 产品接口
public interface Payment {
void pay();
}
// 具体产品
public class Alipay implements Payment {
@Override
public void pay() {
System.out.println("支付宝支付");
}
}
public class WechatPay implements Payment {
@Override
public void pay() {
System.out.println("微信支付");
}
}
// 简单工厂
public class PaymentFactory {
public static Payment createPayment(String type) {
if ("alipay".equalsIgnoreCase(type)) {
return new Alipay();
} else if ("wechat".equalsIgnoreCase(type)) {
return new WechatPay();
}
throw new IllegalArgumentException("不支持的支付类型");
}
}
// 使用
public class Client {
public static void main(String[] args) {
Payment payment = PaymentFactory.createPayment("alipay");
payment.pay(); // 输出:支付宝支付
}
}
✅ 优点:客户端与具体实现解耦 ❌ 缺点:仍然违反开闭原则(修改工厂类)
2.2 工厂方法模式 (Factory Method) 🎯
核心思想:定义一个创建对象的接口,让子类决定实例化哪一个类
// 产品接口
public interface Logger {
void log(String message);
}
// 具体产品
public class FileLogger implements Logger {
@Override
public void log(String message) {
System.out.println("文件日志: " + message);
}
}
public class DatabaseLogger implements Logger {
@Override
public void log(String message) {
System.out.println("数据库日志: " + message);
}
}
// 工厂接口
public interface LoggerFactory {
Logger createLogger();
}
// 具体工厂
public class FileLoggerFactory implements LoggerFactory {
@Override
public Logger createLogger() {
return new FileLogger();
}
}
public class DatabaseLoggerFactory implements LoggerFactory {
@Override
public Logger createLogger() {
return new DatabaseLogger();
}
}
// 使用
public class Client {
public static void main(String[] args) {
LoggerFactory factory = new FileLoggerFactory();
Logger logger = factory.createLogger();
logger.log("这是一个测试日志");
}
}
✨ 模式结构:

✅ 优点:完全符合开闭原则,扩展性强 ❌ 缺点:类的数量增多,系统更复杂
2.3 抽象工厂模式 (Abstract Factory) 🏗️
核心思想:创建相关或依赖对象的家族,而不需要明确指定具体类
// 抽象产品族
public interface Button {
void render();
}
public interface TextField {
void input();
}
// 具体产品族 - Light主题
public class LightButton implements Button {
@Override
public void render() {
System.out.println("渲染浅色主题按钮");
}
}
public class LightTextField implements TextField {
@Override
public void input() {
System.out.println("浅色主题文本输入框");
}
}
// 具体产品族 - Dark主题
public class DarkButton implements Button {
@Override
public void render() {
System.out.println("渲染深色主题按钮");
}
}
public class DarkTextField implements TextField {
@Override
public void input() {
System.out.println("深色主题文本输入框");
}
}
// 抽象工厂
public interface GUIFactory {
Button createButton();
TextField createTextField();
}
// 具体工厂
public class LightThemeFactory implements GUIFactory {
@Override
public Button createButton() {
return new LightButton();
}
@Override
public TextField createTextField() {
return new LightTextField();
}
}
public class DarkThemeFactory implements GUIFactory {
@Override
public Button createButton() {
return new DarkButton();
}
@Override
public TextField createTextField() {
return new DarkTextField();
}
}
// 使用
public class Application {
private Button button;
private TextField textField;
public Application(GUIFactory factory) {
button = factory.createButton();
textField = factory.createTextField();
}
public void render() {
button.render();
textField.input();
}
}
三、三种工厂模式对比 📊
| 模式 | 适用场景 | 优点 | 缺点 |
|---|---|---|---|
| 简单工厂 | 创建逻辑简单,产品类型少 | 实现简单,客户端无需知道具体类 | 违反开闭原则 |
| 工厂方法 | 产品类型多,需要灵活扩展 | 符合开闭原则,扩展性强 | 类的数量增多 |
| 抽象工厂 | 创建相关产品家族 | 保证产品族的兼容性 | 难以支持新种类的产品 |
四、Spring中的工厂模式实践 🌱
在Spring框架中,工厂模式无处不在:
// 1. BeanFactory - 工厂方法的典型应用
BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext.xml");
Object bean = factory.getBean("beanName");
// 2. @Bean注解 - 配置类中的工厂方法
@Configuration
public class AppConfig {
@Bean
public DataSource dataSource() {
return new HikariDataSource();
}
}
// 3. FactoryBean接口 - 特殊对象的工厂
@Component
public class MyFactoryBean implements FactoryBean<MyObject> {
@Override
public MyObject getObject() throws Exception {
return new MyObject();
}
@Override
public Class<?> getObjectType() {
return MyObject.class;
}
}
五、如何选择工厂模式?🤷

六、总结 🎯
工厂模式的核心价值:
-
✨ 解耦:将对象创建与使用分离
-
✨ 扩展:易于增加新产品
-
✨ 封装:隐藏创建逻辑的复杂性
适用场景:
-
🎨 需要创建多种类型的对象
-
🔧 创建过程比较复杂
-
🌐 需要根据不同配置创建不同对象
记住: 不要为了用模式而用模式!如果你的对象创建逻辑很简单,直接new也是不错的选择。
下期预告:好了,工厂模式我们已经彻底掌握了!下一期,我们将深入探讨排名第三的策略模式,看看它如何优雅地处理算法的灵活切换。别忘了关注哦!👍
思考题:你在项目中用过工厂模式吗?是用来解决什么问题的?欢迎在评论区分享你的实战经验!💬
3183



被折叠的 条评论
为什么被折叠?



