策略模式 + 模板方法 + 注册式工厂 统一设计方案（营销优惠场景示例）

策略模式 + 模板方法 + 注册式工厂 统一设计方案（营销优惠场景示例）

---

文档目的

本档面向开发团队，详细说明一种可复用的架构模式：策略模式 + 模板方法 + 注册式工厂（Dispatcher） ，并在此基础上加入接口能力标签的最佳实践。文档提供：

• 设计理念与目标
• 各类职责说明（到类级别）及为什么要这样设计
• Spring Boot 2.x 实现细节（代码示例）
• 营销优惠（Promotion）示例工程：从代码骨架到运行与测试说明
• 可扩展能力（幂等、异步、重试、限流）的实现策略
• 团队使用规范、命名约定、常见坑

---

一、设计目标（回顾）

1. 高可扩展：新增策略时不修改核心框架代码
2. 低耦合：调用方只依赖接口（IHandler）而非实现
3. 统一流程：模板方法负责统一流程（前置、处理、后置）
4. 自动注册：Dispatcher 自动发现并注册 Handler，避免硬编码
5. 可贴标签扩展能力：通过额外接口（如 AsyncHandler、Idempotent）实现横切能力

---

二、总体架构与类职责

2.1 核心组件概览

• IHandler（接口）

  • 声明契约：String getCode()、void handle(Context ctx)
  • 作用：面向接口编程，外部通过接口依赖，不直接依赖抽象类实现

• AbstractHandler（抽象类 / 模板方法）

  • 提供模板方法 final void handle(Context)，内部调用 before()、doHandle()、after()
  • 可注入公共服务（例如：log、metrics、service）
  • 作用：复用通用逻辑，规范流程顺序

• ConcreteHandler（具体实现类）

  • 实现 getCode() 和 doHandle(Context)
  • 仅包含业务逻辑（例如：计算优惠、发券、记录统计）

• HandlerDispatcher（注册式工厂 / 路由）

  • Spring 注入 List<IHandler>，构建 Map<String, IHandler> 注册表
  • 提供 dispatch(code, context) 方法，运行对应 handler
  • 处理找不到 handler 的兜底策略（抛错、降级）

• 能力标签接口（可选）

  • 示例：AsyncHandler、IdempotentHandler、RetryableHandler、RateLimited 等
  • 作用：通过 instanceof 或 Spring AOP 自动启用相应横切逻辑

• Context（数据载体）

  • 统一使用 DTO 或 Context 对象传递数据，不直接传 raw JSON
  • 方便扩展字段（traceId、bizId、version）

2.2 为什么需要这些类（逐条解释）

• 接口 IHandler：

  • 原因：面向接口编程，利于单元测试、Mock、SPI 扩展。接口定义是稳定对外合约，扩展新实现不会破坏依赖者。

• AbstractHandler：

  • 原因：模板方法能把通用的前置/后置逻辑（审计、幂等校验、埋点、异常兜底）统一封装，避免每个 Handler 都写重复代码。

• ConcreteHandler：

  • 原因：业务聚焦，开发人员只需实现 doHandle，降低出错概率与学习成本。

• HandlerDispatcher：

  • 原因：集中管理 handler，避免 if/else、switch、反射动态查找的复杂性，支持运行时扩展。

• 能力标签接口：

  • 原因：有些特性（异步、限流、幂等、重试）是横切关注点。通过接口可在框架层面检测并施加策略，而不修改业务代码。

---

三、代码示例（营销优惠 Promotion 场景）

3.1 场景说明

业务：系统接收营销活动触发请求（例如基于事件或用户操作），根据不同活动类型（满减、折扣、折扣券、买赠、阶梯优惠等）执行不同算法，输出最终优惠结果并发放优惠券或产生订单折扣。

目标：使用本设计模式实现营销优惠引擎，便于扩展新活动类型，同时支持：幂等、异步、重试能力。

3.2 项目结构（建议）

promotion-demo/ (maven)
├─ promotion-api/ (公共 DTO、Context)
├─ promotion-core/ (抽象类、Dispatcher、能力接口)
├─ promotion-handlers/ (具体 Handler 实现)
└─ promotion-app/ (Spring Boot 启动器、演示 Controller/CLI)

3.3 关键代码（精简可运行样例）

3.3.1 Context 与 DTO

// promotion-api/src/main/java/com/example/promotion/PromotionContext.java
public class PromotionContext {
    private String code; // handler code
    private String userId;
    private String orderId;
    private BigDecimal amount;
    private Map<String, Object> extra = new HashMap<>();
    // getters & setters
}

3.3.2 IHandler 接口

// promotion-core
public interface IHandler {
    String getCode();
    void handle(PromotionContext ctx) throws Exception;
}

