Erstellen Sie eine CRUD-API mit Go

Die CRUD-Operationen (Erstellen, Lesen, Aktualisieren, Löschen) sind die Grundfunktionen jeder Webanwendung bei der Arbeit mit einer Datenbank. Dieses Beispiel zeigt Ihnen, wie Sie die CRUD-API mit Go erstellen und MySQL als Datenbank verwenden.

Voraussetzungen

• Gehen Sie 1,21
• MySQL

Setup-Projekt

Einrichten der Go-Projektabhängigkeiten.

go mod init app
go get github.com/gin-gonic/gin
go get gorm.io/gorm
go get gorm.io/driver/mysql
go get github.com/joho/godotenv

Erstellen Sie eine Testdatenbank mit dem Namen „example“ und führen Sie die Datei „database.sql“ aus, um die Tabelle und die Daten zu importieren.

Projektstruktur

├─ .env
├─ main.go
├─ config
│  └─ db.go
├─ controllers
│  └─ product_controller.go
├─ models
│  └─ product.go
├─ public
│  └─ index.html
└─ router
   └─ router.go

Projektdateien

.env

Diese Datei enthält die Datenbankverbindungsinformationen.

DB_HOST=localhost
DB_PORT=3306
DB_DATABASE=example
DB_USER=root
DB_PASSWORD=

db.go

Diese Datei richtet die Datenbankverbindung mithilfe von GORM ein. Es deklariert eine globale Variable DB, um die Datenbankverbindungsinstanz zur späteren Verwendung in unserer Anwendung zu speichern.

package config

import (
    "fmt"
    "os"

    "github.com/joho/godotenv"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
    "gorm.io/gorm/schema"
)

var DB *gorm.DB

func SetupDatabase() {
    godotenv.Load()
    connection := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=true", os.Getenv("DB_USER"), os.Getenv("DB_PASSWORD"), os.Getenv("DB_HOST"), os.Getenv("DB_PORT"), os.Getenv("DB_DATABASE"))
    db, _ := gorm.Open(mysql.Open(connection), &gorm.Config{NamingStrategy: schema.NamingStrategy{SingularTable: true}})
    DB = db
}

router.go

Diese Datei richtet das Routing für eine Gin-Webanwendung ein. Es initialisiert einen Router, stellt eine statische index.html-Datei an der Stamm-URL bereit und definiert API-Routen für CRUD-Vorgänge.

package router

import (
    "app/controllers"

    "github.com/gin-gonic/gin"
)

func SetupRouter() {
    productController := controllers.ProductController{}
    router := gin.Default()
    router.StaticFile("/", "./public/index.html")
    router.Group("/api").
        GET("/products", productController.Index).
        POST("/products", productController.Create).
        GET("/products/:id", productController.Get).
        PUT("/products/:id", productController.Update).
        DELETE("/products/:id", productController.Delete)
    router.Run()
}

Produkt.go

Diese Datei definiert das Produktmodell für die Anwendung. Dieses Modell wird für Datenbankoperationen mit Produkten verwendet.

package models

type Product struct {
    Id int `gorm:"primaryKey;autoIncrement"`
    Name string
    Price float64
}

product_controller.go

Diese Datei definiert alle Funktionen, die zur Bearbeitung eingehender Anfragen und zur Durchführung aller CRUD-Operationen erforderlich sind.

package controllers

import (
    "app/config"
    "app/models"
    "net/http"
    "strconv"

    "github.com/gin-gonic/gin"
)

type ProductController struct {
}

func (con *ProductController) Index(c *gin.Context) {
    var products []models.Product
    config.DB.Find(&products)
    c.JSON(http.StatusOK, products)
}

func (con *ProductController) Get(c *gin.Context) {
    var product models.Product
    config.DB.First(&product, c.Params.ByName("id"))
    c.JSON(http.StatusOK, product)
}

func (con *ProductController) Create(c *gin.Context) {
    var product models.Product
    c.BindJSON(&product)
    if err := config.DB.Create(&product).Error; err != nil {
        c.AbortWithError(http.StatusBadRequest, err)
        return
    }
    c.JSON(http.StatusOK, product)
}

func (con *ProductController) Update(c *gin.Context) {
    var product models.Product
    c.BindJSON(&product)
    product.Id, _ = strconv.Atoi(c.Params.ByName("id"))
    if err := config.DB.Updates(&product).Error; err != nil {
        c.AbortWithError(http.StatusBadRequest, err)
        return
    }
    c.JSON(http.StatusOK, product)
}

func (con *ProductController) Delete(c *gin.Context) {
    var product models.Product
    if err := config.DB.Delete(&product, c.Params.ByName("id")).Error; err != nil {
        c.AbortWithError(http.StatusBadRequest, err)
        return
    }
    c.Status(http.StatusOK)
}

c.BindJSON() analysiert die JSON-Nutzlast aus dem Anforderungstext in eine Go-Struktur.

config.DB die GORM-Instanz, die zum Ausführen der gewünschten Datenbankoperation verwendet wird.

