Développement d'une API RESTful simple avec Gin, ginvalidator et validatorgo

Ce tutoriel vous guide dans la création d'une API RESTful de base à l'aide de Go, du framework Gin et des bibliothèques open source ginvalidator et validatorgo. Ces bibliothèques simplifient la validation des entrées, rendant votre API plus robuste.

Nous allons créer une API pour gérer l'inventaire des produits. L'API prendra en charge la création, la lecture, la mise à jour et la suppression de produits. Pour plus de simplicité, les données seront stockées en mémoire (pas dans une base de données persistante). Cela signifie que les données sont perdues au redémarrage du serveur. Vous pouvez utiliser des outils comme Postman ou Insomnia pour tester l'API.

Conception des points de terminaison de l'API :

L'API aura les points de terminaison suivants :

• /products :
  • GET : Récupère une liste JSON de tous les produits.
  • POST : Ajoute un nouveau produit (charge utile JSON requise).
• /products/:id :
  • GET : Récupère un seul produit par ID (réponse JSON).
  • PUT : met à jour un produit par ID (charge utile JSON requise).
  • DELETE : Supprime un produit par ID.

Mise en œuvre du code :

1. Dépendances : Installez les packages nécessaires : gin-gonic/gin, bube054/ginvalidator et bube054/validatorgo.

2. Structures de données : Définissez des structures pour représenter les données du produit :

<code class="language-go">package main

import (
    "time"
)

type Dimensions struct {
    Length float64 `json:"length"`
    Width  float64 `json:"width"`
    Height float64 `json:"height"`
    Weight float64 `json:"weight"`
}

type Supplier struct {
    Name    string `json:"name"`
    Contact string `json:"contact"`
    Address string `json:"address"`
}

type Product struct {
    ID             string     `json:"id"`
    Name           string     `json:"name"`
    Category       string     `json:"category"`
    Description    string     `json:"description"`
    Price          float64    `json:"price"`
    Stock          int        `json:"stock"`
    Dimensions     Dimensions `json:"dimensions"`
    Supplier       Supplier   `json:"supplier"`
    Tags           []string   `json:"tags"`
    Image          string     `json:"image"`
    ManufacturedAt time.Time  `json:"manufacturedAt"`
    CreatedAt      time.Time  `json:"createdAt"`
    UpdatedAt      time.Time  `json:"updatedAt"`
}</code>

3. Données en mémoire : Initialisez une tranche pour contenir les données du produit :

<code class="language-go">var products = []Product{
    // ... (Initial product data as in the original example) ...
}</code>

4. Middleware de validation : Créez des fonctions middleware pour valider les paramètres de requête et les corps de requête à l'aide de ginvalidator :

<code class="language-go">func productQueriesValidators() gin.HandlersChain {
    return gin.HandlersChain{
        gv.NewQuery("q", nil).Chain().Optional().Trim(" ").Not().Empty(nil).Validate(),
        gv.NewQuery("order", nil).Chain().Optional().Trim(" ").In([]string{"asc", "desc"}).Validate(),
    }
}

func productParamIdValidators() gin.HandlersChain {
    return gin.HandlersChain{gv.NewParam("id", nil).Chain().Trim(" ").Alphanumeric(nil).Validate()}
}

func productBodyValidators() gin.HandlersChain {
    // ... (Validation rules as in the original example) ...
}</code>

5. Gestionnaires API : Implémentez des gestionnaires Gin pour chaque point de terminaison, incorporant un middleware de validation :

<code class="language-go">func getProducts(c *gin.Context) {
    // ... (Handler logic as in the original example) ...
}

func getProduct(c *gin.Context) {
    // ... (Handler logic as in the original example) ...
}

func deleteProduct(c *gin.Context) {
    // ... (Handler logic as in the original example) ...
}

func postProduct(c *gin.Context) {
    // ... (Handler logic as in the original example) ...
}

func putProducts(c *gin.Context) {
    // ... (Handler logic as in the original example) ...
}</code>

6. Enregistrement des routes : Enregistrez les routes API dans la fonction main :

<code class="language-go">func main() {
    router := gin.Default()
    router.GET("/products", append(productQueriesValidators(), getProducts)...)
    router.GET("/products/:id", append(productParamIdValidators(), getProduct)...)
    router.DELETE("/products/:id", append(productParamIdValidators(), deleteProduct)...)
    router.POST("/products", append(productBodyValidators(), postProduct)...)
    router.PUT("/products/:id", append(append(productParamIdValidators(), productBodyValidators()...), putProducts)...)
    router.Run(":8080")
}</code>

Le code complet et mis à jour (y compris les parties omises des étapes 3, 4 et 5) est identique à la section « Code complet » de l'exemple d'origine. N'oubliez pas de remplacer les commentaires // ... par le code fourni dans la réponse d'origine. Cette explication révisée clarifie les étapes et rend le processus plus facile à suivre.

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!