3.3.3 抽象模板 AbstractHandler

@Slf4j
public abstract class AbstractHandler implements IHandler {

    @Autowired
    protected PromotionLogService promotionLogService; // 示例公共服务

    @Override
    public final void handle(PromotionContext ctx) throws Exception{
        String trace = startTrace(ctx);
        try{
            preHandle(ctx);
            doHandle(ctx);
            postHandle(ctx);
        } catch (Exception e){
            onError(ctx,e);
            throw e;
        } finally{
            endTrace(trace);
        }
    }

    protected String startTrace(PromotionContext ctx){
        // 例如生成traceId，埋点
        return UUID.randomUUID().toString();
    }

    protected void preHandle(PromotionContext ctx){
        // 通用校验 (幂等、权限、参数)
        log.info("preHandle {}", getCode());
    }

    protected abstract void doHandle(PromotionContext ctx) throws Exception;

    protected void postHandle(PromotionContext ctx){
        // 通用后置（日志、埋点、版本）
        log.info("postHandle {}", getCode());
    }

    protected void onError(PromotionContext ctx, Exception e){
        promotionLogService.logError(ctx, e);
    }

}

3.3.4 能力接口（示例）

public interface AsyncHandler {}
public interface IdempotentHandler {}
public interface RetryableHandler {}
public interface RateLimitedHandler {}

3.3.5 具体 Handler 示例（满减）

@Component
public class ThresholdDiscountHandler extends AbstractHandler {

    @Override
    public String getCode(){ return "THRESHOLD_DISCOUNT"; }

    @Override
    protected void doHandle(PromotionContext ctx){
        BigDecimal amount = ctx.getAmount();
        // 简单规则：满 100 减 10
        if(amount.compareTo(new BigDecimal(100)) >= 0){
            ctx.getExtra().put("discount", new BigDecimal(10));
        } else {
            ctx.getExtra().put("discount", BigDecimal.ZERO);
        }
    }
}

3.3.6 注册式工厂/Dispatcher

@Component
public class HandlerDispatcher {

    private final Map<String, IHandler> handlerMap;

    @Autowired
    public HandlerDispatcher(List<IHandler> handlers){
        this.handlerMap = handlers.stream()
                .collect(Collectors.toMap(IHandler::getCode, h->h));
    }

    public void dispatch(String code, PromotionContext ctx) throws Exception{
        IHandler h = handlerMap.get(code);
        if(h == null) throw new IllegalArgumentException("Unknown code: " + code);

        // 能力接口检测：示例 - 如果是 AsyncHandler 则提交线程池
        if(h instanceof AsyncHandler){
            // 提交到线程池执行（示例，同步返回 id）
            asyncExecutor.submit(() -> {
                try { h.handle(ctx);} catch(Exception e) { log.error(e.getMessage(), e);} });
            return;
        }

        // 幂等：在 preHandle 或 Dispatcher 上统一处理 idempotent
        if(h instanceof IdempotentHandler){
            // do idempotent check
        }

        // 直接调用
        h.handle(ctx);
    }
}

注：asyncExecutor、幂等校验、限流、重试等建议在 Dispatcher 层或通过 AOP 实现，不要让业务 Handler 负责这些横切关注点。

3.4 运行示例（Controller）

@RestController
@RequestMapping("/promo")
public class PromoController {

    @Autowired
    HandlerDispatcher dispatcher;

    @PostMapping("/apply/{code}")
    public ResponseEntity apply(@PathVariable String code, @RequestBody PromotionContext ctx){
        try{
            dispatcher.dispatch(code, ctx);
            return ResponseEntity.ok(ctx.getExtra());
        } catch (Exception e){
            return ResponseEntity.status(500).body(e.getMessage());
        }
    }
}

示例请求：

POST /promo/apply/THRESHOLD_DISCOUNT
{ "userId":"u1", "orderId":"o1", "amount": 120 }

