1
package fallback
2

3
import "fmt"
4

5
// FallbackFunc 定义降级函数的类型
6
type FallbackFunc func(error) (string, error)
7

8
// WithFallback 用降级函数包装可能失败的调用
9
func WithFallback(primary FallbackFunc, fallback FallbackFunc) FallbackFunc {
10
    return func(err error) (string, error) {
11
        result, err := primary(err)
12
        if err != nil {
13
            // 主逻辑失败，执行降级
14
            fallbackResult, fallbackErr := fallback(err)
15
            if fallbackErr != nil {
16
                // 降级也失败了，返回原始错误
17
                return "", fmt.Errorf("主逻辑和降级均失败: %w, 降级错误: %v", err, fallbackErr)
18
            }
19
            return fallbackResult, nil
20
        }
21
        return result, nil
22
    }
23
}
24

25
// CachedFallback 示例：优先用缓存，缓存也没有则返回默认值
26
func CachedFallback(cache map[string]string, defaultVal string) FallbackFunc {
27
    return func(err error) (string, error) {
28
        // 尝试从缓存获取
29
        if val, ok := cache["latest"]; ok {
30
            return val, nil
31
        }
32
        // 缓存也没有，返回默认值
33
        return defaultVal, nil
34
    }
35
}

1
package circuitbreaker
2

3
import (
4
  "fmt"
5
  "sync"
6
  "time"
7
)
8

9
type State int
10

11
const (
12
  StateClosed   State = iota // 关闭状态，正常放行
13
  StateOpen                  // 打开状态，快速失败
14
  StateHalfOpen              // 半开状态，允许探测
15
)
16

17
type CircuitBreaker struct {
18
  mu           sync.Mutex
19
  threshold    int       // 连续失败阈值
20
  resetTimeout int64     // 冷却时间（毫秒）
21
  state        State     // 当前状态
22
  failCount    int       // 连续失败计数
23
  lastFailTime int64     // 最后一次失败的时间戳
24
}
25

26
func New(threshold int, resetTimeoutMs int64) *CircuitBreaker {
27
  return &CircuitBreaker{
28
    threshold:    threshold,
29
    resetTimeout: resetTimeoutMs,
30
    state:        StateClosed,
31
  }
32
}
33

34
func (cb *CircuitBreaker) Call(fn func() error) error {
35
  cb.mu.Lock()
36
  // 冷却期结束，从 OPEN 转为 HALF_OPEN
37
  if cb.state == StateOpen &&
38
    time.Now().UnixMilli()-cb.lastFailTime >= cb.resetTimeout {
39
    cb.state = StateHalfOpen
40
  }
41
  state := cb.state
42
  cb.mu.Unlock()
43

44
  // OPEN 状态直接拒绝
45
  if state == StateOpen {
46
    return fmt.Errorf("circuit breaker is OPEN")
47
  }
48

49
  err := fn()
50
  cb.mu.Lock()
51
  defer cb.mu.Unlock()
52

53
  if err != nil {
54
    cb.failCount++
55
    cb.lastFailTime = time.Now().UnixMilli()
56
    if cb.failCount >= cb.threshold {
57
      cb.state = StateOpen // 连续失败达标，跳闸
58
    }
59
    return err
60
  }
61

62
  // 成功则重置
63
  cb.failCount = 0
64
  cb.state = StateClosed
65
  return nil
66
}

1
type State = "CLOSED" | "OPEN" | "HALF_OPEN";
2

3
class CircuitBreaker {
4
  private state: State = "CLOSED";
5
  private failureCount = 0;
6
  private lastFailureTime = 0;
7

8
  constructor(
9
    private threshold: number,
10
    private resetTimeout: number, // 毫秒
11
  ) {}
12

13
  private checkState(): State {
14
    // 冷却期结束，转为 HALF_OPEN
15
    if (
16
      this.state === "OPEN" &&
17
      Date.now() - this.lastFailureTime >= this.resetTimeout
18
    ) {
19
      this.state = "HALF_OPEN";
20
    }
21
    return this.state;
22
  }
23

24
  async call<T>(fn: () => Promise<T>): Promise<T> {
25
    if (this.checkState() === "OPEN") {
26
      throw new Error("Circuit breaker is OPEN");
27
    }
28

29
    try {
30
      const result = await fn();
31
      // 探测成功，恢复到 CLOSED
32
      this.failureCount = 0;
33
      this.state = "CLOSED";
34
      return result;
35
    } catch (err) {
36
      this.failureCount++;
37
      this.lastFailureTime = Date.now();
38
      // 连续失败达标，跳闸
39
      if (this.failureCount >= this.threshold) {
40
        this.state = "OPEN";
41
      }
42
      throw err;
43
    }
44
  }
45
}