3. 接口组合与嵌入：接口嵌套、结构体嵌入接口、接口与结构体的组合模式

在微服务业务编排中，单一接口往往无法完整描述复杂的行为集合。Go 语言通过接口嵌套、结构体嵌入接口以及接口与结构体的组合模式，提供了灵活且类型安全的抽象手段。本章将深入这三种模式的设计意图、实现方式与最佳实践。

3.1 接口嵌套：构建行为层次

接口嵌套允许将一个接口嵌入到另一个接口中，从而组合多个行为集合。这与结构体嵌入不同，接口嵌套只继承方法签名，不涉及字段或实现。

3.1.1 基本语法与语义

// 基础接口
type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

// 嵌套接口：组合 Reader 和 Writer
type ReadWriter interface {
    Reader
    Writer
}

// 进一步扩展
type Closer interface {
    Close() error
}

type ReadWriteCloser interface {
    Reader
    Writer
    Closer
}

嵌套接口等价于将内嵌接口的所有方法展开到外层接口中。编译器会检查嵌套接口是否满足方法集的完整性。

3.1.2 接口嵌套的冲突与解决

3.2 结构体嵌入接口：实现与抽象的混合

结构体可以嵌入接口类型，从而在结构体中“继承”接口的方法集。这种模式常用于默认实现、装饰器模式和策略模式。

3.2.1 嵌入接口的结构体

// 定义一个接口
type Logger interface {
    Log(message string)
}

// 默认实现
type ConsoleLogger struct{}

func (c ConsoleLogger) Log(message string) {
    fmt.Println("[Console]", message)
}

// 结构体嵌入接口
type Service struct {
    Logger // 嵌入接口
    Name   string
}

func main() {
    svc := Service{
        Logger: ConsoleLogger{},
        Name:   "OrderService",
    }
    svc.Log("服务启动") // 调用嵌入接口的方法
}

当结构体嵌入接口时，该结构体自动获得接口的所有方法。如果结构体自身没有实现这些方法，则必须通过字段赋值提供一个实现了该接口的具体值。

3.2.2 覆盖与扩展

结构体可以覆盖嵌入接口的方法，实现自定义行为：

type FileLogger struct{}

func (f FileLogger) Log(message string) {
    fmt.Println("[File]", message)
}

type Service struct {
    Logger
    Name string
}

// 覆盖 Log 方法
func (s Service) Log(message string) {
    fmt.Println("[Service]", s.Name, message)
    s.Logger.Log(message) // 仍然可以调用嵌入的 Logger
}

3.3 接口与结构体的组合模式

组合模式在 Go 中通过结构体嵌入实现，而接口则定义了组合对象的统一行为。这种模式在业务编排中尤为常见，用于构建可扩展的处理链。

3.3.1 组合模式的结构

// 组件接口
type Component interface {
    Execute(ctx context.Context) error
}

// 叶子节点：具体业务逻辑
type ValidateStep struct{}

func (v ValidateStep) Execute(ctx context.Context) error {
    fmt.Println("执行验证步骤")
    return nil
}

// 组合节点：包含多个子组件
type CompositeStep struct {
    steps []Component
}

func (c *CompositeStep) Add(step Component) {
    c.steps = append(c.steps, step)
}

func (c *CompositeStep) Execute(ctx context.Context) error {
    for _, step := range c.steps {
        if err := step.Execute(ctx); err != nil {
            return err
        }
    }
    return nil
}

// 使用
func main() {
    composite := &CompositeStep{}
    composite.Add(ValidateStep{})
    composite.Add(ValidateStep{})
    composite.Execute(context.Background())
}

3.3.2 组合模式在编排中的应用

3.4 三种模式的对比与选择

3.5 实战：业务编排中的组合应用

以下示例展示如何在订单处理流程中应用接口组合与嵌入：

// 定义步骤接口
type OrderStep interface {
    Process(ctx context.Context, order *Order) error
}

// 基础步骤：验证
type ValidateStep struct{}

func (s ValidateStep) Process(ctx context.Context, order *Order) error {
    if order.ID == "" {
        return errors.New("订单ID不能为空")
    }
    return nil
}

// 基础步骤：计算价格
type PriceStep struct{}

func (s PriceStep) Process(ctx context.Context, order *Order) error {
    order.Total = order.Quantity * order.UnitPrice
    return nil
}

// 组合步骤：顺序执行
type SequentialStep struct {
    steps []OrderStep
}

func (s *SequentialStep) Add(step OrderStep) {
    s.steps = append(s.steps, step)
}

func (s *SequentialStep) Process(ctx context.Context, order *Order) error {
    for _, step := range s.steps {
        if err := step.Process(ctx, order); err != nil {
            return fmt.Errorf("步骤执行失败: %w", err)
        }
    }
    return nil
}

// 装饰步骤：日志
type LoggingStep struct {
    Step OrderStep
}

func (s LoggingStep) Process(ctx context.Context, order *Order) error {
    log.Printf("开始处理订单: %s", order.ID)
    err := s.Step.Process(ctx, order)
    log.Printf("订单处理完成: %s, err=%v", order.ID, err)
    return err
}

// 使用
func main() {
    pipeline := &SequentialStep{}
    pipeline.Add(ValidateStep{})
    pipeline.Add(LoggingStep{Step: PriceStep{}})
    pipeline.Process(context.Background(), &Order{ID: "ORD-001", Quantity: 2, UnitPrice: 100})
}