Comment travailler avec des bases de données NoSQL comme MongoDB à Golang

Installez le pilote MongoDB GO et utilisez Mongo.Connect () pour établir une connexion pour s'assurer que la connexion réussit via Ping; 2. Définissez une structure GO avec la balise BSON pour mapper les documents MongoDB, utilisez éventuellement primitive.Objectid comme type d'ID; 3. Utilisez INSERTOne pour insérer un seul document, FindOne Requête un seul document et gérer les erreurs Mongo.ErrnoDocuments, UpdateOne met à jour le document, DeleteOne supprime le document, Find Coopera avec Cursor.tall pour obtenir plusieurs documents; 4. Utilisez toujours le contexte avec le délai d'expiration pour éviter la demande de demande, réutilisez les instances des clients MongoDB, utilisez BSON.M, BSON.D et BSON.A raisonnablement, créer des index uniques pour les champs de requête courants pour améliorer les performances, et activer TLS et l'authentification dans les environnements de production - l'utilisation de MongoDB dans GO peut obtenir des connexions NOSQL efficaces et maintenables et des opérations de modélisation correcte par des données multiples, des erreurs de contexte, des erreurs de contexte.

Travailler avec des bases de données NoSQL comme MongoDB dans Go (Golang) est simple grâce au Strong Support de MongoDB GO et GO de GO officiel pour la gestion des données basée sur Struct. Voici un guide pratique sur la façon d'intégrer et d'utiliser efficacement MongoDB dans une application Go.

1. Configurez le pilote MongoDB GO

Tout d'abord, installez le pilote officiel de MongoDB GO:

 Allez Get Go.mongodb.org/mongo-driver/mongo
Allez Get Go.mongodb.org/mongo-driver/mongo/options

Ces packages fournissent des outils pour se connecter à MongoDB, exécuter des requêtes et gérer des options telles que la mise en commun des connexions et les délais d'attente.

2. Connectez-vous à MongoDB

Utilisez mongo.Connect() pour établir une connexion. Vous le ferez généralement une fois au démarrage.

 package principal

importer (
    "contexte"
    "FMT"
    "enregistrer"
    "temps"

    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
)

func main () {
    // Définir les options du client
    ClientOptions: = OptionS.Client (). ApplyUri ("MongoDB: // LocalHost: 27017")

    // Connectez-vous à MongoDB
    Client, err: = Mongo.Connect (context.todo (), clientoPtions)
    Si err! = Nil {
        log.fatal (err)
    }

    // Vérifiez la connexion
    ctx, annuler: = context.withtimeout (context.background (), 10 * time.second)
    Déférer annuler ()

    err = client.ping (ctx, nil)
    Si err! = Nil {
        Log.fatal ("Échec de Ping MongoDB:", ERR)
    }

    fmt.println ("connecté à MongoDB!")

    // utilise le client pour les opérations
    Collection: = Client.Database ("MyDB"). Collection ("utilisateurs")

    // insérer, requête, etc. allez ici

    // Déconnectez-vous une fois terminé (généralement différé dans les applications réelles)
    si err = client.disconnect (ctx); err! = Nil {
        log.fatal (err)
    }
}

Astuce : En production, stockez le client à l'échelle mondiale ou injectez-le par injection de dépendance. Ne vous reconnectez pas pour chaque demande.

3. Définir les modèles de données à l'aide de structures

