罗罗编程学习记录
本页内容 展开查看

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&lt;String, Strategy&gt; 自动收集策略? 进阶 已完成 容器注入
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)、具体策略(每个分支一个实现)、上下文(持有并选择策略)。
  • 真正被消除的不是「条件」本身,而是条件判断从业务主干代码里移出,集中到注册表或工厂。
  • 适用前提:分支是「同一类算法的不同实现」(折扣、排序、支付渠道、消息发送通道),而不是「与业务无关的零散校验」。

原理流程

  1. 观察 if/else 中的分支是否共享同一签名。
  2. 抽出接口,每个分支变成一个实现类或函数。
  3. 上下文按 key 从注册表取策略并调用,主干不再出现分支。
  4. 新增分支 = 新增一个实现 + 注册,主干代码零改动。

代码或图示

// 反例:业务主干里堆满分支
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,二者按业务语义选择。

原理流程

  1. 定义策略接口,每个实现自带 key()。
  2. 启动时遍历所有实现,按 key 放入 Map。
  3. 调用方传入 key,上下文从 Map 取策略。
  4. 命中失败时走默认策略或抛异常。

代码或图示

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。
  • 闭包可以携带外部状态,但要注意闭包捕获的变量生命周期。

原理流程

  1. 定义策略函数类型。
  2. 每个分支写一个普通函数或闭包。
  3. 构造 map[string]Discount 做注册表。
  4. 调用时按 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。

原理流程

  1. 定义函数签名类型。
  2. 每个分支写一个箭头函数/普通函数。
  3. 构造注册表,按 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:定义一组相关方法,适合复杂策略族。

原理流程

  1. 策略不捕获环境:用 fn 指针最简单。
  2. 策略捕获环境但只有一种实现:用 impl Fn。
  3. 运行期需要在多种闭包间切换:用 Box<dyn Fn>。
  4. 策略需要多方法:定义 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 或泛型。

原理流程

  1. 策略集合封闭、数量少且稳定:用 enum。
  2. 策略集合需要第三方扩展(插件、动态加载):用 dyn Trait。
  3. 性能敏感的热点路径:enum 或泛型单态化。
  4. 需要把异构策略放进同一个集合: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 或在构造器里重新分组。

原理流程

  1. 每个策略实现加 @Component,类名即 key。
  2. 上下文构造器注入 Map<String, DiscountStrategy>。
  3. 调用时按 key 从 Map 取 Bean。
  4. 新增策略只需加一个 @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,漏掉任何变体编译报错。
  • 与策略模式的差异:策略模式运行期分派,联合类型编译期分派。

原理流程

  1. 定义联合类型,每个变体带 kind 字段。
  2. 用 switch (x.kind) 处理所有分支。
  3. 加 default 分支把值赋给 never,强制穷尽。
  4. 新增变体时编译器提示所有未处理点,重构安全。

代码或图示

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。

原理流程

  1. 看切换决定权:在外部 → 策略;在状态对象内部 → 状态。
  2. 看策略是否知道彼此:策略互不引用;状态持有「下一个状态」的迁移逻辑。
  3. 看是否需要持久化当前状态:状态模式通常需要持久化当前状态标识。

代码或图示

策略:Context.setStrategy(A) → 外部决定;A 不认识 B/C
状态:Context.handle() → CurrentState.onEvent() → 自己返回 NextState

常见误区

  • 把订单状态机写成策略:订单状态会迁移(待支付→已支付→已发货),这是状态模式;只是按订单类型计算运费才是策略。
  • 在策略里写「执行完切换到 B」:策略不应承担迁移职责,这是状态模式的活儿。
  • 认为结构相似就能互换:结构相似不代表语义相似,意图错了后续维护会很痛。

追问

  • 状态模式怎么持久化?答:只存当前状态的 key,恢复时重建状态对象并注入上下文。
  • 策略能模拟状态模式吗?答:能,但迁移规则会散落在外部,状态模式的价值就是把迁移内聚。

01.3.2.8-010 策略模式和模板方法怎么选型?

一句话结论

流程骨架固定、只替换其中一两个步骤时用模板方法(继承);整套算法可互换、步骤之间没有固定顺序时用策略(组合)。策略更灵活,可运行期替换;模板方法复用流程更直接,但继承层级会膨胀。

概念解释

  • 模板方法:父类 final 方法固定步骤顺序,子类只实现差异步骤。
  • 策略:上下文持有一个策略对象,整体替换算法;步骤顺序由策略自己决定。
  • 现代趋势:模板方法可重构为「把步骤注入函数式策略」,即组合优于继承。

原理流程

  1. 变化点是「个别步骤」→ 模板方法。
  2. 变化点是「整套算法」→ 策略。
  3. 需要运行期替换 → 策略。
  4. 继承层级已经超过 2 层 → 重构为策略组合。

代码或图示

模板方法:AbstractExporter.export() { read(); format(); write(); }
         子类只实现 format(),流程顺序固定
策略:    Context.strategy.export(),整个 export 都是可替换的

常见误区

  • 用模板方法承载多套完全不同的流程:父类的 final 方法会限制子类,差异大时继承体系膨胀。
  • 用策略却复制重复流程:公共流程应上移到上下文或抽象策略基类。
  • 认为模板方法已经过时:Spring 的 JdbcTemplate、RestTemplate 仍然是模板方法思想,只是用回调替代了继承。

追问

  • 模板方法怎么用组合重写?答:把每个步骤抽成函数或策略接口,父类构造时传入步骤函数。
  • 钩子方法和抽象步骤的区别?答:抽象步骤必须实现;钩子有默认空实现,子类按需覆盖。

01.3.2.8-011 运行时选择策略 vs 编译时固定实现的判断标准?

一句话结论

如果选择依据在编译期已知(配置在启动时确定、部署环境固定、依赖版本固定),用编译时固定(泛型、依赖注入、条件装配);如果选择依据每次请求都不同(用户类型、订单来源、动态开关),用运行时注册表。

概念解释

  • 编译期固定:通过泛型参数、构建标签、@ConditionalOnProperty 在启动时锁定。
  • 运行时选择:每次调用按 key 查注册表。
  • 中间态:启动时根据配置选择一次策略并缓存,等于编译期固定。

原理流程

  1. 选择依据是否随请求变化?否 → 启动时选定一次。
  2. 是否需要灰度切换?是 → 配置中心动态切换,但仍走注册表。
  3. 是否需要多租户按 key 路由?是 → 运行时注册表。
  4. 热点路径对 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 等必须本身线程安全。

原理流程

  1. 策略类字段只放不可变依赖(final 的协作对象)。
  2. 请求级数据通过方法参数传递,不存字段。
  3. 需要跨方法共享的请求态,封装成上下文对象传给策略。
  4. 必须有状态时,按请求创建策略实例,不放进共享注册表。

代码或图示

// 正确:无状态,字段是不可变协作对象
@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)、环境变量。
  • 动态刷新:配置变更后,注册表热更新,不重启进程。

原理流程

  1. 策略类实现自描述接口(type()、enable()、configure(props))。
  2. 启动时加载配置,按 key 组装策略实例。
  3. 配置变更事件触发重建注册表。
  4. 调用方永远走统一入口,感知不到配置变化。

代码或图示

// 数据库表 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 与 Rust dyn 对象安全的具体规则
  • [ ] 补充策略模式在 Spring Cloud Gateway、Netty Pipeline 中的落地案例
  • [ ] 补充配置中心驱动策略热更新的基准测试(本机实测后填入)
  • [ ] 补充 PHP 常驻 worker(Swoole/Octane)下策略状态清理的实际案例