Interface en tant que modèle dans Mgo (Go) : résolution de l'erreur d'assignabilité

Lorsque vous traitez des flux de travail comprenant des nœuds de différents types, cela peut être Il est tentant d’exploiter les interfaces Golang pour encapsuler leurs divers comportements. Cependant, le stockage de tels flux de travail dans MongoDB pose un défi unique.

Le problème d'assignabilité

L'erreur rencontrée lors de l'opération de recherche provient de l'incompatibilité entre le document décodé et le Interface de nœud. Mgo ne dispose pas des informations de type nécessaires pour déterminer le type spécifique de chaque nœud intégré. Cela entraîne une incompatibilité d'affectation.

Approche alternative : intégration avec des informations de type

Pour surmonter cet obstacle, envisagez d'encapsuler les informations de type dans les nœuds intégrés. Définissez une nouvelle structure, NodeWithType, composée de l'interface Node et d'un champ Type représentant le type spécifique.

type NodeWithType struct {
   Node Node `bson:"-"`
   Type string
}

Démarshaling BSON personnalisé

Pour combler l'écart entre le document décodé et la structure Go, implémentez la fonction SetBSON pour NodeWithType. Cette fonction décodera le champ Type, créera une instance du type correspondant et lui déléguera le démarshaling.

func (nt *NodeWithType) SetBSON(r bson.Raw) error {
   // Decode Type field
   var typeName string
   err := bson.Unmarshal(r["Type"], &typeName)
   if err != nil {
      return err
   }

   // Create an instance of the correct type based on Type field
   var node Node
   switch typeName {
   case "EmailNode":
      node = &EmailNode{}
   case "TwitterNode":
      node = &TwitterNode{}
   }

   // Unmarshal the remaining fields into the created instance
   if err = node.SetBSON(r[typeName]); err != nil {
      return err
   }

   // Assign the created instance to the Node field
   nt.Node = node

   return nil
}

Dans la structure Workflow, remplacez la tranche Node par une tranche de NodeWithType.

type Workflow struct {
   CreatedAt time.Time
   StartedAt time.Time
   CreatedBy string
   Nodes []NodeWithType
}

Grâce à cette approche, Mgo peut désormais trouver et désorganiser avec succès des flux de travail avec des nœuds intégrés de différents types.