2. Go 接口基础：接口定义、接口实现、空接口、类型断言、接口组合

在微服务架构中，接口是模块间通信的契约。Go 语言的接口系统采用隐式实现机制，即类型无需显式声明实现某个接口，只要它拥有接口中所有方法签名，就自动满足该接口。这种设计为限流熔断骨架提供了极高的灵活性和可替换性。

2.1 接口定义与核心语法

接口通过 type 关键字定义，内部包含一组方法签名。任何实现了这些方法的类型都自动成为该接口的实现者。

// 定义一个限流器接口
type RateLimiter interface {
    Allow() bool
    Stats() (allowed, denied int64)
}

// 定义一个熔断器接口
type CircuitBreaker interface {
    Execute(req func() error) error
    State() string
}

2.2 接口实现：隐式契约的力量

Go 的隐式实现让代码更加解耦。以下示例展示一个令牌桶限流器如何隐式实现 RateLimiter 接口：

type TokenBucket struct {
    rate     int
    capacity int
    tokens   int
}

func (tb *TokenBucket) Allow() bool {
    if tb.tokens > 0 {
        tb.tokens--
        return true
    }
    return false
}

func (tb *TokenBucket) Stats() (allowed, denied int64) {
    // 实际实现中应维护计数器
    return 100, 20
}

// 编译时检查：确保 *TokenBucket 实现了 RateLimiter
var _ RateLimiter = (*TokenBucket)(nil)

编译时检查惯用法 var _ RateLimiter = (*TokenBucket)(nil) 可以在开发阶段立即发现实现不完整的问题，避免运行时 panic。

2.3 空接口：任意类型的容器

空接口 interface{} 不包含任何方法，因此所有类型都实现了它。在 Go 1.18+ 中，空接口等价于 any 类型别名。

// 空接口可以存储任意值
var data interface{}
data = 42
data = "hello"
data = &TokenBucket{rate: 10, capacity: 100}

// 类型转换需要类型断言
value, ok := data.(*TokenBucket)
if ok {
    fmt.Println("限流器速率:", value.rate)
}

2.4 类型断言：安全地还原具体类型

类型断言用于从接口值中提取底层具体值。语法为 接口值.(目标类型)，返回两个值：提取后的值和布尔标志。

// 类型 switch 示例：处理不同限流器实现
func InspectLimiter(rl RateLimiter) {
    switch v := rl.(type) {
    case *TokenBucket:
        fmt.Printf("令牌桶限流器，容量: %d\n", v.capacity)
    case *LeakyBucket:
        fmt.Printf("漏桶限流器，速率: %d\n", v.rate)
    default:
        fmt.Println("未知限流器类型")
    }
}

2.5 接口组合：构建可扩展的骨架

Go 支持将多个接口嵌入到一个新接口中，形成接口组合。这是构建限流熔断骨架的核心技术。

// 基础接口
type RateLimiter interface {
    Allow() bool
}

type CircuitBreaker interface {
    Execute(req func() error) error
}

type MetricsCollector interface {
    Record(result string, duration time.Duration)
}

// 组合接口：限流熔断骨架的核心契约
type Skeleton interface {
    RateLimiter
    CircuitBreaker
    MetricsCollector
    Name() string
}

2.6 接口在限流熔断骨架中的典型应用

在骨架设计中，接口组合使得各组件可以独立演进。以下表格展示了接口在不同骨架组件中的角色：

// 骨架初始化示例：通过接口组合实现可插拔架构
func NewSkeleton(
    limiter RateLimiter,
    breaker CircuitBreaker,
    metrics MetricsCollector,
    name string,
) Skeleton {
    return &skeletonImpl{
        limiter: limiter,
        breaker: breaker,
        metrics: metrics,
        name:    name,
    }
}

type skeletonImpl struct {
    limiter RateLimiter
    breaker CircuitBreaker
    metrics MetricsCollector
    name    string
}

func (s *skeletonImpl) Allow() bool                          { return s.limiter.Allow() }
func (s *skeletonImpl) Execute(req func() error) error       { return s.breaker.Execute(req) }
func (s *skeletonImpl) Record(result string, dur time.Duration) { s.metrics.Record(result, dur) }
func (s *skeletonImpl) Name() string                         { return s.name }