So implementieren Sie mehrere Schnittstellen mit identischen Methodensignaturen in verschiedenen Paketen

Angenommen, Sie müssen Schnittstellen implementieren, die in separaten Paketen mit widersprüchlichen Methodensignaturen definiert sind . Das kann eine Herausforderung sein, aber Go bietet eine Lösung.

Betrachten wir ein Beispiel:

• In Paket A:

  package A
  
  type Doer interface {
    Do() string
  }
  
  func FuncA(doer A.Doer) {
    // Use doer.Do() here to implement functionality
  }

• In Paket B:

  package B
  
  type Doer interface {
    Do() string
  }
  
  func FuncB(doer B.Doer) {
    // Use doer.Do() here to implement functionality
  }

In Ihrem Hauptpaket:

package main

import (
    "path/to/A"
    "path/to/B"
)

type C int

// C implements both A.Doer and B.Doer, but the implementation of Do() aligns with A.
func (c C) Do() string {
    return "C implements both A and B"
}

func main() {
    c := C(0)
    A.FuncA(c) // Acceptable as C implements A.Doer
    B.FuncB(c) // Error, as the Do() implementation in C doesn't meet B.Doer requirements
}

Lösung:

Um diesen Konflikt zu lösen, bietet Go einen prägnanten Ansatz:

if _, ok := obj.(A.Doer); ok {
}

Damit können Sie überprüfen, ob ein Objekt (eines Schnittstellentyps) zur Laufzeit einem anderen Schnittstellentyp (z. B. A.Doer) entspricht.

Das OP weist jedoch auf eine weitere Komplikation hin : Die für Do() in Paket A und Paket B implementierte Logik ist unterschiedlich. Um dies zu beheben, erstellen Sie Wrapper um Ihr Objekt:

• DoerA mit C als Feld und implementiert A.Do() logisch.
• DoerB mit C als Feld und implementiert B. Do() logisch.

Durch die Implementierung unterschiedlicher Wrapper können Sie basierend auf dem erwarteten Schnittstellentyp (A.Doer oder B.Doer) steuern, welche Methode verwendet werden soll. Dadurch entfällt die Notwendigkeit einer einzelnen Do()-Methode für das ursprüngliche C-Objekt, die bei der Implementierung beider Logiken Schwierigkeiten bereiten würde.