GO utilise des structures pour mapper sur des documents mongoDB. Utilisez des balises bson pour contrôler comment les champs sont sérialisés.

 Tapez user struct {
    ID String `bson:" _ id, omitempty "`
    Nom String `BSON:" Name "`
    Chaîne de messagerie `bson:" e-mail "`
    Âge int `bson:" âge "`
    Bool actif `bson:" actif, omitempty ""
}

• La balise bson explique au conducteur comment mapper les champs de structure aux clés de document MongoDB.
• _id avec omitempty permet à MongoDB de générer automatiquement un objetId s'il n'est pas fourni.
• Utilisez primitive.ObjectID de go.mongodb.org/mongo-driver/bson/primitive si vous voulez des ID typés.

Exemple avec ObjectId:

 Importer "go.mongodb.org/mongo-driver/bson/primitive"

Tapez user struct {
    Id primitive.objectid `bson:" _ id, omitempty "`
    Nom String `BSON:" Name "`
    Chaîne de messagerie `bson:" e-mail "`
}

4. Effectuer des opérations CRUD

Insérer un document

 utilisateur: = utilisateur {
    Nom: "Alice",
    Courriel: "Alice@example.com",
    Âge: 30 ans,
}

Résultat, err: = collection.insertOne (context.todo (), utilisateur)
Si err! = Nil {
    log.fatal (err)
}

fmt.printf ("document inséré avec id:% v \ n", result.insertEDID)

Trouver un document

 Var FoundUser utilisateur
Filtre: = BSON.M {"Courriel": "Alice@example.com"}

err = Collection.FindOne (context.todo (), filtre) .decode (& FoundUser)
Si err! = Nil {
    Si err == Mongo.errnodocuments {
        fmt.println ("aucun document trouvé")
    } autre {
        log.fatal (err)
    }
} autre {
    fmt.printf ("Found:% v \ n", FoundUser)
}

Mettre à jour un document

 Mise à jour: = bson.m {"$ set": bson.m {"age": 31}}
Résultat, err: = collection.updateOne (context.todo (), filtre, mise à jour)
Si err! = Nil {
    log.fatal (err)
}
fmt.printf ("Modified% v documents \ n", result.modifiedCount)

Supprimer un document

 Résultat, err: = collection.deleteOne (context.todo (), filtre)
Si err! = Nil {
    log.fatal (err)
}
fmt.printf ("Document (s) \ n" supprimé% V

Trouver plusieurs documents

 curseur, err: = collection.find (context.todo (), bson.m {"age": bson.m {"$ gt": 25}})
Si err! = Nil {
    log.fatal (err)
}
déférer curseur.close (context.todo ())

Var utilisateurs [] utilisateur
si err = cursor.all (context.todo (), & utilisateurs); err! = Nil {
    log.fatal (err)
}

pour _, u: = gamme utilisateurs {
    fmt.printf ("% v \ n", u)
}

5. Gérer correctement les erreurs et le contexte

Utilisez toujours le contexte avec les délais d'attente pour éviter les opérations suspendues:

 ctx, annuler: = context.withtimeout (context.background (), 5 * time.second)
Déférer annuler ()

err = collection.findOne (ctx, filtre) .decode (& user)

Vérifiez explicitement mongo.ErrNoDocuments lorsque vous recherchez des documents uniques.

6. Utiliser les index pour les performances

Vous pouvez créer des index programmaticalement:

 indexModel: = Mongo.IndexModel {
    Touches: bson.d {{"e-mail", 1}},
    Options: OptionS.Index (). SetUnique (true),
}

_, err: = collection.indexes (). createOne (context.todo (), indexmodel)
Si err! = Nil {
    log.fatal (err)
}

7. meilleures pratiques

• Réutilisez le client : le pilote MongoDB GO est en file d'attente. Créez un client au démarrage et réutilisez-le.
• Utilisez BSON.M, BSON.D, BSON.A :
  • bson.M - carte non ordonnée
  • bson.D - Document commandé (utile pour les opérations où la commande est importante)
  • bson.A - tableau
• Valider l'entrée avant l'insertion.
• Utilisez la journalisation structurée et surveillez les requêtes lentes.
• Activer TLS et authentification dans la production.

Travailler avec MongoDB dans GO est naturel en raison de la frappe forte de Go et de l'API propre du conducteur. Avec une modélisation de structure appropriée et une gestion de contexte, vous pouvez créer des applications évolutives et maintenables qui exploitent la flexibilité de Nosql.

Fondamentalement, connectez-vous une fois, modélisez vos données, utilisez des structures avec des balises BSON et appliquez des modèles CRUD standard - il n'est pas complexe, mais facile de se tromper sans attention au contexte et à la 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!