Go et MongoDB : créer une API CRUD à partir de zéro-Golang-php.cn

Go and MongoDB: Building a CRUD API from Scratch

Vous souhaitez créer une application Web dynamique avec un backend robuste ? Ne cherchez pas plus loin que Go et MongoDB ! Cette combinaison puissante vous permet de créer des API évolutives et efficaces qui gèrent facilement la création, la lecture, la mise à jour et la suppression (CRUD) de données.

Dans ce guide convivial pour les débutants, nous expliquerons le processus de création d'une API CRUD simple à l'aide de Go et MongoDB. Nous couvrirons les étapes essentielles, fournirons des exemples de code et parsèmerons de conseils utiles en cours de route.

Commencer

Tout d'abord, configurons notre environnement :

Installation de Go : Téléchargez et installez la dernière version de Go depuis https://go.dev/dl/.
Configuration de MongoDB : Si MongoDB n'est pas en cours d'exécution, vous pouvez le télécharger et l'installer à partir de https://www.mongodb.com/try/download/community.
IDE ou éditeur de texte : Choisissez votre environnement de codage préféré. Certaines options populaires incluent VS Code, GoLand ou Atom.

Structure du projet :

Créez un nouveau répertoire de projet et organisez vos fichiers comme ceci :

my-crud-api/
├── main.go
├── models/
│   └── user.go
├── handlers/
│   └── user.go
└── config/
    └── config.go

Copier après la connexion

Définir notre modèle

Commençons par définir notre modèle de données. Pour cet exemple, nous allons créer une simple structure User :

// models/user.go
package models

import (
    "go.mongodb.org/mongo-driver/bson/primitive"
)

type User struct {
    ID     primitive.ObjectID `bson:"_id,omitempty"`
    Name   string             `bson:"name,omitempty"`
    Email  string             `bson:"email,omitempty"`
    Age    int                `bson:"age,omitempty"`
    Active bool               `bson:"active,omitempty"`
}

Copier après la connexion

Explication :

Nous utilisons primitive.ObjectID du package mongo-driver pour représenter l'ID unique du document MongoDB.
Les balises bson sont cruciales pour mapper nos champs de structure Go aux champs correspondants dans nos documents MongoDB.

Connexion à MongoDB

Nous devons établir une connexion à notre base de données MongoDB. Créez un fichier config.go dans le répertoire config :

// config/config.go
package config

import (
    "context"
    "fmt"
    "os"

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

func ConnectToMongoDB() (*mongo.Client, error) {
    uri := os.Getenv("MONGODB_URI")
    if uri == "" {
        return nil, fmt.Errorf("MONGODB_URI is not set")
    }

    clientOptions := options.Client().ApplyURI(uri)
    client, err := mongo.Connect(context.Background(), clientOptions)
    if err != nil {
        return nil, err
    }

    err = client.Ping(context.Background(), nil)
    if err != nil {
        return nil, err
    }

    return client, nil
}

Copier après la connexion

Explication :

Nous utilisons os.Getenv pour récupérer l'URI de connexion MongoDB à partir de la variable d'environnement MONGODB_URI. Assurez-vous de définir cette variable dans votre environnement.
Nous utilisons le package mongo-driver pour nous connecter à la base de données MongoDB et effectuer des opérations de base comme envoyer un ping à la base de données.

Gestionnaires de bâtiments

Maintenant, construisons les gestionnaires d'API pour nos opérations CRUD. Dans le répertoire des gestionnaires, créez un fichier user.go :

// handlers/user.go
package handlers

import (
    "context"
    "encoding/json"
    "fmt"
    "net/http"

    "github.com/your-username/my-crud-api/config"
    "github.com/your-username/my-crud-api/models"
    "go.mongodb.org/mongo-driver/bson"
    "go.mongodb.org/mongo-driver/bson/primitive"
    "go.mongodb.org/mongo-driver/mongo"
)

// Create a new user
func CreateUser(w http.ResponseWriter, r *http.Request) {
    client, err := config.ConnectToMongoDB()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer client.Disconnect(context.Background())

    var user models.User
    if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    collection := client.Database("your_database_name").Collection("users")
    result, err := collection.InsertOne(context.Background(), user)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    json.NewEncoder(w).Encode(result)
}

// Get all users
func GetAllUsers(w http.ResponseWriter, r *http.Request) {
    client, err := config.ConnectToMongoDB()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer client.Disconnect(context.Background())

    collection := client.Database("your_database_name").Collection("users")
    cursor, err := collection.Find(context.Background(), bson.D{})
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer cursor.Close(context.Background())

    var users []models.User
    for cursor.Next(context.Background()) {
        var user models.User
        if err := cursor.Decode(&user); err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }
        users = append(users, user)
    }

    json.NewEncoder(w).Encode(users)
}

