Créez une API CRUD avec Go

Les opérations CRUD (créer, lire, mettre à jour, supprimer) sont la fonctionnalité de base de toute application Web lorsque vous travaillez avec une base de données. Cet exemple vous montrera comment créer l'API CRUD avec Go et en utilisant MySQL comme base de données.

Conditions préalables

• Allez 1.21
• MySQL

Projet d'installation

Configuration des dépendances du projet Go.

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

Créez une base de données de test nommée « exemple » et exécutez le fichier database.sql pour importer la table et les données.

Structure du projet

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

Fichiers de projet

.env

Ce fichier contient les informations de connexion à la base de données.

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

db.go

Ce fichier configure la connexion à la base de données à l'aide de GORM. Il déclare une variable globale DB pour contenir l'instance de connexion à la base de données à utiliser plus tard dans notre application.

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
}

routeur.go

Ce fichier configure le routage pour une application Web Gin. Il initialise un routeur, sert un fichier index.html statique à l'URL racine, définit les routes API pour les opérations CRUD.

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()
}

produit.go

Ce fichier définit le modèle de produit pour l'application. Ce modèle est utilisé pour les opérations de base de données impliquant des produits.

package models

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

product_controller.go

Ce fichier définit toutes les fonctions requises pour gérer les demandes entrantes et effectuer toutes les opérations CRUD.

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() analyse la charge utile JSON du corps de la requête dans une structure Go.

config.DB l'instance GORM utilisée pour effectuer l'opération de base de données souhaitée.

c.JSON() envoie une réponse JSON avec le résultat de l'opération et le code d'état HTTP approprié.

main.go

Ce fichier est le point d'entrée principal de notre application. Il créera et configurera l'application web Gin.

package main

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

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

index.html

Ce fichier sera utilisé pour créer une interface utilisateur de base pour tester notre API.

<!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>

• De nombreux autres articles utiliseront Postman comme client HTTP pour tester l'API, mais dans cet article, j'utiliserai JavaScript à la place. Cela vous aidera à comprendre plus de détails lorsque vous travaillez avec une requête HTTP côté client.
• Pour que ce fichier reste propre et lisible, nous n'utiliserons que du HTML et du JavaScript de base. Il n'y a pas de bibliothèques supplémentaires telles que CSS Framework ou Axios ici.
• Toutes les fonctions CRUD utiliseront la méthode HTTP appropriée pour appeler l'API.
• showResponse(res) formatera l'objet JSON pour le rendre plus facile à lire.

Exécuter le projet

go run main.go

Ouvrez le navigateur Web et accédez à http://localhost:8080

Essai

Obtenez tous les produits

Cliquez sur le bouton « Obtenir des produits ». L'API renverra toutes les données des produits.

Obtenir le produit par identifiant

Cliquez sur le bouton « Obtenir le produit » et saisissez « 1 » pour l'identifiant du produit. L'API renverra des données de produit.

Créer un produit

Cliquez sur le bouton « Créer un produit » et saisissez « tester-créer » pour le nom du produit et « 100 » pour le prix. L'API renverra un produit nouvellement créé.

Mettre à jour le produit

Cliquez sur le bouton « Mettre à jour le produit » et entrez « 101 » pour l'identifiant du produit et « test-update » pour le nom et « 200 » pour le prix. L'API renverra un produit mis à jour.

Supprimer le produit

Cliquez sur le bouton « Supprimer le produit » et saisissez « 101 » pour l'identifiant du produit. L'API ne renverra rien, ce qui est acceptable car nous ne renvoyons rien de notre API.

Conclusion

Dans cet article, vous avez appris comment créer et configurer le framework Gin afin de créer une API CRUD. Utilisez GORM comme ORM pour effectuer les opérations CRUD sur la base de données. Testez notre API en utilisant JavaScript. J'espère que vous apprécierez l'article.

Code source : https://github.com/StackPuz/Example-CRUD-Go

Créez une application Web CRUD : https://stackpuz.com

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!