Las operaciones CRUD (crear, leer, actualizar, eliminar) son la funcionalidad básica de cualquier aplicación web a la hora de trabajar con una base de datos. Este ejemplo le mostrará cómo crear la API CRUD con Go y usando MySQL como base de datos.

Requisitos previos

• Ir 1.21
• MySQL

Proyecto de instalación

Configurando las dependencias del proyecto 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

Cree una base de datos de prueba llamada "ejemplo" y ejecute el archivo base de datos.sql para importar la tabla y los datos.

Estructura del proyecto

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

Archivos de proyecto

.env

Este archivo contiene la información de conexión a la base de datos.

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

db.go

Este archivo configura la conexión de la base de datos usando GORM. Declara una variable global DB para contener la instancia de conexión de la base de datos para usarla más adelante en nuestra aplicación.

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
}

enrutador.go

Este archivo configura el enrutamiento para una aplicación web Gin. Inicializa un enrutador, proporciona un archivo index.html estático en la URL raíz y define rutas API para operaciones 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()
}

producto.go

Este archivo define el modelo de Producto para la aplicación. Este modelo se utiliza para operaciones de bases de datos que involucran productos.

package models

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

producto_controller.go

Este archivo define todas las funciones necesarias para manejar las solicitudes entrantes y realizar cualquier operación 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() analiza la carga útil JSON del cuerpo de la solicitud en una estructura Go.

config.DB la instancia de GORM que se utiliza para realizar la operación de base de datos deseada.

c.JSON() envía una respuesta JSON con el resultado de la operación y el código de estado HTTP apropiado.

principal.go

Este archivo es el principal punto de entrada de nuestra aplicación. Creará y configurará la aplicación web Gin.

package main

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

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

índice.html

Este archivo se utilizará para crear una interfaz de usuario básica para probar nuestra API.

    
Example CRUD
    

• Get Products
• Get Product
• Create Product
• Update Product
• Delete Product