// Get a user by ID
func GetUserByID(w http.ResponseWriter, r *http.Request) {
    client, err := config.ConnectToMongoDB()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer client.Disconnect(context.Background())

    id, err := primitive.ObjectIDFromHex(r.URL.Query().Get("id"))
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    collection := client.Database("your_database_name").Collection("users")
    var user models.User
    if err := collection.FindOne(context.Background(), bson.M{"_id": id}).Decode(&user); err != nil {
        http.Error(w, err.Error(), http.StatusNotFound)
        return
    }

    json.NewEncoder(w).Encode(user)
}

// Update a user
func UpdateUser(w http.ResponseWriter, r *http.Request) {
    client, err := config.ConnectToMongoDB()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer client.Disconnect(context.Background())

    id, err := primitive.ObjectIDFromHex(r.URL.Query().Get("id"))
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    var updatedUser models.User
    if err := json.NewDecoder(r.Body).Decode(&updatedUser); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    collection := client.Database("your_database_name").Collection("users")
    filter := bson.M{"_id": id}
    update := bson.M{"$set": updatedUser}
    result, err := collection.UpdateOne(context.Background(), filter, update)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    json.NewEncoder(w).Encode(result)
}

// Delete a user
func DeleteUser(w http.ResponseWriter, r *http.Request) {
    client, err := config.ConnectToMongoDB()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer client.Disconnect(context.Background())

    id, err := primitive.ObjectIDFromHex(r.URL.Query().Get("id"))
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    collection := client.Database("your_database_name").Collection("users")
    result, err := collection.DeleteOne(context.Background(), bson.M{"_id": id})
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    json.NewEncoder(w).Encode(result)
}

Copier après la connexion

Explication :

Nous implémentons les opérations CRUD : CreateUser, GetAllUsers, GetUserByID, UpdateUser et DeleteUser.
Chaque fonction se connecte à MongoDB, récupère la collection, effectue l'opération respective et renvoie une réponse JSON.
Nous traitons les erreurs potentielles et renvoyons les codes d'état HTTP appropriés.

Configuration de l'application principale

Enfin, lions le tout ensemble dans notre fichier main.go :

// main.go
package main

import (
    "fmt"
    "log"
    "net/http"

    "github.com/your-username/my-crud-api/handlers"
)

func main() {
    http.HandleFunc("/users", handlers.CreateUser)
    http.HandleFunc("/users", handlers.GetAllUsers)
    http.HandleFunc("/users/", handlers.GetUserByID)
    http.HandleFunc("/users/", handlers.UpdateUser)
    http.HandleFunc("/users/", handlers.DeleteUser)

    fmt.Println("Server running on port 8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Copier après la connexion

Explication :

Nous enregistrons les gestionnaires d'API avec les points de terminaison HTTP correspondants.
On démarre le serveur et on écoute sur le port 8080.

Exécuter l'API

Variable d'environnement : Définissez la variable d'environnement MONGODB_URI avec votre chaîne de connexion MongoDB.
Construire et exécuter : Créez l'application Go à l'aide de go build, puis exécutez-la à l'aide de ./my-crud-api.

Tester l'API

Vous pouvez tester votre API à l'aide d'outils comme Postman ou curl.

Créer : Envoyez une requête POST à /users avec une charge utile JSON contenant les détails de l'utilisateur.
Lire : Envoyez une requête GET à /users pour récupérer tous les utilisateurs ou à /users/?id={user_id} pour obtenir un utilisateur spécifique.
Mise à jour : Envoyez une requête PUT à /users/?id={user_id} avec une charge utile JSON contenant les détails de l'utilisateur mis à jour.
Supprimer : Envoyez une demande DELETE à /users/?id={user_id} pour supprimer un utilisateur.

Conseils pour réussir

Gestion des erreurs : Gérez toujours les erreurs potentielles et renvoyez des codes d'état HTTP significatifs.
Sécurité : Mettez en œuvre des mécanismes d'authentification et d'autorisation appropriés pour votre API.
Conception de base de données : Concevez votre schéma de base de données de manière réfléchie pour optimiser les performances et l'évolutivité.
Documentation : Documentez vos points de terminaison d'API, les formats de requête/réponse et les codes d'erreur.

Félicitations ! Vous avez réussi à créer une API CRUD de base à l'aide de Go et MongoDB. Avec cette base, vous pouvez étendre votre API pour gérer des fonctionnalités plus complexes et créer des applications Web impressionnantes. Continuez à apprendre et à explorer les possibilités infinies de Go et MongoDB !

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!