c.JSON() sendet eine JSON-Antwort mit dem Ergebnis der Operation und dem entsprechenden HTTP-Statuscode.

main.go

Diese Datei ist der Haupteinstiegspunkt unserer Anwendung. Es wird die Gin-Webanwendung erstellt und eingerichtet.

package main

import (
    "app/config"
    "app/router"
)

func main() {
    config.SetupDatabase()
    router.SetupRouter()
}

index.html

Diese Datei wird verwendet, um eine grundlegende Benutzeroberfläche zum Testen unserer API zu erstellen.

<!DOCTYPE html>
<head>
    <style>
        li {
            margin-bottom: 5px;
        }
        textarea {
            width: 100%;
        }
    </style>
</head>
<body>
    <h1>Example CRUD</h1>
    <ul>
        <li><button onclick="getProducts()">Get Products</button></li>
        <li><button onclick="getProduct()">Get Product</button></li>
        <li><button onclick="createProduct()">Create Product</button></li>
        <li><button onclick="updateProduct()">Update Product</button></li>
        <li><button onclick="deleteProduct()">Delete Product</button></li>
    </ul>
    <textarea id="text_response" rows="20"></textarea>
    <script>
        function showResponse(res) {
            res.text().then(text => {
                let contentType = res.headers.get('content-type')
                if (contentType && contentType.startsWith('application/json')) {
                    text = JSON.stringify(JSON.parse(text), null, 4)
                }
                document.getElementById('text_response').innerHTML = text
            })
        }
        function getProducts() {
            fetch('/api/products').then(showResponse)
        }
        function getProduct() {
            let id = prompt('Input product id')
            fetch('/api/products/' + id).then(showResponse)
        }
        function createProduct() {
            let name = prompt('Input product name')
            let price = parseFloat(prompt('Input product price'))
            fetch('/api/products', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({ name, price })
            }).then(showResponse)
        }
        function updateProduct() {
            let id = parseInt(prompt('Input product id to update'))
            let name = prompt('Input new product name')
            let price = parseFloat(prompt('Input new product price'))
            fetch('/api/products/' + id, {
                method: 'PUT',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({ name, price })
            }).then(showResponse)
        }
        function deleteProduct() {
            let id = prompt('Input product id to delete')
            fetch('/api/products/' + id, {
                method: 'DELETE'
            }).then(showResponse)
        }
    </script>
</body>
</html>

• Viele andere Artikel verwenden Postman als HTTP-Client zum Testen der API, aber in diesem Artikel verwende ich stattdessen JavaScript. Dies wird Ihnen helfen, mehr Details zu verstehen, wenn Sie mit HTTP-Anfragen auf der Clientseite arbeiten.
• Damit diese Datei sauber und lesbar bleibt, verwenden wir nur einfaches HTML und JavaScript. Es gibt hier keine zusätzlichen Bibliotheken wie das CSS Framework oder Axios.
• Alle CRUD-Funktionen verwenden die entsprechende HTTP-Methode, um die API aufzurufen.
• showResponse(res) formatiert das JSON-Objekt, um es leichter lesbar zu machen.

Projekt ausführen

go run main.go

Öffnen Sie den Webbrowser und gehen Sie zu http://localhost:8080

Testen

Holen Sie sich alle Produkte

Klicken Sie auf die Schaltfläche „Produkte abrufen“. Die API gibt alle Produktdaten zurück.

Produkt nach ID abrufen

Klicken Sie auf die Schaltfläche „Produkt abrufen“ und geben Sie „1“ als Produkt-ID ein. Die API gibt Produktdaten zurück.

Produkt erstellen

Klicken Sie auf die Schaltfläche „Produkt erstellen“ und geben Sie „test-create“ als Produktnamen und „100“ als Preis ein. Die API gibt ein neu erstelltes Produkt zurück.

Produkt aktualisieren

Klicken Sie auf die Schaltfläche „Produkt aktualisieren“ und geben Sie „101“ für die Produkt-ID und „test-update“ für den Namen und „200“ für den Preis ein. Die API gibt ein aktualisiertes Produkt zurück.

Produkt löschen

Klicken Sie auf die Schaltfläche „Produkt löschen“ und geben Sie „101“ als Produkt-ID ein. Die API gibt nichts zurück, was akzeptabel ist, da wir von unserer API nichts zurückgeben.

Abschluss

In diesem Artikel haben Sie gelernt, wie Sie das Gin-Framework erstellen und einrichten, um eine CRUD-API zu erstellen. Nutzen Sie GORM als ORM, um die CRUD-Operationen in der Datenbank auszuführen. Testen Sie unsere API mit JavaScript. Ich hoffe, dass Ihnen der Artikel gefällt.

Quellcode: https://github.com/StackPuz/Example-CRUD-Go

Erstellen Sie eine CRUD-Web-App: https://stackpuz.com

Das obige ist der detaillierte Inhalt vonErstellen Sie eine CRUD-API mit Go. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!