摘要

抽象工厂设计模式是一种创建型设计模式，旨在提供一个接口，用于创建一系列相关或依赖的对象，无需指定具体类。它通过抽象工厂、具体工厂、抽象产品和具体产品等组件构建，相比工厂方法模式，能创建一个产品族。该模式适用于多个产品需一起创建的场景，可隐藏产品细节，便于客户端使用。

1. 抽象工厂设计模式定义

抽象工厂模式是创建型设计模式的一种，它提供一个接口，用于创建一系列相关或相互依赖的对象，而无需指定它们的具体类。就像一个“超级工厂”，里面包含多个子工厂，用于生产同一产品族中的各种产品。你不关心产品的具体实现，只关心工厂能提供什么样的系列产品。

核心要点：

维度	描述
意图	为创建相关对象的家族提供一个统一的接口
解决问题	解决“多个产品之间需要一起创建”的问题
与工厂方法对比	工厂方法是一个产品一个工厂；抽象工厂是一个产品族一个工厂
隐藏细节	客户端不需要知道具体产品类，只通过抽象接口使用

2. 抽象工厂设计模式结构

2.1. 抽象工厂设计模式类图

• AbstractFactory：抽象工厂
• ConcreteFactory：具体工厂
• AbstractProduct：抽象产品
• Product：具体产品

2.2. 抽象工厂设计模式时序图

3. 抽象工厂设计模式实现方式

抽象工厂模式的实现，主要通过一组产品接口 + 一个抽象工厂接口 + 多个具体工厂实现类来构建。下面是完整的标准实现方式。

3.1. 🧱 实现步骤（Java 示例）

3.1.1. 定义抽象产品接口

// 抽象产品 A
public interface Button {void click();
}// 抽象产品 B
public interface TextField {void input(String text);
}

3.1.2. 定义具体产品类

// Windows 系列产品
public class WindowsButton implements Button {public void click() {System.out.println("Windows 按钮点击");}
}public class WindowsTextField implements TextField {public void input(String text) {System.out.println("Windows 输入: " + text);}
}// Mac 系列产品
public class MacButton implements Button {public void click() {System.out.println("Mac 按钮点击");}
}public class MacTextField implements TextField {public void input(String text) {System.out.println("Mac 输入: " + text);}
}

3.1.3. 定义抽象工厂接口

public interface GUIFactory {Button createButton();TextField createTextField();
}

3.1.4. 实现具体工厂类

public class WindowsFactory implements GUIFactory {public Button createButton() {return new WindowsButton();}public TextField createTextField() {return new WindowsTextField();}
}public class MacFactory implements GUIFactory {public Button createButton() {return new MacButton();}public TextField createTextField() {return new MacTextField();}
}

3.1.5. 客户端使用示例

