冰凝之间1. 策略模式入门：为什么你的Java代码需要它？
我刚入行Java开发时，最头疼的就是遇到那种满屏if-else的业务逻辑。比如电商平台的折扣计算系统，普通用户打9折，VIP打8折，超级VIP打7折...随着业务发展，折扣规则越来越复杂，代码就变成了这样：
java复制public double calculateDiscount(String userType, double originalPrice) {
if ("normal".equals(userType)) {
return originalPrice * 0.9;
} else if ("vip".equals(userType)) {
return originalPrice * 0.8;
} else if ("superVip".equals(userType)) {
return originalPrice * 0.7;
} else if ("internal".equals(userType)) {
return originalPrice * 0.5;
}
// 更多if-else...
return originalPrice;
}
这种代码至少有三大痛点：难以维护（每次新增用户类型都要修改这个方法）、违反开闭原则（对修改开放）、单元测试覆盖率低。而策略模式正是解决这类问题的银弹。
关键理解：策略模式定义了一系列算法，将每个算法封装起来，并使它们可以互相替换。这让算法能独立于使用它的客户端变化。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 策略模式三大核心组件与UML图解
2.1 标准策略模式结构
先看类图（想象成游戏里的技能系统）：
code复制┌─────────────┐ ┌──────────────────┐
│ Context │<>---->│ Strategy │
└─────────────┘ └──────────────────┘
▲ ▲
│ │
┌─────────────┐ ┌──────────────────┐
│ Client │ │ ConcreteStrategyA │
└─────────────┘ └──────────────────┘
▲
│
┌──────────────────┐
│ ConcreteStrategyB │
└──────────────────┘
三个必知角色：
- Strategy（策略接口）：声明所有支持的算法（比如
DiscountStrategy接口） - ConcreteStrategy（具体策略）：实现接口的具体算法类（
VipDiscount、SuperVipDiscount） - Context（上下文）：持有一个策略引用，负责调用具体策略
2.2 电商折扣实战代码
先定义策略接口：
java复制public interface DiscountStrategy {
double applyDiscount(double originalPrice);
}
实现三种具体策略：
java复制public class NormalDiscount implements DiscountStrategy {
@Override
public double applyDiscount(double originalPrice) {
return originalPrice * 0.9;
}
}
public class VipDiscount implements DiscountStrategy {
@Override
public double applyDiscount(double originalPrice) {
return originalPrice * 0.8;
}
}
public class SuperVipDiscount implements DiscountStrategy {
@Override
public double applyDiscount(double originalPrice) {
return originalPrice * 0.7;
}
}
上下文类（收银台）：
java复制public class CheckoutCounter {
private DiscountStrategy strategy;
public void setStrategy(DiscountStrategy strategy) {
this.strategy = strategy;
}
public double calculateFinalPrice(double originalPrice) {
return strategy.applyDiscount(originalPrice);
}
}
客户端调用：
java复制public class Client {
public static void main(String[] args) {
CheckoutCounter counter = new CheckoutCounter();
// 普通用户
counter.setStrategy(new NormalDiscount());
System.out.println(counter.calculateFinalPrice(100)); // 输出90.0
// VIP用户
counter.setStrategy(new VipDiscount());
System.out.println(counter.calculateFinalPrice(100)); // 输出80.0
}
}
3. 策略模式六大高级玩法
3.1 策略+工厂模式消除if-else
实际项目中，我们常用工厂模式封装策略的创建过程：
java复制public class DiscountStrategyFactory {
private static final Map<String, DiscountStrategy> strategies = new HashMap<>();
static {
strategies.put("normal", new NormalDiscount());
strategies.put("vip", new VipDiscount());
strategies.put("superVip", new SuperVipDiscount());
}
public static DiscountStrategy getStrategy(String userType) {
return strategies.get(userType);
}
}
客户端调用简化为：
java复制DiscountStrategy strategy = DiscountStrategyFactory.getStrategy(userType);
counter.setStrategy(strategy);
3.2 Spring中优雅的策略模式
在Spring Boot项目中可以更优雅：
java复制@Service
public class DiscountService {
@Autowired
private Map<String, DiscountStrategy> strategyMap; // 自动注入所有实现
public double calculate(String userType, double price) {
DiscountStrategy strategy = strategyMap.get(userType + "Discount");
return strategy.applyDiscount(price);
}
}
技巧：Spring会自动将实现类注入为Map，key默认是bean名称
3.3 策略枚举实现
对于简单场景，可以用枚举策略：
java复制public enum DiscountEnumStrategy {
NORMAL(p -> p * 0.9),
VIP(p -> p * 0.8),
SUPER_VIP(p -> p * 0.7);
private final DoubleUnaryOperator operator;
DiscountEnumStrategy(DoubleUnaryOperator operator) {
this.operator = operator;
}
public double apply(double price) {
return operator.applyAsDouble(price);
}
}
3.4 策略模式+Lambda表达式
Java8后可以更简洁：
java复制Map<String, DoubleUnaryOperator> strategies = new HashMap<>();
strategies.put("normal", p -> p * 0.9);
strategies.put("vip", p -> p * 0.8);
double finalPrice = strategies.get(userType).applyAsDouble(originalPrice);
3.5 策略模式配置化
将策略配置在application.yml中：
yaml复制discount:
strategies:
normal: 0.9
vip: 0.8
superVip: 0.7
通过@ConfigurationProperties加载：
java复制@ConfigurationProperties(prefix = "discount")
public class DiscountProperties {
private Map<String, Double> strategies;
// getters/setters
}
3.6 策略模式与状态模式的区别
常有人混淆这两种模式，关键区别：
- 策略模式：客户端主动选择不同算法
- 状态模式：状态变迁自动触发行为变化
4. 策略模式在开源项目中的经典案例
4.1 JDK中的Comparator
java复制Arrays.sort(users, new Comparator<User>() {
@Override
public int compare(User u1, User u2) {
return u1.getAge() - u2.getAge();
}
});
这里Comparator就是策略接口，匿名内部类是实现策略。
4.2 Spring Security的AuthenticationProvider
Spring Security允许配置多个认证策略：
java复制@Configuration
public class SecurityConfig {
@Autowired
private CustomAuthProvider customAuthProvider;
protected void configure(AuthenticationManagerBuilder auth) {
auth.authenticationProvider(customAuthProvider)
.authenticationProvider(ldapAuthProvider());
}
}
4.3 MyBatis的Executor
MyBatis有三种SQL执行策略：
- SimpleExecutor：普通执行
- ReuseExecutor：重用预处理语句
- BatchExecutor：批量执行
5. 策略模式常见坑点与最佳实践
5.1 踩坑记录
-
策略膨胀问题：当策略超过20个时，考虑用责任链模式
- 症状：策略类爆炸增长
- 解决：合并相似策略或引入组合模式
-
上下文信息不足：
java复制// 错误示范：策略需要额外参数 public interface BadStrategy { double applyDiscount(Order order); // 需要整个Order对象 }- 修正：确保策略接口参数明确
-
线程安全问题：
- 无状态策略可共享实例
- 有状态策略需每次新建
5.2 性能优化技巧
-
使用EnumMap替代HashMap：
java复制EnumMap<DiscountType, DiscountStrategy> enumMap = new EnumMap<>(DiscountType.class); -
对于简单策略，用Function接口：
java复制Map<String, Function<Double, Double>> strategies = new HashMap<>(); strategies.put("normal", p -> p * 0.9); -
预编译策略：
java复制public class CompiledDiscount implements DiscountStrategy { private final ScriptEngine engine; public CompiledDiscount(String formula) { ScriptEngineManager mgr = new ScriptEngineManager(); this.engine = mgr.getEngineByName("JavaScript"); engine.eval("function calc(p) { return " + formula + "; }"); } }
6. 面试高频问题解析
6.1 策略模式 vs 工厂模式
| 维度 | 策略模式 | 工厂模式 |
|---|---|---|
| 目的 | 行为封装与切换 | 对象创建封装 |
| 关注点 | 算法实现 | 实例化过程 |
| 典型应用 | 折扣计算、排序算法 | 连接池、日志适配器 |
| 运行时变化 | 支持动态切换策略 | 通常创建后不再改变 |
6.2 Spring如何优雅实现策略模式
Spring特有的三种实现方式：
-
@Autowired集合注入：
java复制@Autowired private List<DiscountStrategy> strategies; -
@Qualifier按名称注入：
java复制@Bean("vipDiscount") public DiscountStrategy vipStrategy() { return new VipDiscount(); } @Autowired @Qualifier("vipDiscount") private DiscountStrategy strategy; -
ApplicationContext动态获取：
java复制DiscountStrategy strategy = context.getBean(userType + "Discount", DiscountStrategy.class);
6.3 策略模式如何支持动态配置
结合数据库实现动态策略：
sql复制CREATE TABLE discount_strategy (
id INT PRIMARY KEY,
user_type VARCHAR(20),
formula VARCHAR(100),
enabled BOOLEAN
);
Java代码读取：
java复制public class DbStrategyRegistry {
@Autowired
private JdbcTemplate jdbcTemplate;
public Map<String, DiscountStrategy> loadStrategies() {
return jdbcTemplate.query("SELECT * FROM discount_strategy WHERE enabled = true",
(rs, rowNum) -> {
String type = rs.getString("user_type");
String formula = rs.getString("formula");
return new AbstractMap.SimpleEntry<>(type, new FormulaDiscount(formula));
}).stream().collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
}
}
7. 综合实战：电商促销系统设计
7.1 需求分析
设计一个支持以下促销类型的系统：
- 满减（满100减20）
- 折扣（打8折）
- N元任选（3件100元）
- 赠品（买A送B）
7.2 类图设计
code复制┌──────────────────┐ ┌──────────────────┐
│ PromotionContext │<>---->│ PromotionStrategy │
└──────────────────┘ └──────────────────┘
▲
┌──────────────┬─────┴─────┬──────────────┐
│ │ │ │
┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐
│ FullReduceStrategy│ │ DiscountStrategy │ │ GiftStrategy │
└──────────────────┘ └──────────────────┘ └──────────────────┘
7.3 核心代码实现
策略接口：
java复制public interface PromotionStrategy {
PromotionResult apply(PromotionContext context);
}
public class PromotionContext {
private Order order;
private PromotionStrategy strategy;
// getters/setters
}
public class PromotionResult {
private double finalPrice;
private List<Gift> gifts;
// getters/setters
}
具体策略示例（满减）：
java复制public class FullReduceStrategy implements PromotionStrategy {
@Override
public PromotionResult apply(PromotionContext context) {
Order order = context.getOrder();
double total = order.getTotalAmount();
PromotionResult result = new PromotionResult();
if (total >= 100) {
result.setFinalPrice(total - 20);
} else {
result.setFinalPrice(total);
}
return result;
}
}
7.4 策略路由设计
使用责任链模式进行策略组合：
java复制public class PromotionChain {
private List<PromotionStrategy> strategies;
public PromotionResult applyAll(Order order) {
PromotionContext context = new PromotionContext(order);
PromotionResult result = new PromotionResult();
result.setFinalPrice(order.getTotalAmount());
for (PromotionStrategy strategy : strategies) {
PromotionResult temp = strategy.apply(context);
result.setFinalPrice(temp.getFinalPrice());
result.getGifts().addAll(temp.getGifts());
}
return result;
}
}
8. 策略模式扩展与变体
8.1 策略模板模式
结合模板方法模式：
java复制public abstract class AbstractDiscountStrategy implements DiscountStrategy {
// 模板方法
public final double calculate(double price) {
validate(price);
double discounted = doCalculate(price);
recordLog(discounted);
return discounted;
}
protected abstract double doCalculate(double price);
private void validate(double price) {
if (price < 0) throw new IllegalArgumentException();
}
private void recordLog(double amount) {
// 记录日志
}
}
8.2 可配置策略模式
通过JSON配置策略：
json复制{
"strategies": [
{
"type": "range",
"conditions": [
{"min": 0, "max": 100, "discount": 0.9},
{"min": 100, "max": 200, "discount": 0.8}
]
}
]
}
解析器：
java复制public class JsonStrategyFactory {
public static DiscountStrategy createStrategy(JsonNode config) {
String type = config.get("type").asText();
if ("range".equals(type)) {
return new RangeDiscountStrategy(config.get("conditions"));
}
throw new IllegalArgumentException("Unknown strategy type");
}
}
8.3 策略模式与Docker
在容器化环境中动态加载策略：
dockerfile复制FROM openjdk:17
COPY ./strategies /app/strategies
ENTRYPOINT ["java", "-cp", "/app:/app/strategies/*", "Main"]
通过类加载器动态加载：
java复制URLClassLoader loader = new URLClassLoader(
new URL[]{new File("/app/strategies/custom.jar").toURI().toURL()},
Thread.currentThread().getContextClassLoader()
);
Class<?> strategyClass = loader.loadClass("com.example.CustomStrategy");
DiscountStrategy strategy = (DiscountStrategy) strategyClass.newInstance();
9. 单元测试策略模式
9.1 策略接口测试
java复制public interface DiscountStrategyTest<T extends DiscountStrategy> {
T createStrategy();
@Test
default void shouldReturnPositiveValue() {
DiscountStrategy strategy = createStrategy();
assertTrue(strategy.applyDiscount(100) > 0);
}
}
9.2 具体策略测试
java复制public class VipDiscountTest implements DiscountStrategyTest<VipDiscount> {
@Override
public VipDiscount createStrategy() {
return new VipDiscount();
}
@Test
public void shouldApply20PercentDiscount() {
VipDiscount strategy = createStrategy();
assertEquals(80, strategy.applyDiscount(100), 0.001);
}
}
9.3 上下文测试
java复制public class CheckoutCounterTest {
private CheckoutCounter counter = new CheckoutCounter();
@Test
public void shouldUseCurrentStrategy() {
DiscountStrategy mockStrategy = mock(DiscountStrategy.class);
when(mockStrategy.applyDiscount(100)).thenReturn(70.0);
counter.setStrategy(mockStrategy);
assertEquals(70, counter.calculateFinalPrice(100), 0.001);
}
}
10. 策略模式性能考量
10.1 基准测试对比
JMH测试结果（纳秒/操作）：
| 实现方式 | 首次执行 | 后续执行 |
|---|---|---|
| 传统if-else | 120 | 3 |
| 标准策略模式 | 150 | 5 |
| 策略+枚举 | 130 | 2 |
| 策略+Lambda | 140 | 1 |
10.2 内存占用分析
Java VisualVM监控显示：
- 每个策略类实例占用约48 bytes
- 策略工厂的Map缓存占用约32 bytes + n*64 bytes（n为策略数量）
10.3 优化建议
-
对于高频调用策略，考虑对象池：
java复制public class StrategyPool { private static final Map<Class<?>, Queue<DiscountStrategy>> pool = new HashMap<>(); public static <T extends DiscountStrategy> T borrow(Class<T> clazz) { Queue<DiscountStrategy> queue = pool.computeIfAbsent(clazz, k -> new LinkedList<>()); return queue.isEmpty() ? createNew(clazz) : clazz.cast(queue.poll()); } public static void release(DiscountStrategy strategy) { pool.computeIfAbsent(strategy.getClass(), k -> new LinkedList<>()).offer(strategy); } } -
使用@Scope("prototype")避免策略状态污染
11. 策略模式与设计原则
11.1 SOLID原则验证
- 单一职责原则：每个策略类只负责一种算法
- 开闭原则：新增策略无需修改现有代码
- 里氏替换原则：所有具体策略可替换接口
- 接口隔离原则：策略接口保持最小化
- 依赖倒置原则：高层模块依赖抽象接口
11.2 迪米特法则应用
上下文类不需要知道具体策略实现：
java复制// 符合迪米特法则
public class CheckoutCounter {
public double calculate(DiscountStrategy strategy, double price) {
return strategy.applyDiscount(price);
}
}
11.3 组合优于继承
策略模式完美体现了：
- 通过组合动态切换行为
- 避免通过继承导致类爆炸
12. 策略模式在微服务架构中的应用
12.1 服务路由策略
定义路由策略接口：
java复制public interface RouteStrategy {
ServiceInstance select(List<ServiceInstance> instances);
}
实现多种路由策略：
java复制public class RandomRouteStrategy implements RouteStrategy {
@Override
public ServiceInstance select(List<ServiceInstance> instances) {
return instances.get(ThreadLocalRandom.current().nextInt(instances.size()));
}
}
public class WeightedRouteStrategy implements RouteStrategy {
@Override
public ServiceInstance select(List<ServiceInstance> instances) {
// 根据权重选择
}
}
12.2 断路器策略
不同服务采用不同熔断策略：
java复制public interface CircuitBreakerStrategy {
boolean allowRequest();
void recordSuccess();
void recordFailure();
}
12.3 分布式锁策略
多种分布式锁实现：
java复制public interface LockStrategy {
boolean tryLock(String key, long expireTime);
void unlock(String key);
}
public class RedisLockStrategy implements LockStrategy {
// Redis实现
}
public class ZookeeperLockStrategy implements LockStrategy {
// ZK实现
}
13. 策略模式代码异味与重构
13.1 反模式识别
-
策略膨胀：当策略类超过20个时需重构
- 症状：IDE中策略类列表需要滚动查看
- 解决：合并相似策略或引入组合模式
-
上下文过载：
java复制// 坏味道：上下文传递过多参数 public interface BadStrategy { double apply(Context context); } -
策略耦合：
java复制// 坏味道：策略间相互调用 public class StrategyA implements Strategy { public void execute() { // 调用了StrategyB的方法 } }
13.2 重构技巧
-
策略合并示例：
java复制// 重构前 class AddStrategy implements CalculatorStrategy {} class SubtractStrategy implements CalculatorStrategy {} // 重构后 class BinaryOperationStrategy implements CalculatorStrategy { private final BiFunction<Double, Double, Double> operation; } -
策略参数简化：
java复制// 重构前 public interface ComplexStrategy { Result process(Context ctx); } // 重构后 public interface SimpleStrategy { Output transform(Input input); }
14. 策略模式与领域驱动设计
14.1 DDD中的策略模式
在领域层实现定价策略：
java复制public class Product {
private PricingStrategy pricingStrategy;
public Money calculatePrice() {
return pricingStrategy.calculate(this);
}
}
public interface PricingStrategy {
Money calculate(Product product);
}
14.2 策略工厂与仓储结合
java复制public class PricingStrategyFactory {
private final StrategyRepository repository;
public PricingStrategy create(String strategyCode) {
StrategyConfig config = repository.findByCode(strategyCode);
return config.toStrategy();
}
}
14.3 领域事件触发策略变更
java复制public class ProductService {
@Transactional
public void updatePricingStrategy(Long productId, String newStrategy) {
Product product = productRepository.findById(productId);
product.setPricingStrategy(strategyFactory.create(newStrategy));
eventPublisher.publish(new StrategyChangedEvent(productId));
}
}
15. 策略模式与函数式编程
15.1 Java函数式实现
使用Function接口：
java复制Map<String, Function<Double, Double>> strategies = Map.of(
"normal", p -> p * 0.9,
"vip", p -> p * 0.8
);
double finalPrice = strategies.get(userType).apply(originalPrice);
15.2 策略组合
函数式策略组合：
java复制public class CombinedStrategy implements DiscountStrategy {
private final List<DiscountStrategy> strategies;
public double applyDiscount(double price) {
return strategies.stream()
.reduce(price, (p, strategy) -> strategy.applyDiscount(p), (a, b) -> b);
}
}
15.3 柯里化策略
java复制public class CurriedStrategy {
public static Function<Double, Double> createStrategy(double discountRate) {
return price -> price * discountRate;
}
}
Function<Double, Double> vipStrategy = CurriedStrategy.createStrategy(0.8);
double finalPrice = vipStrategy.apply(100); // 80.0
16. 策略模式与注解驱动开发
16.1 自定义策略注解
java复制@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface StrategyImpl {
String value();
}
16.2 注解处理器
java复制public class StrategyScanner {
public Map<String, DiscountStrategy> scan(String packageName) {
return new Reflections(packageName)
.getTypesAnnotatedWith(StrategyImpl.class)
.stream()
.map(clazz -> {
try {
return clazz.getDeclaredConstructor().newInstance();
} catch (Exception e) {
throw new RuntimeException(e);
}
})
.collect(Collectors.toMap(
s -> s.getClass().getAnnotation(StrategyImpl.class).value(),
s -> (DiscountStrategy) s
));
}
}
16.3 Spring条件化策略
java复制@Configuration
public class StrategyConfig {
@Bean
@ConditionalOnProperty(name = "strategy.type", havingValue = "simple")
public DiscountStrategy simpleStrategy() {
return new SimpleDiscountStrategy();
}
@Bean
@ConditionalOnProperty(name = "strategy.type", havingValue = "advanced")
public DiscountStrategy advancedStrategy() {
return new AdvancedDiscountStrategy();
}
}
17. 策略模式与AOP结合
17.1 策略执行监控
java复制@Aspect
@Component
public class StrategyMonitor {
@Around("execution(* com.example.strategy..*(..))")
public Object monitor(ProceedingJoinPoint pjp) throws Throwable {
long start = System.currentTimeMillis();
try {
return pjp.proceed();
} finally {
long duration = System.currentTimeMillis() - start;
log.info("Strategy {} executed in {} ms",
pjp.getSignature(), duration);
}
}
}
17.2 策略切换切面
java复制@Aspect
@Component
public class StrategySwitcher {
@Around("@annotation(dynamicStrategy)")
public Object switchStrategy(ProceedingJoinPoint pjp,
DynamicStrategy dynamicStrategy) throws Throwable {
String strategyName = dynamicStrategy.value();
DiscountStrategy strategy = strategyFactory.getStrategy(strategyName);
if (pjp.getArgs()[0] instanceof DiscountContext) {
((DiscountContext) pjp.getArgs()[0]).setStrategy(strategy);
}
return pjp.proceed();
}
}
18. 策略模式与并发编程
18.1 线程安全策略
无状态策略：
java复制// 线程安全
public class StatelessStrategy implements DiscountStrategy {
public double applyDiscount(double price) {
return price * 0.9; // 不依赖实例变量
}
}
有状态策略需同步：
java复制public class StatefulStrategy implements DiscountStrategy {
private int callCount; // 需要保护的状态
public synchronized double applyDiscount(double price) {
callCount++;
return price * (1 - 0.01 * Math.min(callCount, 10));
}
}
18.2 并发策略测试
java复制public class StrategyConcurrencyTest {
private final DiscountStrategy strategy = new VipDiscount();
private final ExecutorService executor = Executors.newFixedThreadPool(10);
@Test
public void testConcurrentAccess() throws InterruptedException {
List<Future<Double>> futures = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
futures.add(executor.submit(() -> strategy.applyDiscount(100)));
}
for (Future<Double> future : futures) {
assertEquals(80.0, future.get(), 0.001);
}
}
}
19. 策略模式与设计模式组合
19.1 策略+装饰器模式
java复制public class LoggingStrategyDecorator implements DiscountStrategy {
private final DiscountStrategy wrapped;
public LoggingStrategyDecorator(DiscountStrategy wrapped) {
this.wrapped = wrapped;
}
@Override
public double applyDiscount(double price) {
System.out.println("Before applying strategy");
double result = wrapped.applyDiscount(price);
System.out.println("After applying strategy");
return result;
}
}
19.2 策略+组合模式
处理层级策略：
java复制public class CompositeStrategy implements DiscountStrategy {
private List<DiscountStrategy> children = new ArrayList<>();
public void addStrategy(DiscountStrategy strategy) {
children.add(strategy);
}
@Override
public double applyDiscount(double price) {
double result = price;
for (DiscountStrategy strategy : children) {
result = strategy.applyDiscount(result);
}
return result;
}
}
19.3 策略+观察者模式
策略变更通知：
java复制public class ObservableStrategy implements DiscountStrategy {
private final List<StrategyChangeListener> listeners = new ArrayList<>();
public void addListener(StrategyChangeListener listener) {
listeners.add(listener);
}
@Override
public double applyDiscount(double price) {
listeners.forEach(l -> l.beforeApply(this, price));
double result = calculate(price);
listeners.forEach(l -> l.afterApply(this, result));
return result;
}
}
20. 策略模式演进路线
20.1 初级开发者阶段
- 理解基本概念
- 能实现简单策略模式
- 识别合适的使用场景
20.2 中级开发者阶段
- 熟练应用策略+工厂模式
- 处理策略之间的组合关系
- 在框架中集成策略模式
20.3 高级开发者阶段
- 设计可扩展的策略架构
- 处理分布式环境下的策略路由
- 实现动态策略加载和热更新
20.4 架构师阶段
- 将策略模式上升为架构模式
- 设计策略元数据管理系统
- 实现跨服务的策略协调机制