Entwicklung einer einfachen RESTful-API mit Gin, Ginvalidator und Validatorgo

Dieses Tutorial führt Sie durch die Erstellung einer grundlegenden RESTful-API mit Go, dem Gin-Framework und den Open-Source-Bibliotheken ginvalidator und validatorgo. Diese Bibliotheken vereinfachen die Eingabevalidierung und machen Ihre API robuster.

Wir erstellen eine API zur Verwaltung des Produktinventars. Die API unterstützt das Erstellen, Lesen, Aktualisieren und Löschen von Produkten. Der Einfachheit halber werden die Daten im Speicher gespeichert (keine persistente Datenbank). Dies bedeutet, dass beim Neustart des Servers Daten verloren gehen. Sie können Tools wie Postman oder Insomnia verwenden, um die API zu testen.

API-Endpunktdesign:

Die API verfügt über die folgenden Endpunkte:

• /products:
  • GET: Ruft eine JSON-Liste aller Produkte ab.
  • POST: Fügt ein neues Produkt hinzu (JSON-Nutzlast erforderlich).
• /products/:id:
  • GET: Ruft ein einzelnes Produkt nach ID ab (JSON-Antwort).
  • PUT: Aktualisiert ein Produkt nach ID (JSON-Nutzlast erforderlich).
  • DELETE: Löscht ein Produkt nach ID.

Code-Implementierung:

1. Abhängigkeiten: Installieren Sie die erforderlichen Pakete: gin-gonic/gin, bube054/ginvalidator und bube054/validatorgo.

2. Datenstrukturen: Definieren Sie Strukturen zur Darstellung von Produktdaten:

<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. In-Memory-Daten:Initialisieren Sie ein Segment, um Produktdaten zu speichern:

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

4. Validierungs-Middleware: Erstellen Sie Middleware-Funktionen zur Validierung von Abfrageparametern und Anforderungstexten mit 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. API-Handler: Implementieren Sie Gin-Handler für jeden Endpunkt und integrieren Sie Validierungs-Middleware:

<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. Routenregistrierung: Registrieren Sie API-Routen in der Funktion 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>

Der vollständige, aktualisierte Code (einschließlich der ausgelassenen Teile aus den Schritten 3, 4 und 5) ist identisch mit dem Abschnitt „Vollständiger Code“ des Originalbeispiels. Denken Sie daran, die // ...-Kommentare durch den in der ursprünglichen Antwort bereitgestellten Code zu ersetzen. Diese überarbeitete Erklärung verdeutlicht die Schritte und erleichtert die Befolgung des Prozesses.

Das obige ist der detaillierte Inhalt vonEntwicklung einer einfachen RESTful-API mit Gin, Ginvalidator und Validatorgo. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!