01.3.2.8 策略模式
所属:全栈开发面试题库 / 01 计算机基础与通用工程 / 01.3 设计模式与架构基础 / 01.3.2 常用设计模式多语言详解
覆盖范围
- 策略模式消除 if/else 的正确姿势与适用前提
- 策略注册表(Map + key)分发与默认策略
- 函数式策略:Go
func、TypeScript 函数类型、Python 一等函数 - Rust 的
fn指针、闭包与Box<dyn Trait>、enum 分派取舍 - Spring 中
Map<String, Strategy>注入与 Bean 命名分发 - TypeScript 可辨识联合 +
never穷尽检查何时比策略更合适 - 策略与状态模式、策略与模板方法的关键区别
- 运行时选择 vs 编译时固定的判断标准
- 策略对象的无状态、可复用性与线程安全
- 策略配置化(数据库 / 配置中心驱动)与过度设计判断
面试题索引
| 编号 | 题目 | 难度 | 状态 | 备注 |
|---|---|---|---|---|
| 01.3.2.8-001 | 策略模式消除 if/else 的正确姿势与前提是什么? | 基础 | 已完成 | 何时该拆 |
| 01.3.2.8-002 | 策略注册表 + key 分发怎么写?默认策略怎么兜底? | 基础 | 已完成 | Map 注册 |
| 01.3.2.8-003 | Go 里怎么用函数类型做策略? | 进阶 | 已完成 | func 一等公民 |
| 01.3.2.8-004 | TypeScript 与 Python 的函数式策略怎么写? | 进阶 | 已完成 | 一等函数 |
| 01.3.2.8-005 | Rust 的 fn 指针、闭包和 trait 对象怎么选? |
高级 | 已完成 | 对象安全 |
| 01.3.2.8-006 | Rust 用 enum 分派 vs Box<dyn Trait> 的性能与取舍? |
高级 | 已完成 | 静态分派 |
| 01.3.2.8-007 | Spring 怎么用 Map<String, Strategy> 自动收集策略? |
进阶 | 已完成 | 容器注入 |
| 01.3.2.8-008 | TypeScript 可辨识联合 + 穷尽检查何时比策略模式更合适? | 高级 | 已完成 | 类型级分派 |
| 01.3.2.8-009 | 策略模式和状态模式的关键区别是什么? | 进阶 | 已完成 | 结构相似意图不同 |
| 01.3.2.8-010 | 策略模式和模板方法怎么选型? | 进阶 | 已完成 | 组合 vs 继承 |
| 01.3.2.8-011 | 运行时选择策略 vs 编译时固定实现的判断标准? | 进阶 | 已完成 | 变化点 |
| 01.3.2.8-012 | 策略对象为什么要无状态?多线程下怎么保证安全? | 进阶 | 已完成 | 可复用性 |
| 01.3.2.8-013 | 策略配置化怎么落地?什么时候是过度设计? | 高级 | 已完成 | 配置驱动 |
01.3.2.8-001 策略模式消除 if/else 的正确姿势与前提是什么?
一句话结论
策略模式消除的是「同一族、可互换、会随业务增长的算法分支」,不是所有 if/else;它的前提是分支背后有稳定的共同接口(相同入参出参),且分支数量会继续增加,否则硬拆成策略类反而比直接 if/else 更难读。
概念解释
- 三个角色:策略接口(定义统一
execute)、具体策略(每个分支一个实现)、上下文(持有并选择策略)。 - 真正被消除的不是「条件」本身,而是条件判断从业务主干代码里移出,集中到注册表或工厂。
- 适用前提:分支是「同一类算法的不同实现」(折扣、排序、支付渠道、消息发送通道),而不是「与业务无关的零散校验」。
原理流程
- 观察 if/else 中的分支是否共享同一签名。
- 抽出接口,每个分支变成一个实现类或函数。
- 上下文按 key 从注册表取策略并调用,主干不再出现分支。
- 新增分支 = 新增一个实现 + 注册,主干代码零改动。
代码或图示
// 反例:业务主干里堆满分支
public BigDecimal discount(String type, BigDecimal price) {
if ("NORMAL".equals(type)) return price;
if ("GOLD".equals(type)) return price.multiply(new BigDecimal("0.9"));
if ("VIP".equals(type)) return price.multiply(new BigDecimal("0.8"));
throw new IllegalArgumentException(type);
}
// 正例:策略接口 + 注册表分发
public interface DiscountStrategy {
String type();
BigDecimal discount(BigDecimal price);
}
常见误区
- 把所有 if/else 都翻译成策略:一两个分支、逻辑只有两三行、半年不变的,留在主干里可读性更好。
- 策略接口承担多种不相关算法:违反接口隔离,应按变化点拆成多个策略族。
- 把「判断对象类型」当成策略:类型分支更适合用多态(重写方法),而不是策略。
追问
- if/else 里分支只是「打印日志格式不同」算策略吗?答:不算,这属于输出格式差异,可走格式化器或枚举映射;策略要求行为可整体替换。
- 策略模式会让类数量膨胀吗?答:会,所以只有「分支数 ≥ 3 且持续增长」时才值得;分支少用 Map 或枚举即可。
01.3.2.8-002 策略注册表 + key 分发怎么写?默认策略怎么兜底?
一句话结论
注册表就是一个 Map<String, Strategy>:启动时把所有实现按 type() 收集进去,调用时按 key 取;取不到时要么走显式注册的默认策略,要么抛出业务异常,绝不能静默返回 null。
概念解释
- key 的来源:策略实现自报类型(
type()),或由外部配置指定。 - 收集方式:容器自动注入
Map<String, T>(Spring)、手动构造、启动时扫描。 - 兜底:
getOrDefault(defaultStrategy, key)或抛NotFoundStrategyException,二者按业务语义选择。
原理流程
- 定义策略接口,每个实现自带
key()。 - 启动时遍历所有实现,按 key 放入 Map。
- 调用方传入 key,上下文从 Map 取策略。
- 命中失败时走默认策略或抛异常。
代码或图示
public class DiscountContext {
private final Map<String, DiscountStrategy> registry;
private final DiscountStrategy defaultStrategy;
public DiscountContext(List<DiscountStrategy> strategies, DiscountStrategy defaultStrategy) {
this.registry = strategies.stream()
.collect(Collectors.toMap(DiscountStrategy::type, s -> s));
this.defaultStrategy = defaultStrategy;
}
public BigDecimal discount(String type, BigDecimal price) {
DiscountStrategy s = registry.getOrDefault(type, defaultStrategy);
return s.discount(price);
}
}
常见误区
- 注册表 key 用中文或业务枚举字面量:应使用稳定的英文编码,避免业务文案调整后失效。
- 取到 null 后直接调用:NPE 会在调用点暴露,错误信息丢失 key 上下文,应在上下文层统一抛带 key 的异常。
- 每次调用
registry.get后才if null:兜底逻辑分散在业务代码里,等于没消除分支。
追问
- 默认策略应该注册还是写死?答:能注册就注册,让它也成为一个普通策略实现,避免在上下文里写特例分支。
- 注册表里重复 key 会怎样?答:启动时就应该失败(
toMap默认抛IllegalStateException),不要让后注册的悄悄覆盖。
01.3.2.8-003 Go 里怎么用函数类型做策略?
一句话结论
Go 没有类继承,策略最自然的形态是「函数类型 + 普通函数/闭包」:定义一个 type Discount func(price float64) float64,每个分支就是一个函数,注册表用 map[string]Discount 分发;只有当策略需要多个方法或持有依赖时,才升级为接口。
概念解释
- Go 函数是一等公民,可以作为字段、参数、Map 的值。
- 函数类型接口化:单方法函数类型天然兼容函数值;复杂行为用
interface。 - 闭包可以携带外部状态,但要注意闭包捕获的变量生命周期。
原理流程
- 定义策略函数类型。
- 每个分支写一个普通函数或闭包。
- 构造
map[string]Discount做注册表。 - 调用时按 key 取函数并直接调用。
代码或图示
package discount
type Discount func(price float64) float64
var normal Discount = func(p float64) float64 { return p }
var gold Discount = func(p float64) float64 { return p * 0.9 }
var vip Discount = func(p float64) float64 { return p * 0.8 }
var registry = map[string]Discount{
"NORMAL": normal,
"GOLD": gold,
"VIP": vip,
}
func Calc(level string, price float64) (float64, error) {
d, ok := registry[level]
if !ok {
return 0, fmt.Errorf("unknown level: %s", level)
}
return d(price), nil
}
常见误区
- 用函数类型做策略却在函数里访问全局可变状态:策略应是纯函数,依赖应通过构造参数注入或改成接口。
- 在闭包里捕获请求级变量:闭包会让变量逃逸到堆,且异步调用时可能读到被修改后的值。
- 接口只有一个方法时还坚持写结构体实现:Go 里这种情况直接用函数类型更轻。
追问
- Go 怎么把依赖注入函数策略?答:写一个工厂函数
func NewXxxRepoStrategy(r Repo) Discount,返回闭包持有 repo;注册时调用工厂。 - 函数类型策略怎么 mock?答:直接在测试里传一个假函数即可,不需要实现接口。
01.3.2.8-004 TypeScript 与 Python 的函数式策略怎么写?
一句话结论
TS 用函数类型别名或 Record<K, Fn> 注册表;Python 用普通函数 + dict,或用 @dataclass 类策略;两者都不需要为单方法策略引入接口类,注册表就是普通 Map。
概念解释
- TS:
type Discount = (price: number) => number,注册表Record<string, Discount>。 - Python:函数即对象,
REGISTRY: dict[str, Callable[[float], float]]。 - 当策略需要多方法或依赖注入时,才升级为 class。
原理流程
- 定义函数签名类型。
- 每个分支写一个箭头函数/普通函数。
- 构造注册表,按 key 取函数并调用。
代码或图示
type Discount = (price: number) => number;
const normal: Discount = (p) => p;
const gold: Discount = (p) => p * 0.9;
const vip: Discount = (p) => p * 0.8;
const registry: Record<string, Discount> = { NORMAL: normal, GOLD: gold, VIP: vip };
function calc(level: string, price: number): number {
const d = registry[level];
if (!d) throw new Error(`unknown level: ${level}`);
return d(price);
}
from collections.abc import Callable
Discount = Callable[[float], float]
REGISTRY: dict[str, Discount] = {
"NORMAL": lambda p: p,
"GOLD": lambda p: p * 0.9,
"VIP": lambda p: p * 0.8,
}
def calc(level: str, price: float) -> float:
d = REGISTRY.get(level)
if d is None:
raise ValueError(f"unknown level: {level}")
return d(price)
常见误区
- TS 里
Record<string, Fn>索引返回Fn而不是Fn | undefined:开启noUncheckedIndexedAccess后必须显式判空。 - Python lambda 里写复杂逻辑:lambda 只适合一行表达式,复杂策略用普通函数或类。
- 在 TS 注册表中用字符串 key 却不用联合类型:丢失了字面量提示,应定义
type Level = "NORMAL" | "GOLD" | "VIP"。
追问
- Python 怎么注册带依赖的策略?答:写工厂函数
def make_repo_strategy(repo) -> Discount: def d(p): ...; return d,注册时调用工厂。 - TS 策略怎么 mock?答:注册表在测试里直接替换成假函数即可。
01.3.2.8-005 Rust 的 fn 指针、闭包和 trait 对象怎么选?
一句话结论
无状态的纯函数用 fn(...) -> ... 函数指针;需要捕获环境的用 impl Fn / Box<dyn Fn>;需要定义一组多方法可互换行为时用 trait + Box<dyn Trait>。选择依据是「是否捕获环境」和「是否有多个方法」。
概念解释
fn指针:无捕获函数,可复制、可作字段。impl Fn:静态分发,编译期单态化,零开销但只能固定一种类型。Box<dyn Fn>:动态分发,可存放不同闭包,有一次堆分配与间接调用开销。- trait:定义一组相关方法,适合复杂策略族。
原理流程
- 策略不捕获环境:用
fn指针最简单。 - 策略捕获环境但只有一种实现:用
impl Fn。 - 运行期需要在多种闭包间切换:用
Box<dyn Fn>。 - 策略需要多方法:定义 trait,用
Box<dyn Trait>或泛型。
代码或图示
// 1. fn 指针:无捕获纯函数
type Discount = fn(f64) -> f64;
fn normal(p: f64) -> f64 { p }
fn gold(p: f64) -> f64 { p * 0.9 }
fn calc(level: &str, price: f64) -> f64 {
let d: Discount = match level {
"GOLD" => gold,
_ => normal,
};
d(price)
}
// 2. Box<dyn Fn>:运行期可切换的闭包
type DiscountDyn = Box<dyn Fn(f64) -> f64>;
fn make(rate: f64) -> DiscountDyn {
Box::new(move |p: f64| p * rate)
}
fn calc_dyn(level: &str, price: f64) -> f64 {
let d: DiscountDyn = match level {
"VIP" => make(0.8),
_ => make(1.0),
};
d(price)
}
常见误区
- 用
fn指针却想捕获变量:编译错误,fn不捕获环境,改用Box<dyn Fn>。 - 把所有策略都写成
Box<dyn Trait>:单态化消失、间接调用开销变大,热点路径优先用泛型或 enum。 - 忽略 trait 对象安全(object safety):trait 里有泛型方法或
Self类型时不能dyn,详见下一题。
追问
impl Fn和Box<dyn Fn>的性能差异?答:前者静态单态化,可能内联;后者每次调用走 vtable,热点路径有差距。- Rust 策略怎么持有依赖?答:闭包 move 依赖即可;trait 策略则把依赖放进实现结构体。
01.3.2.8-006 Rust 用 enum 分派 vs Box<dyn Trait> 的性能与取舍?
一句话结论
enum 分派(match 一个枚举,每个变体对应一种策略)是静态分派,编译器知道所有类型,可内联、可优化、无堆分配;Box<dyn Trait> 是动态分派,运行期走 vtable,可扩展但每次调用有间接开销。策略数量在编译期已知且封闭时优先 enum。
概念解释
- enum 分派:把策略变成枚举变体,调用时
match self { VariantA => ..., VariantB => ... }。 - trait 对象:
Box<dyn Discount>,运行期才知道具体类型。 - 对象安全:trait 只要有泛型方法或返回
Self,就不能做成dyn,这时只能用 enum 或泛型。
原理流程
- 策略集合封闭、数量少且稳定:用 enum。
- 策略集合需要第三方扩展(插件、动态加载):用
dyn Trait。 - 性能敏感的热点路径:enum 或泛型单态化。
- 需要把异构策略放进同一个集合:
Box<dyn Trait>必须。
代码或图示
// enum 分派:静态、封闭、零开销
enum Discount {
Normal,
Gold { rate: f64 },
Vip,
}
impl Discount {
fn apply(&self, price: f64) -> f64 {
match self {
Discount::Normal => price,
Discount::Gold { rate } => price * rate,
Discount::Vip => price * 0.8,
}
}
}
// trait 对象:开放、动态、有堆分配与间接调用
trait Discount {
fn apply(&self, price: f64) -> f64;
}
struct Normal;
impl Discount for Normal { fn apply(&self, p: f64) -> f64 { p } }
struct Gold { rate: f64 }
impl Discount for Gold { fn apply(&self, p: f64) -> f64 { p * self.rate } }
fn calc(d: &dyn Discount, price: f64) -> f64 { d.apply(price) }
常见误区
- 用 enum 但变体里塞大量数据:枚举体会膨胀,变体独占内存;大字段应改
Box<dyn Trait>或把数据放进结构体。 - 用
dyn Trait但 trait 不满足对象安全:编译器直接报错,此时只能用泛型或 enum。 - 认为 enum 不能扩展就放弃:业务侧策略通常封闭,enum 反而更安全(穷尽检查)。
追问
- 什么是对象安全?答:trait 不能有泛型方法、不能返回
Self、不能取Self的引用作为可变指针等;具体规则以 Rust 版本文档为准。 - 枚举分派怎么模拟开放扩展?答:主程序用 enum,插件接口用 trait;两者通过适配层桥接。
01.3.2.8-007 Spring 怎么用 Map<String, Strategy> 自动收集策略?
一句话结论
Spring 容器会把所有实现同一接口的 Bean 按「Bean 名」自动注入到 Map<String, XxxStrategy>,key 默认是 Bean 名;只要给每个策略类起一个稳定的 Bean 名,就能拿到一个现成的注册表,不需要手写收集逻辑。
概念解释
- 注入
List<Strategy>:所有实现按类型收集。 - 注入
Map<String, Strategy>:key 为 Bean 名(默认是类名首字母小写),value 为 Bean 实例。 - 自定义 key:实现
ApplicationContextAware或在构造器里重新分组。
原理流程
- 每个策略实现加
@Component,类名即 key。 - 上下文构造器注入
Map<String, DiscountStrategy>。 - 调用时按 key 从 Map 取 Bean。
- 新增策略只需加一个
@Component类,注册表自动更新。
代码或图示
public interface DiscountStrategy {
String type();
BigDecimal discount(BigDecimal price);
}
@Component("NORMAL")
public class NormalDiscount implements DiscountStrategy {
public String type() { return "NORMAL"; }
public BigDecimal discount(BigDecimal p) { return p; }
}
@Component("GOLD")
public class GoldDiscount implements DiscountStrategy {
public String type() { return "GOLD"; }
public BigDecimal discount(BigDecimal p) { return p.multiply(new BigDecimal("0.9")); }
}
@Service
public class DiscountService {
private final Map<String, DiscountStrategy> registry;
public DiscountService(Map<String, DiscountStrategy> registry) {
this.registry = registry;
}
public BigDecimal calc(String type, BigDecimal price) {
DiscountStrategy s = registry.get(type);
if (s == null) throw new IllegalArgumentException("unknown: " + type);
return s.discount(price);
}
}
常见误区
- 依赖 Bean 名做 key:Bean 名重构后会变,应让策略自报
type(),构造器里按type()重新分组。 - 认为策略 Bean 是多例:默认是 singleton,多线程下策略必须无状态,详见 012 题。
- 同时注入
List和Map:两边都会收集全量 Bean,注意不要重复初始化。
追问
- 怎么按
type()字段而不是 Bean 名分组?答:构造器里registry = list.stream().collect(toMap(DiscountStrategy::type, s -> s)),重复 key 启动即失败。 - 怎么让策略带配置?答:策略类通过
@Value读配置,或用@ConfigurationProperties;不同策略读不同配置前缀。
01.3.2.8-008 TypeScript 可辨识联合 + 穷尽检查何时比策略模式更合适?
一句话结论
当策略集合在编译期封闭(所有分支已知、不会被第三方扩展)时,用可辨识联合(type X = A | B | C)+ switch + never 穷尽检查,比策略类层次更轻、类型推导更好;只有当策略需要运行期动态加载或跨包扩展时,才用注册表式策略。
概念解释
- 可辨识联合:每个变体有一个字面量字段(如
kind: "circle")。 - 穷尽检查:
switch后用default: (x: never) => x,漏掉任何变体编译报错。 - 与策略模式的差异:策略模式运行期分派,联合类型编译期分派。
原理流程
- 定义联合类型,每个变体带
kind字段。 - 用
switch (x.kind)处理所有分支。 - 加
default分支把值赋给never,强制穷尽。 - 新增变体时编译器提示所有未处理点,重构安全。
代码或图示
type Shape =
| { kind: "circle"; radius: number }
| { kind: "square"; side: number }
| { kind: "rect"; w: number; h: number };
function area(s: Shape): number {
switch (s.kind) {
case "circle": return Math.PI * s.radius ** 2;
case "square": return s.side ** 2;
case "rect": return s.w * s.h;
default:
const _exhaustive: never = s;
throw new Error(`unknown: ${_exhaustive}`);
}
}
常见误区
- 把开放集合(插件、用户自定义策略)硬塞进联合类型:每加一个变体都要改包,破坏开闭。
switch不加never兜底:新增变体时遗漏分支不会报错,运行时才暴露。- 用联合类型却在每个 case 里写大量逻辑:case 过长时仍应抽成独立函数,只是分派点保留在 switch。
追问
- 联合类型怎么和注册表策略混用?答:核心封闭类型用联合,外部扩展点用注册表;适配层把联合变体转成注册表 key。
- 为什么
never能做穷尽检查?答:switch穷尽后s在 default 分支收窄为never,给它赋任何其他类型都会报错。
01.3.2.8-009 策略模式和状态模式的关键区别是什么?
一句话结论
两者结构几乎一样(都持有一个「当前行为对象」并委托),但意图相反:策略的切换由外部调用方决定(同一份上下文,主动换算法);状态的切换由状态对象自己决定(上下文被动地在状态间迁移)。
概念解释
- 策略:外部传入或选择策略,策略之间互不相识,不会自己要求切换。
- 状态:每个状态对象知道「在什么事件下应该迁移到哪个状态」,状态迁移规则内聚在状态里。
- 同构点:都用组合代替多分支
switch。
原理流程
- 看切换决定权:在外部 → 策略;在状态对象内部 → 状态。
- 看策略是否知道彼此:策略互不引用;状态持有「下一个状态」的迁移逻辑。
- 看是否需要持久化当前状态:状态模式通常需要持久化当前状态标识。
代码或图示
策略:Context.setStrategy(A) → 外部决定;A 不认识 B/C
状态:Context.handle() → CurrentState.onEvent() → 自己返回 NextState
常见误区
- 把订单状态机写成策略:订单状态会迁移(待支付→已支付→已发货),这是状态模式;只是按订单类型计算运费才是策略。
- 在策略里写「执行完切换到 B」:策略不应承担迁移职责,这是状态模式的活儿。
- 认为结构相似就能互换:结构相似不代表语义相似,意图错了后续维护会很痛。
追问
- 状态模式怎么持久化?答:只存当前状态的 key,恢复时重建状态对象并注入上下文。
- 策略能模拟状态模式吗?答:能,但迁移规则会散落在外部,状态模式的价值就是把迁移内聚。
01.3.2.8-010 策略模式和模板方法怎么选型?
一句话结论
流程骨架固定、只替换其中一两个步骤时用模板方法(继承);整套算法可互换、步骤之间没有固定顺序时用策略(组合)。策略更灵活,可运行期替换;模板方法复用流程更直接,但继承层级会膨胀。
概念解释
- 模板方法:父类
final方法固定步骤顺序,子类只实现差异步骤。 - 策略:上下文持有一个策略对象,整体替换算法;步骤顺序由策略自己决定。
- 现代趋势:模板方法可重构为「把步骤注入函数式策略」,即组合优于继承。
原理流程
- 变化点是「个别步骤」→ 模板方法。
- 变化点是「整套算法」→ 策略。
- 需要运行期替换 → 策略。
- 继承层级已经超过 2 层 → 重构为策略组合。
代码或图示
模板方法:AbstractExporter.export() { read(); format(); write(); }
子类只实现 format(),流程顺序固定
策略: Context.strategy.export(),整个 export 都是可替换的
常见误区
- 用模板方法承载多套完全不同的流程:父类的
final方法会限制子类,差异大时继承体系膨胀。 - 用策略却复制重复流程:公共流程应上移到上下文或抽象策略基类。
- 认为模板方法已经过时:Spring 的
JdbcTemplate、RestTemplate仍然是模板方法思想,只是用回调替代了继承。
追问
- 模板方法怎么用组合重写?答:把每个步骤抽成函数或策略接口,父类构造时传入步骤函数。
- 钩子方法和抽象步骤的区别?答:抽象步骤必须实现;钩子有默认空实现,子类按需覆盖。
01.3.2.8-011 运行时选择策略 vs 编译时固定实现的判断标准?
一句话结论
如果选择依据在编译期已知(配置在启动时确定、部署环境固定、依赖版本固定),用编译时固定(泛型、依赖注入、条件装配);如果选择依据每次请求都不同(用户类型、订单来源、动态开关),用运行时注册表。
概念解释
- 编译期固定:通过泛型参数、构建标签、
@ConditionalOnProperty在启动时锁定。 - 运行时选择:每次调用按 key 查注册表。
- 中间态:启动时根据配置选择一次策略并缓存,等于编译期固定。
原理流程
- 选择依据是否随请求变化?否 → 启动时选定一次。
- 是否需要灰度切换?是 → 配置中心动态切换,但仍走注册表。
- 是否需要多租户按 key 路由?是 → 运行时注册表。
- 热点路径对 vtable 敏感?是 → 优先编译期固定。
代码或图示
// 启动时按配置选择一次:编译期固定
@Configuration
public class StrategyConfig {
@Bean
public DiscountStrategy discountStrategy(
@Value("${discount.default:NORMAL}") String type) {
return switch (type) {
case "GOLD" -> new GoldDiscount();
default -> new NormalDiscount();
};
}
}
常见误区
- 明明选择依据固定,却每次请求都查注册表:多一次 Map 查询虽然不大,但语义上误导。
- 运行时选择却忘了兜底:key 来自外部输入时,必须有默认策略或异常。
- 用条件装配搞灰度:
@ConditionalOnProperty是启动期开关,运行期灰度要用注册表 + 动态配置。
追问
- 启动时选定策略还能切换吗?答:能,但要主动重建上下文或用代理层转发;比每次查注册表更复杂。
- 配置中心驱动算运行时吗?答:算,key 来自配置中心,策略实例可以缓存,但选择逻辑在每次读配置时执行。
01.3.2.8-012 策略对象为什么要无状态?多线程下怎么保证安全?
一句话结论
策略对象通常被注册表/容器共享为单例,如果它持有可变字段,多线程并发调用就会串数据;正确做法是策略无状态(只依赖注入的协作对象,协作对象本身线程安全),请求级参数通过方法参数传入,不要存为字段。
概念解释
- 无状态策略:方法内不访问可变字段,入参出参明确,天然线程安全。
- 有状态策略:必须按请求创建(prototype / 每次 new),或用
ThreadLocal隔离。 - 协作对象:
@Autowired的 Repository、Client 等必须本身线程安全。
原理流程
- 策略类字段只放不可变依赖(
final的协作对象)。 - 请求级数据通过方法参数传递,不存字段。
- 需要跨方法共享的请求态,封装成上下文对象传给策略。
- 必须有状态时,按请求创建策略实例,不放进共享注册表。
代码或图示
// 正确:无状态,字段是不可变协作对象
@Component
public class VipDiscount implements DiscountStrategy {
private final RateClient client; // 线程安全的外部客户端
public VipDiscount(RateClient client) { this.client = client; }
public BigDecimal discount(BigDecimal price) {
return price.multiply(client.rate("VIP")); // 不存中间状态
}
}
// 错误:把请求级数据存成字段
@Component
public class BadDiscount implements DiscountStrategy {
private BigDecimal price; // 多线程下会串
public void setPrice(BigDecimal p) { this.price = p; }
public BigDecimal discount() { return price.multiply(...); }
}
常见误区
- 策略 Bean 里放
static可变字段:所有请求共享,并发事故。 - 认为「策略类是单例所以方法局部变量也不安全」:方法局部变量在栈上,天然线程安全。
- 用
ThreadLocal给有状态策略兜底:ThreadLocal 是方案,但要清理,且线程池复用会泄漏,不如无状态直接。
追问
- 必须有状态的策略怎么办?答:按请求 new 出来(从工厂或 prototype 作用域获取),不要放进共享 Map。
- 策略之间能共享缓存吗?答:能,但缓存对象要线程安全(
ConcurrentHashMap),且缓存的是不可变数据,不要缓存请求态。
01.3.2.8-013 策略配置化怎么落地?什么时候是过度设计?
一句话结论
策略配置化 = 把「选哪个策略、参数是多少」从代码搬到配置中心或数据库;适合策略数量多、业务运营需要动态调整(营销活动、灰度、多租户)的场景;但策略只有两三个、半年不变时,配置化只会增加复杂度,属于过度设计。
概念解释
- 配置内容:策略 key、启用开关、参数(费率、阈值、模板)。
- 配置来源:数据库表、配置中心(Nacos、Apollo)、环境变量。
- 动态刷新:配置变更后,注册表热更新,不重启进程。
原理流程
- 策略类实现自描述接口(
type()、enable()、configure(props))。 - 启动时加载配置,按 key 组装策略实例。
- 配置变更事件触发重建注册表。
- 调用方永远走统一入口,感知不到配置变化。
代码或图示
// 数据库表 strategy_config: type, enabled, rate
public DiscountStrategy build(StrategyConfig cfg) {
return switch (cfg.getType()) {
case "GOLD" -> new GoldDiscount(new BigDecimal(cfg.getRate()));
case "VIP" -> new VipDiscount();
default -> new NormalDiscount();
};
}
// 配置变更时重建注册表
public void onConfigRefresh(List<StrategyConfig> configs) {
Map<String, DiscountStrategy> fresh = configs.stream()
.filter(StrategyConfig::isEnabled)
.collect(Collectors.toMap(StrategyConfig::getType, this::build));
this.registry = fresh; // volatile 引用或加锁
}
常见误区
- 策略参数写死在代码里:运营要改费率还得发版,这是配置化要解决的问题。
- 配置化却不做校验:配置中心给个非法值,策略运行时才报错,应在加载时校验。
- 策略只有 2 个还做热更新:复杂度远大于收益,直接写死。
追问
- 热更新注册表怎么保证线程安全?答:用
volatile引用整体替换,或用ConcurrentHashMap增量更新;不要在遍历中修改。 - 怎么判断是否过度设计?答:问「未来 3 个月会不会有运营自助调整的需求」,没有就先写死,出现后再重构。
跨语言差异对照
| 语言 | 惯用实现 | 差异要点 |
|---|---|---|
| Java | 接口 + 多实现 + Map 注册表;Spring 自动收集 Bean |
类与接口是一等公民;策略默认单例,必须无状态 |
| Go | 函数类型 type Fn func(...) + map[string]Fn;复杂行为用接口 |
没有继承,策略轻量化;闭包可携带依赖 |
| Python | 普通函数 + dict 注册表;复杂策略用 class | 函数即对象,注册最简单;lambda 只适合单行 |
| PHP | 接口 + 多实现 + 容器解析;Laravel 可绑定到容器 | FPM 下每请求重建策略,无状态约束弱 |
| C#/.NET | 接口 + Func<> 委托;DI 容器收集 IEnumerable<IStrategy> |
委托类型让函数式策略天然成立;DI 生命周期要注意 |
| TypeScript | 函数类型别名 + Record<K, Fn>;可辨识联合做编译期分派 |
联合类型 + never 穷尽检查是独有优势 |
| Rust | fn 指针、Box<dyn Fn>、enum 分派、trait 对象 |
静态分派(enum/泛型)与动态分派(dyn)的取舍是 Rust 独有命题 |
跨语言差异
- Java/Spring 的策略注册表是「容器自动收集」,其他语言通常要手动构造 Map。
- Go、Python、TypeScript 因为函数是一等公民,单方法策略不需要接口类,直接用函数。
- Rust 没有「类单例共享」的语义,策略要么编译期固定(泛型/enum),要么运行期动态(
dyn),性能取舍写在类型上。 - PHP 在 FPM 下每请求重建策略实例,无状态约束弱;但在常驻 worker 模型下又必须回到无状态。
- C# 的
Func<>、Action<>委托把函数式策略做成了语言内置能力。 - TypeScript 的可辨识联合是编译期方案,能替代一部分运行期策略,且类型安全。
- Rust 用 enum 封闭策略集合时,穷尽检查比任何语言都严格,新增变体编译器会强制处理。
待整理清单
- [ ] 补充 C#
Delegate.CreateDelegate与 Rustdyn对象安全的具体规则 - [ ] 补充策略模式在 Spring Cloud Gateway、Netty Pipeline 中的落地案例
- [ ] 补充配置中心驱动策略热更新的基准测试(本机实测后填入)
- [ ] 补充 PHP 常驻 worker(Swoole/Octane)下策略状态清理的实际案例