1
package pipeline
2

3
// Handler 是管道终端的处理函数
4
type Handler func(ctx map[string]any)
5

6
// Middleware 是中间件函数，接收上下文和下一个处理器
7
type Middleware func(ctx map[string]any, next Handler)
8

9
// Chain 将多个中间件组合为单一处理器
10
func Chain(middlewares ...Middleware) Handler {
11
    return func(ctx map[string]any) {
12
        var run func(i int)
13
        run = func(i int) {
14
            if i < len(middlewares) {
15
                // 将后续链包装为 next handler
16
                middlewares[i](ctx, func(c map[string]any) {
17
                    run(i + 1)
18
                })
19
            }
20
        }
21
        run(0)
22
    }
23
}

1
func logging(ctx map[string]any, next Handler) {
2
    start := time.Now()
3
    next(ctx) // 调用下游
4
    fmt.Printf("耗时: %v\n", time.Since(start))
5
}
6

7
func auth(ctx map[string]any, next Handler) {
8
    token, _ := ctx["token"].(string)
9
    if token == "" {
10
        ctx["error"] = "未认证" // 短路：不调用 next
11
        return
12
    }
13
    next(ctx)
14
}
15

16
// 组合：日志 → 认证 → 业务处理
17
handler := Chain(logging, auth, func(ctx map[string]any) {
18
    ctx["result"] = "成功"
19
})

1
// 中间件类型：接收上下文和 next 函数
2
type Middleware<T> = (ctx: T, next: () => void) => void;
3

4
class Pipeline<T> {
5
  private middlewares: Middleware<T>[] = [];
6

7
  // 添加中间件到链尾
8
  use(middleware: Middleware<T>): void {
9
    this.middlewares.push(middleware);
10
  }
11

12
  // 执行中间件链
13
  execute(ctx: T): void {
14
    let index = 0;
15
    const next = (): void => {
16
      if (index < this.middlewares.length) {
17
        const mw = this.middlewares[index]!;
18
        index++;
19
        mw(ctx, next);
20
      }
21
    };
22
    next();
23
  }
24
}