public class Application {public static void main(String[] args) {// 可通过配置文件或环境变量来控制GUIFactory factory = new WindowsFactory();// GUIFactory factory = new MacFactory();Button button = factory.createButton();TextField textField = factory.createTextField();button.click();textField.input("Hello World!");}
}

3.2. ✅ 抽象工厂模式特点

特点	描述
解耦	客户端不需要了解产品的具体类
易于扩展	可以轻松新增新的产品族，只需添加一个新的工厂类
成本	新增产品种类时，需要修改所有工厂类（违背开闭原则）
应用场景	多产品族、产品组合固定、创建逻辑复杂的场景

4. 抽象工厂设计模式适合场景

抽象工厂是一种创建型设计模式，适用于需要一组相关或互相依赖的对象的场景。

4.1. ✅ 适合使用抽象工厂模式的场景

场景	说明
产品族固定，且产品之间有依赖关系	比如 GUI 界面中，按钮、文本框等控件需风格统一（如 Windows、Mac）。
系统需要独立于产品创建逻辑	客户端无需关心产品如何创建，只关注使用接口。
需要保证产品之间的一致性（风格/协议/行为）	比如同一品牌的组件应配套使用，避免混搭出错。
系统有多个产品族，但每次只使用其中一个	比如数据库连接池的不同厂商实现（Druid、HikariCP）。
适合用于“横向扩展”产品族，而不是“纵向扩展”产品种类	可以增加新的平台或风格，但不易增加产品接口。

4.2. ❌ 不适合使用抽象工厂模式的场景

场景	原因
❌ 只需要创建一种对象，不是一个产品族	比如只创建不同类型的日志对象，用简单工厂或策略更合适。
❌ 频繁增加新的产品（产品等级结构）	每新增一个产品类型（接口），所有具体工厂都要修改，违背“开闭原则”。
❌ 产品之间无依赖、不要求一致性	没有必要引入抽象工厂，使用简单工厂或直接实例化即可。
❌ 产品构造非常简单，扩展性需求低	抽象工厂的结构较复杂，维护成本较高，可能得不偿失。
❌ 仅用于单一系统或开发周期很短的小项目	引入抽象工厂会增加架构复杂度。

4.3. 📌 抽象工厂设计模式总结

项目	抽象工厂适用	不适用
是否一组产品族	✅ 是	❌ 否
是否要求统一风格	✅ 是	❌ 否
是否频繁新增产品接口	❌ 否	✅ 是
是否希望屏蔽实例化逻辑	✅ 是	❌ 否

5. 抽象工厂设计模式实战示例

在金融风控系统中，不同的业务线（如消费贷、车贷、现金贷等）往往使用不同的风控规则引擎或评分模型。抽象工厂模式在这里可以用于隔离不同业务线的策略实现，提升系统的可扩展性和解耦能力。

5.1. ✅ 多业务线风控规则工厂示例：

系统支持多个业务线，每个业务线都有自己的一套风控规则引擎（如用户画像评分、反欺诈规则、额度评估等），需要统一接口、按业务线隔离实现。

5.2. 🧱 抽象设计结构

• 抽象产品：RiskRuleEngine（风控规则引擎）
• 抽象工厂：RiskRuleFactory（风控规则工厂）
• 具体工厂：ConsumerLoanFactory、CarLoanFactory 等
• 客户端：风控服务，根据业务类型获取对应工厂并执行规则引擎

5.3. 🧩 代码结构

5.3.1. 抽象产品接口

public interface RiskRuleEngine {void evaluate(String userId);
}

5.3.2. 抽象工厂接口

public interface RiskRuleFactory {RiskRuleEngine createUserProfileEngine();RiskRuleEngine createFraudEngine();RiskRuleEngine createCreditLimitEngine();
}

5.3.3. 具体产品实现（以消费贷为例）

@Component
public class ConsumerUserProfileEngine implements RiskRuleEngine {public void evaluate(String userId) {System.out.println("消费贷 - 用户画像评估：" + userId);}
}@Component
public class ConsumerFraudEngine implements RiskRuleEngine {public void evaluate(String userId) {System.out.println("消费贷 - 反欺诈规则评估：" + userId);}
}@Component
public class ConsumerCreditLimitEngine implements RiskRuleEngine {public void evaluate(String userId) {System.out.println("消费贷 - 授信额度评估：" + userId);}
}

5.3.4. 消费贷工厂实现

@Component("consumerLoanFactory")
public class ConsumerLoanFactory implements RiskRuleFactory {@Autowired private ConsumerUserProfileEngine userProfileEngine;@Autowired private ConsumerFraudEngine fraudEngine;@Autowired private ConsumerCreditLimitEngine creditLimitEngine;public RiskRuleEngine createUserProfileEngine() {return userProfileEngine;}public RiskRuleEngine createFraudEngine() {return fraudEngine;}public RiskRuleEngine createCreditLimitEngine() {return creditLimitEngine;}
}

5.3.5. 客户端服务按业务线执行风控评估

@Service
public class RiskControlService {@Autowired@Qualifier("consumerLoanFactory") // 或通过配置中心动态选择工厂private RiskRuleFactory riskRuleFactory;public void doRiskEvaluate(String userId) {riskRuleFactory.createUserProfileEngine().evaluate(userId);riskRuleFactory.createFraudEngine().evaluate(userId);riskRuleFactory.createCreditLimitEngine().evaluate(userId);}
}

5.4. ✅ 如果要支持动态业务线切换（如配置中心配置当前业务）

你可以将所有工厂注册进一个 Map：

@Component
public class RiskRuleFactoryRegistry {private final Map<String, RiskRuleFactory> factoryMap = new HashMap<>();@Autowiredpublic RiskRuleFactoryRegistry(List<RiskRuleFactory> factories) {for (RiskRuleFactory factory : factories) {factoryMap.put(factory.getClass().getSimpleName().replace("Factory", "").toLowerCase(), factory);}}public RiskRuleFactory getFactory(String bizType) {return factoryMap.get(bizType.toLowerCase());}
}

5.5. ✅ 使用配置中心动态切换工厂

@Service
public class DynamicRiskControlService {@Value("${biz.line.type:consumerLoan}")private String bizType;@Autowiredprivate RiskRuleFactoryRegistry registry;public void doEvaluate(String userId) {RiskRuleFactory factory = registry.getFactory(bizType);factory.createUserProfileEngine().evaluate(userId);factory.createFraudEngine().evaluate(userId);factory.createCreditLimitEngine().evaluate(userId);}
}

5.6. ✅ 抽象工厂涉及面模式总结

优势	描述
模块隔离	不同业务线的规则逻辑完全隔离，避免混乱
易于扩展	新业务线只需实现一套工厂和引擎，不影响老业务
支持插件化	工厂可结合 SPI 动态加载
配置驱动	支持配置中心动态切换业务逻辑

6. 抽象工厂设计模式思考

6.1. 引入SPI 加载抽象工厂、或者结合 Spring Boot Starter 自动注册不同业务线的风控策略示例

6.1.1. 需求回顾

• 多业务线（消费贷、车贷等）各自实现一套 RiskRuleFactory。
• 通过 SPI 机制实现工厂插件化，支持 jar 扩展、热插拔。
• Spring Boot 启动时自动扫描 SPI 实现，注册到工厂注册中心。
• 支持根据配置动态切换当前业务线风控工厂。

6.1.2. 项目结构示例

risk-control-spi/├─ META-INF/services/com.example.risk.spi.RiskRuleFactory├─ com/example/risk/spi/│    ├─ RiskRuleFactory.java       // SPI接口│    ├─ ConsumerLoanFactory.java   // 业务线1实现│    ├─ CarLoanFactory.java        // 业务线2实现├─ com/example/risk/spring/│    ├─ RiskRuleFactoryRegistry.java│    ├─ RiskControlAutoConfiguration.java│    ├─ DynamicRiskControlService.java

6.1.3. 示例代码

SPI接口定义（RiskRuleFactory）

package com.example.risk.spi;public interface RiskRuleFactory {// 返回业务线标识，如 "consumerLoan"String getBizType(); void evaluateUserProfile(String userId);void evaluateFraud(String userId);void evaluateCreditLimit(String userId);
}

SPI实现（以消费贷为例）

package com.example.risk.spi;public class ConsumerLoanFactory implements RiskRuleFactory {@Overridepublic String getBizType() {return "consumerLoan";}@Overridepublic void evaluateUserProfile(String userId) {System.out.println("消费贷用户画像评估: " + userId);}@Overridepublic void evaluateFraud(String userId) {System.out.println("消费贷反欺诈评估: " + userId);}@Overridepublic void evaluateCreditLimit(String userId) {System.out.println("消费贷授信额度评估: " + userId);}
}

同理实现 CarLoanFactory 等其他业务线工厂。

SPI配置文件：文件路径：src/main/resources/META-INF/services/com.example.risk.spi.RiskRuleFactory内容（每行一个实现类全限定名）：

com.example.risk.spi.ConsumerLoanFactory
com.example.risk.spi.CarLoanFactory

工厂注册中心（Spring Bean）

package com.example.risk.spring;import com.example.risk.spi.RiskRuleFactory;
import org.springframework.stereotype.Component;import javax.annotation.PostConstruct;
import java.util.*;@Component
public class RiskRuleFactoryRegistry {private final Map<String, RiskRuleFactory> factoryMap = new HashMap<>();@PostConstructpublic void init() {ServiceLoader<RiskRuleFactory> loader = ServiceLoader.load(RiskRuleFactory.class);for (RiskRuleFactory factory : loader) {factoryMap.put(factory.getBizType(), factory);System.out.println("加载风控工厂：" + factory.getBizType());}}public RiskRuleFactory getFactory(String bizType) {RiskRuleFactory factory = factoryMap.get(bizType);if (factory == null) {throw new IllegalArgumentException("不支持的业务线: " + bizType);}return factory;}
}

Spring Boot 自动配置类

package com.example.risk.spring;import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;@Configuration
@ConditionalOnProperty(prefix = "risk.control", name = "enabled", havingValue = "true", matchIfMissing = true)
public class RiskControlAutoConfiguration {@Beanpublic RiskRuleFactoryRegistry riskRuleFactoryRegistry() {return new RiskRuleFactoryRegistry();}@Beanpublic DynamicRiskControlService dynamicRiskControlService() {return new DynamicRiskControlService();}
}

动态风控服务

package com.example.risk.spring;import com.example.risk.spi.RiskRuleFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;@Service
public class DynamicRiskControlService {@Value("${risk.control.bizType:consumerLoan}")private String bizType;@Autowiredprivate RiskRuleFactoryRegistry registry;public void doEvaluate(String userId) {RiskRuleFactory factory = registry.getFactory(bizType);factory.evaluateUserProfile(userId);factory.evaluateFraud(userId);factory.evaluateCreditLimit(userId);}
}

6.1.4. SPI+抽象工厂设计模式总结

1. 扩展业务线：只需实现 RiskRuleFactory 接口，并在 SPI 文件里声明实现类，打包成 jar 加入项目。
2. 动态切换业务线：修改配置 risk.control.bizType=carLoan 即可切换到车贷业务线风控。
3. 热插拔：新的业务线可以单独打包成 jar 通过 SPI 机制自动被加载。

优点	说明
插件式扩展	新增业务线无需改动核心代码，符合开闭原则
Spring 集成	自动装配，减少手动配置
配置驱动	通过配置灵活切换业务逻辑
动态加载	SPI 支持运行时加载多个实现

博文参考

• 3. 抽象工厂模式(Abstract Factory) — Graphic Design Patterns
• 抽象工厂设计模式
• 创建型 - 抽象工厂(Abstract Factory) | Java 全栈知识体系