As operações CRUD (criar, ler, atualizar, excluir) são a funcionalidade básica de qualquer aplicação web ao trabalhar com um banco de dados. Este exemplo mostrará como criar a API CRUD com Go e usando MySQL como banco de dados.

Pré-requisitos

• Vá para 1.21
• MySQL

Projeto de configuração

Configurando as dependências do projeto 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

Crie um banco de dados de teste chamado "exemplo" e execute o arquivo database.sql para importar a tabela e os dados.

Estrutura do projeto

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

Arquivos de projeto

.env

Este arquivo contém as informações de conexão do banco de dados.

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

db.go

Este arquivo configura a conexão do banco de dados usando GORM. Ele declara uma variável global DB para armazenar a instância de conexão do banco de dados para usar posteriormente em nosso aplicativo.

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
}

roteador.go

Este arquivo configura o roteamento para um aplicativo da web Gin. Ele inicializa um roteador, fornece um arquivo index.html estático na URL raiz, define rotas de API para operações 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()
}

produto.go

Este arquivo define o modelo de Produto para a aplicação. Este modelo é usado para operações de banco de dados envolvendo produtos.

package models

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

product_controller.go

Este arquivo define todas as funções necessárias para lidar com solicitações recebidas e executar quaisquer operações 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() analisa a carga JSON do corpo da solicitação em uma estrutura Go.

config.DB a instância GORM usada para executar a operação de banco de dados desejada.

c.JSON() envia uma resposta JSON com o resultado da operação e o código de status HTTP apropriado.

principal.go

Este arquivo é o principal ponto de entrada da nossa aplicação. Ele criará e configurará o aplicativo web Gin.

package main

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

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

index.html

Este arquivo será usado para criar uma interface de usuário básica para testar nossa API.

    
Example CRUD
    

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