Go 设计模式 - 组合复用

假设一个触发器 Trigger ，在 v1 版本中只有 Polling Trigger (是一种通过轮询的方式的触发器)，领域对象是这样设计的。

type Trigger struct {
  base TriggerBase // 基本属性
  ... // 其他属性
  extra TriggerExtra // 扩展属性，包含了 Polling Trigger 的特定属性
}

如果在 v2 版本中，需求要求添加一个 Instant Trigger (即时触发器)，具备与 Polling Trigger 不同的特定属性。

我们需要在 TriggerExtra 结构体中继续添加 需要的字段吗？显然感觉怪怪的，我们从设计模式的角度来分析一下。

extra 字段存在的不合理性

1. 违反开闭原则
   extra 作为扩展值对象，在进行扩展时，需要对 TriggerExtra 结构体进行修改。
2. 违反单一职责原则
   extra 字段包含了一些不相关的属性。如 Polling Trigger 和 Instant Trigger 两者的不相关属性，以后扩展可能会变得更多。这些属性被统一放在 extra 字段中，它所承担的责任过多。

解决方案

1. 可以通过「继承」的方式。

type Trigger struct {
  base TriggerBase // 基本属性
}

type PollingTrigger struct {
  Trigger
  polling PollingConfig
}

type InstantTrigger struct {
  Trigger
  instant InstantConfig
}

这样就解决问题了。在进行不同版本的扩展时，无需修改原有的代码，只需扩展需要的代码即可。
但 go 并不鼓励继承，子类和父类具有强耦合性。

• 继承复用破坏了包装，因为父类的实现细节会暴露给子类。比如子类可以访问父类的成员变量等，一旦父类的这些变量定义发生变化，子类就可能会失败。
• 如果父类的实现发生改变，那么子类的实现也不得不发生改变。

2. 「组合复用」
   也叫 聚合复用。
   将扩展的字段替换为抽象的接口。

type Trigger struct {
  base TriggerBase
  typeSpecific TypeSpecificConfig
}

type TypeSpecificConfig interface {
  TriggerType() TriggerType
  Validate() error
  String() string
}

type PollingConfig struct {
    pollingInterval   time.Duration
    maxRetries        int
    retryDelay        time.Duration
}

func (c PollingConfig) TriggerType() TriggerType {
    return TriggerTypePollingTrigger
}

func (c PollingConfig) Validate() error {
    if c.pollingInterval <= 0 {
        return errors.New("polling interval must be positive")
    }
    // 其他校验
    return nil
}

func (c PollingConfig) String() string {
  s, _ := json.Marshal(c)
  return s
}

type InstantConfig struct {
    webhook   string
}

func (c InstantConfig) TriggerType() TriggerType {
    return TriggerTypeInstantTrigger
}

func (c InstantConfig) Validate() error {
    if len(c.webhook) == 0 {
        return errors.New("webhook settings required")
    }
    // 其他校验
    return nil
}

func (c InstantConfig) String() string {
  s, _ := json.Marshal(c)
  return s
}

为什么要使用「组合复用」，或者说它的收益在哪？

1. 代码可复用，可以组合多个类对象，可以直接使用子对象的方法。
2. 降低耦合度。类的继承是一种强耦合的方式，特别是如果继承的关系比较深，这种耦合度会更加严重。
3. 可扩展性。我们可以根据需求不断增加新的成员，让系统更加灵活和可扩展。