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.
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.
├─ .env ├─ main.go ├─ config │ └─ db.go ├─ controllers │ └─ product_controller.go ├─ models │ └─ product.go ├─ public │ └─ index.html └─ router └─ router.go
Diese Datei enthält die Datenbankverbindungsinformationen.
DB_HOST=localhost DB_PORT=3306 DB_DATABASE=example DB_USER=root DB_PASSWORD=
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
}
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()
}
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
}
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.
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()
}
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>
go run main.go
Öffnen Sie den Webbrowser und gehen Sie zu http://localhost:8080
Klicken Sie auf die Schaltfläche „Produkte abrufen“. Die API gibt alle Produktdaten zurück.
Klicken Sie auf die Schaltfläche „Produkt abrufen“ und geben Sie „1“ als Produkt-ID ein. Die API gibt Produktdaten zurück.
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.
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.
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.
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!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