返回：`{ "discount": 10 }

---

四、能力扩展实现

4.1 方案一：责任链能力增强

将所有能力抽象成"HandlerFilter"，按照顺序处理请求

类似 Spring MVC FilterChain / Gateway FilterChain / Netty Pipeline

4.1.1 定义责任链过滤器接口

public interface HandlerFilter {

    /**
     * @param handler   真实 Handler
     * @param ctx       入参
     * @param chain     下一过滤器
     */
    void doFilter(IHandler handler, PromotionContext ctx, HandlerFilterChain chain);
}

4.1.2 责任链实现

public class HandlerFilterChain {

    private final List<HandlerFilter> filters;
    private int index = 0;

    public HandlerFilterChain(List<HandlerFilter> filters) {
        this.filters = filters;
    }

    public void doFilter(IHandler handler, PromotionContext ctx) {
        if (index < filters.size()) {
            HandlerFilter f = filters.get(index++);
            f.doFilter(handler, ctx, this);
        } else {
            handler.handle(ctx);
        }
    }
}

4.1.3 把能力封装成 Filter

异步 Filter

@Component
public class AsyncFilter implements HandlerFilter {

    @Autowired
    ExecutorService executor;

    @Override
    public void doFilter(IHandler handler, PromotionContext ctx, HandlerFilterChain chain) {
        if (!(handler instanceof AsyncHandler)) {
            chain.doFilter(handler, ctx);
            return;
        }

        executor.submit(() -> chain.doFilter(handler, ctx));
    }
}

幂等 Filter

@Component
public class IdempotentFilter implements HandlerFilter {

    @Autowired
    RedisTemplate<String, String> redis;

    @Override
    public void doFilter(IHandler handler, PromotionContext ctx, HandlerFilterChain chain) {

        if (!(handler instanceof IdempotentHandler)) {
            chain.doFilter(handler, ctx);
            return;
        }

        String key = "idempotent:" + handler.code() + ":" + ctx.getBizId();

        Boolean ok = redis.opsForValue().setIfAbsent(key, "1", Duration.ofMinutes(10));

        if (!Boolean.TRUE.equals(ok)) {
            log.warn("幂等校验命中：{}", key);
            return; // 直接终止
        }

        chain.doFilter(handler, ctx);
    }
}

重试 Filter

@Component
public class RetryFilter implements HandlerFilter {

    @Override
    public void doFilter(IHandler handler, PromotionContext ctx, HandlerFilterChain chain) {

        if (!(handler instanceof RetryableHandler retry)) {
            chain.doFilter(handler, ctx);
            return;
        }

        int times = retry.retryTimes();
        long backoff = retry.backoffMs();

        for (int i = 1; i <= times; i++) {
            try {
                chain.doFilter(handler, ctx);
                return;
            } catch (Exception e) {
                if (i == times) throw e;
                Thread.sleep(backoff * i);
            }
        }
    }
}

限流 Filter

@Component
public class RateLimitFilter implements HandlerFilter {

    @Autowired
    RedisTemplate<String, String> redis;

    @Override
    public void doFilter(IHandler handler, PromotionContext ctx, HandlerFilterChain chain) {

        if (!(handler instanceof RateLimitedHandler rate)) {
            chain.doFilter(handler, ctx);
            return;
        }

        String key = "rate:" + handler.code();

        Long count = redis.opsForValue().increment(key);
        redis.expire(key, 1, TimeUnit.SECONDS);

        if (count > rate.qps()) {
            log.warn("限流触发 > {}", rate.qps());
            return;
        }

        chain.doFilter(handler, ctx);
    }
}

4.1.4 Dispatcher

@Component
public class PromotionDispatcher {

    private final Map<String, IHandler> handlerMap;
    private final List<HandlerFilter> filters;

    @Autowired
    public PromotionDispatcher(List<IHandler> handlers, List<HandlerFilter> filters) {
        this.filters = filters;
        handlerMap = handlers.stream().collect(Collectors.toMap(IHandler::code, h -> h));
    }

    public void dispatch(String code, PromotionContext ctx) {
        IHandler handler = handlerMap.get(code);
        HandlerFilterChain chain = new HandlerFilterChain(filters);
        chain.doFilter(handler, ctx);
    }
}

4.2 方案二：使用 AOP 实现能力增强（零侵入）

不改 Dispatcher，不改 Handler，只用注解实现

最适合框架化封装、中间件开发

4.2.1 定义注解

// 异步
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AsyncAbility {}

// 幂等
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface IdempotentAbility {
    String key();
}

// 重试
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RetryAbility {
    int times() default 3;
    long backoff() default 200;
}

// 限流
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimitAbility {
    int qps();
}

4.2.2 切面统一处理

只展示幂等示例：

@Aspect
@Component
public class IdempotentAspect {

    @Autowired
    RedisTemplate<String, String> redis;

    @Around("@annotation(ann)")
    public Object around(ProceedingJoinPoint pjp, IdempotentAbility ann) throws Throwable {
        String key = ann.key();
        Boolean ok = redis.opsForValue().setIfAbsent(key, "1", Duration.ofMinutes(10));

        if (!Boolean.TRUE.equals(ok)) {
            log.info("幂等拦截 {}", key);
            return null;
        }

        return pjp.proceed();
    }
}

4.2.3 具体Handler

@AsyncAbility
@IdempotentAbility(key = "promo:user:{{ctx.userId}}")
@RetryAbility(times = 3)
@RateLimitAbility(qps = 50)
public void doHandle(PromotionContext ctx) {

}

---

五、架构图

                                    +-------------------+
                                    |   外部调用入口     |
                                    |  (Controller / MQ) |
                                    +---------+---------+
                                              |
                                              v
                                    +-------------------+
                                    |   HandlerDispatcher  (注册式工厂)   |
                                    | - Map<code, IHandler>             |
                                    | - 注入 List<IHandler> & List<Filter>|
                                    +---------+---------+
                                              |
                                              v
                          +-----------------------------------------------+
                          |      HandlerFilterChain / Filters (可选)     |
                          |  (责任链：按顺序执行能力过滤器/增强器)         |
                          |  - RateLimitFilter   (限流, Redis)            |
                          |  - IdempotentFilter  (幂等, Redis/DB)         |
                          |  - AuthFilter        (权限校验)               |
                          |  - RetryFilter       (重试包装/回退策略)      |
                          |  - AsyncFilter       (异步提交/线程池/MQ)     |
                          +----------------+------------------------------+
                                           |
                                           v
                            (责任链末端调用 -> 真正的 Handler 执行点)
                                           |
                                           v
+-------------------------------------------------------------+
|                         IHandler (接口)                     |
|  + getCode() : String                                        |
|  + handle(ctx: Context) : void                              |
+---------------------------+---------------------------------+
                            |
                            v
+-------------------------------------------------------------+
|                      AbstractHandler (模板方法)             |
|  - final handle(ctx) {                                       |
|       preHandle(ctx);            // 共性前置（日志、trace）  |
|       doHandle(ctx);             // 子类实现的业务方法       |
|       postHandle(ctx);           // 共性后置（审计、metrics）}|
|  - protected abstract doHandle(ctx)                          |
+---------------------------+---------------------------------+
                            |
           +----------------+-------------------------------+
           |                |                |              |
           v                v                v              v
+----------------+  +----------------+  +----------------+  +----------------+
| CouponHandler  |  | SmsHandler     |  | OrderHandler   |  | OtherHandler   |
| (Concrete)     |  | (Concrete)     |  | (Concrete)     |  | (Concrete)     |
| @Idempotent    |  | @Async         |  | @RetryAbility  |  | @RateLimited   |
| @RetryAbility  |  | @RateLimited   |  |                |  |                |
+----------------+  +----------------+  +----------------+  +----------------+

（注：子类业务方法 doHandle() 上用注解或直接实现能力接口）

5.1 执行时序（简明步骤）

1. 外部调用（HTTP / MQ）→ HandlerDispatcher.dispatch(code, ctx)。
2. Dispatcher 根据 code 从注册表取到对应 IHandler。
3. Dispatcher 构造 HandlerFilterChain（或直接使用注入的 Filter 列表）。
4. 责任链按顺序执行：
   • RateLimitFilter (Redis 令牌桶) → 拒绝或通过
   • IdempotentFilter (SETNX 或 DB 唯一键) → 已处理则短路
   • AuthFilter（权限/参数校验）
   • RetryFilter（包装后续调用，负责重试与退避）
   • AsyncFilter（若标记异步则提交线程池或MQ，并决定是否等待/返回）
5. 责任链末端调用 AbstractHandler.handle()（模板方法）：
   • preHandle（通用前置，如 traceId、日志）
   • doHandle（子类业务；此处被 AOP 注解拦截的横切能力也作用于该方法）
   • postHandle（通用后置，如埋点、清理）
6. 子类 doHandle() 可被 AOP 注解（@IdempotentAbility、@RetryAbility、@RateLimitAbility、@AsyncAbility）进一步拦截或增强（二选一：责任链或 AOP 实现能力）。
7. 处理过程中会使用：
   • ExecutorService / ThreadPool（异步执行）
   • Redis（幂等 + 限流 + 分布式锁）
   • MQ（异步/补偿/消息队列）
   • DB（落库、唯一索引）
   • Monitoring（metrics/ELK/Tracing）

六、命名规范

• Handler 类名：<业务场景><策略>Handler，例如 OrderThresholdDiscountHandler、CouponIssueHandler
• Code 命名：UPPER_SNAKE 或 Dot.Delimited

---

七、常见坑与防护

1. Handler 内部做横切逻辑（如重试/限流）：会导致重复实现，建议统一在 Dispatcher/AOP
2. Handler 过多依赖注入 ：抽象类注入过多 service 导致耦合高，建议把公共服务封装成 HandlerSupport 小工具类
3. getCode 冲突：注册时需校验重复 code，防止覆盖
4. 序列化/Context 版本管理：Context 字段变动需兼容老版本
5. 异常吞掉：模板方法中不要吞掉异常，必须做好日志和告警