Dans GO, comment définir une interface commune en utilisant un modèle d'usine pour gérer différents types de paramètres pour la même méthode d'interfaces différentes?

Le mode d'usine GO Language résout la différence de type de paramètre de méthode d'interface

Cet article examine comment définir une interface commune en utilisant le motif d'usine dans GO pour gérer différents types de paramètres de la même méthode dans différentes interfaces. Le défi de ce problème est que plusieurs interfaces implémentent la même méthode, mais les types de paramètres de ces méthodes varient. L'utilisation interface{} ou any type directement perdra des informations de type et réduira la sécurité du code.

Supposons que nous ayons deux interfaces IAXX et IBXX , qui contiennent toutes deux Create , mais les types de paramètres de Create sont model.AXX et model.BXX respectivement. Afin de définir une interface publique ICommonInterface tout en évitant la perte de type, nous pouvons adopter le mode d'usine.

L'idée principale est de créer une interface ICreatorFactory , qui est responsable de la création et de la fourniture de différents types de paramètres de méthode. La méthode Create de ICreator accepte ICreatorFactory en tant que paramètre, acceptant ainsi indirectement différents types de paramètres.

Exemple de code:

 package principal

Importer "FMT"

// définir le type de modèle (hypothèse)
Type Modelaxx struct {
    Valeur de valeur
}

Type ModelBxx struct {
    Valeur int
}

// Définir l'interface d'usine iCreatorFactory
Tapez l'interface iCreatorFactory {
    GetCreatePayload () Interface {}
}

// Définir l'interface publique iCreator
Tapez l'interface iCreator {
    Créer (iCreatorFactory d'usine)
}

// L'interface IAXX implémente le type iaxx struct {}

func (ia * iaxx) create (iCreatorFactory d'usine) {
    Télécharge utile: = factory.getcreatepayload (). (Modelaxx) // Type Assertion fmt.printf ("iaxx create:% v \ n", charge utile)
}

// L'interface IBXX implémente Type Ibxx Struct {}

func (ib * ibxx) create (factory icreatorfactory) {
    Payload: = factory.getCreatePayload (). (ModelBxx) // Type Assertion fmt.printf ("Ibxx Create:% v \ n", charge utile)
}


// Implémentation d'usine: créer ModelAxx
type axxfactory struct {}

func (af * axxfactory) getcreatepayload () interface {} {
    return Modelaxx {Value: "Bonjour à partir d'axx"}
}

// Implémentation d'usine: Créer ModelBxx
type bxxfactory struct {}

func (bf * bxxfactory) getcreatepayload () interface {} {
    return ModelBxx {valeur: 123}
}

func main () {
    ia: = & iaxx {}
    ib: = & ibxx {}

    ia.create (& axxfactory {})
    ib.create (& bxxfactory {})
}

Dans cet exemple, AXXFactory et BXXFactory implémentent respectivement ICreatorFactory et renvoient leurs types de modèles respectifs. IAXX et IBXX obtiennent en toute sécurité des paramètres à travers des assertions de type, en évitant le problème de la décalage de type. Cette méthode maintient la flexibilité et l'évolutivité du code et évite les risques de sécurité de type provoqués en utilisant interface{} . Il convient de noter que l'utilisation des assertions de type ( .(modelAXX) ) nécessite de s'assurer que l'usine entrante renvoie le type correct, sinon la panique d'exécution se produira. Des implémentations plus robustes peuvent nécessiter l'ajout de mécanismes de gestion des erreurs.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!