Comment implémenter plusieurs interfaces avec des signatures de méthode identiques dans différents packages

Supposons que vous deviez implémenter des interfaces définies dans des packages distincts avec des signatures de méthodes contradictoires . Cela peut être difficile, mais Go propose une solution.

Prenons un exemple :

• Dans le package A :

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

• Dans le package B :

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

Dans votre package principal :

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
}

Solution :

Pour résoudre ce conflit, Go propose une approche concise :

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

Cela vous permet de vérifier si un objet (d'un type d'interface) est conforme à un autre type d'interface (par exemple, A.Doer) au moment de l'exécution.

Cependant, l'OP met en évidence une autre complication : la logique implémentée pour Do() dans le package A et le package B est distincte. Pour résoudre ce problème, créez des wrappers autour de votre objet :

• DoerA avec C comme champ, implémentant A.Do() logiquement.
• DoerB avec C comme champ, implémentant B. Do() logiquement.

En implémentant des wrappers distincts, vous pouvez contrôler la méthode à utiliser en fonction du type d'interface attendu (A.Doer ou B.Doer). Cela élimine le besoin d'une seule méthode Do() sur l'objet C d'origine, qui aurait du mal à implémenter les deux logiques.