Como criar uma API CRUD com Gin e MongoDB de Golang

Golang é uma das linguagens de programação mais bem pagas e sob demanda com muitos aplicativos. Quando emparelhado com estruturas como Gin, Revel e gorilla/mux, você pode criar facilmente uma API com Go.

Saiba como criar uma API CRUD em Golang usando a estrutura Gin HTTP.

Configuração e instalação iniciais

Comece com Golang instalando-o no seu computador, caso ainda não o tenha feito.

Uma vez instalado, o próximo passo é criar uma pasta raiz do projeto em sua máquina e inicializar um módulo Go nesse diretório raiz.

Para isso, abra uma CLI, navegue até a pasta raiz do seu projeto e execute:

vá mod init module_name

Você verá o nome do seu módulo (por exemplo, CRUD_API) e sua versão ao abrir o go.mod Arquivo. Todos os pacotes personalizados virão deste módulo pai. Portanto, qualquer pacote personalizado importado assume o formato:

importar(pacote CRUD_API/pacote-nome-diretório)

Em seguida, instale os pacotes necessários para criar a API CRUD. Neste caso, use Gin Gônica para rotear os endpoints da API:

instagram viewer

vai pegue github.com/gin-gonic/gin

Agora instale o Driver MongoDB para armazenar dados:

vai pegue go.mongodb.org/mongo-driver/mongo

Como conectar-se ao MongoDB

Tudo o que você precisa é do seu URI do MongoDB para conectar o Golang ao banco de dados. Normalmente se parece com isso se você estiver se conectando ao MongoDB Atlas localmente:

Mongo_URL = "mongodb://127.0.0.1:27017"

Agora crie uma nova pasta no diretório raiz do seu projeto e chame-a bancos de dados. Crie um arquivo Go dentro desta pasta e nomeie-o banco de dados.go.

Este é o seu pacote de banco de dados e começa importando as bibliotecas necessárias:

pacote base de dadosimportar (
"contexto"
"fmt"
"registro"
"Tempo"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
função ConnectDB() *mongo. Cliente {
	Mongo_URL := "mongodb://127.0.0.1:27017"
	cliente, err := mongo. NovoCliente (opções. Client().ApplyURI(Mongo_URL))
se errar != nil {
registro.Fatal(errar)
	}
ctx, cancel := context. WithTimeout (context. Background(), 10 * tempo. Segundo)
	erro = cliente. Conectar (ctx)
	adiar cancelar()
se errar != nil {
registro.Fatal(errar)
	}fmt. Imprimirln("Conectado ao mongoDB")
Retorna cliente
}

É uma prática recomendada ocultar variáveis de ambiente como a string de conexão do banco de dados em um .env Arquivo usando o pacote dotenv. Isso torna seu código mais portátil e é útil ao usar um Instância de cluster de nuvem MongoDB, por exemplo.

o ConnectDB A função estabelece uma conexão e retorna um novo objeto MongoDB Client.

Criar coleção de banco de dados

O MongoDB armazena dados em Collections, que fornecem uma interface para os dados subjacentes do banco de dados.

Para lidar com a funcionalidade de busca de coleção, comece criando uma nova pasta, Coleção, na raiz do seu projeto. Agora crie um novo arquivo Go, getCollection.go, que obtém a coleção do banco de dados:

pacote getcollectionimportar (
"go.mongodb.org/mongo-driver/mongo"
)funçãoGetCollection(cliente *mongo.Cliente, nome da coleçãocorda) *mongo.Coleção {
	coleção := cliente. Base de dados("myGoappDB").Coleção("Postagens")
Retorna coleção
}

Esta função obtém a coleção do banco de dados MongoDB. O nome do banco de dados, neste caso, é myGoappDB, com Postagens como sua coleção.

Criar o modelo de banco de dados

Crie uma nova pasta dentro do seu diretório raiz e chame-a modelo. Esta pasta lida com seu modelo de banco de dados.

Crie um novo arquivo Go dentro dessa pasta e chame-o model.go. Seu modelo, neste caso, é uma postagem de blog com o título:

pacote modeloimportar ( "go.mongodb.org/mongo-driver/bson/primitive" )

modelo Estrutura de postagem { EU IRIAprimitivo.ObjectID Cadeia de título Sequência do artigo }

Criando uma API CRUD com Go

Em seguida é a criação da API CRUD. Para começar com esta seção, crie uma nova pasta dentro do diretório raiz do projeto para lidar com seus endpoints. Chame-o rotas.

Crie um arquivo Go separado nesta pasta para cada ação. Por exemplo, você pode nomeá-los criar.go, leia.go, update.go, e delete.go. Você exportará esses manipuladores como o rotas pacote.

Como criar o endpoint POST em Go

Comece definindo o endpoint POST para gravar dados no banco de dados.

Lado de dentro rotas/criar.go, adicione o seguinte:

pacote rotasimportar (
	getcollection "CRUD_API/Coleção"
	base de dados "CRUD_API/bancos de dados"
	modelo "CRUD_API/modelo"
"contexto"
"registro"
"net/http"
"Tempo"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson/primitive"
)
função Criar postagem(c*gin. Contexto){
var DB = banco de dados. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Postagens")
	ctx, cancel := context. WithTimeout (context. Background(), 10*tempo. Segundo)
	postar := novo(modelo. Postagens)
	adiar cancelar()
se errar := c. BindJSON(&publicar); err!= nil {
 c. JSON(http. StatusBadRequest, gin. H{"mensagem": err})
registro.Fatal(errar)
Retorna
	}
postPayload := model. Postagens{
Identidade: primitivo.NewObjectID(),
Título: publicar.Título,
Artigo: publicar.Artigo,
	}
resultado, err := postCollection. InsertOne (ctx, postPayload)
se errar != nil {
 c. JSON(http. StatusInternalServerError, gin. H{"mensagem": err})
Retorna
	}c. JSON(http. StatusCriado, gin. H{"mensagem": "Postado com sucesso", "Dados": map[string]interface{}{"dados": resultado}})
}

Esse código começa importando os módulos personalizados do projeto. Em seguida, ele importa pacotes de terceiros, incluindo Gin e Driver MongoDB.

Mais longe, postColeção mantém a coleção de banco de dados. Notavelmente, c. BindJSON("postar") é uma instância de modelo JSONified que chama cada campo de modelo como postPayload; isso vai para o banco de dados.

Como criar o ponto de extremidade GET

O endpoint GET, em rotas/read.go, lê um único documento do banco de dados por meio de seu ID exclusivo. Ele também começa importando pacotes personalizados e de terceiros:

pacote rotasimportar (
	getcollection "CRUD_API/Coleção"
	base de dados "CRUD_API/bancos de dados"
	modelo "CRUD_API/modelo"
"contexto"
"net/http"
"Tempo"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
função ReadOnePost(c*gin. Contexto){
	ctx, cancel := context. WithTimeout (context. Background(), 10*tempo. Segundo)
var DB = banco de dados. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Postagens")
postId := c. Param("postId")
var modelo de resultado. Postagens
adiar cancelar()
objId, _ := primitivo. ObjectIDFromHex (postId)
err := postCollection. FindOne (ctx, bson. M{"Eu iria": objId}).Decodificar(&resultado)
res := mapa[string]interface{}{"dados": resultado}
se errar != nil {
 c. JSON(http. StatusInternalServerError, gin. H{"mensagem": err})
Retorna
	}c. JSON(http. StatusCriado, gin. H{"mensagem": "sucesso!", "Dados": res})
}

o postId variável é uma declaração de parâmetro. Ele obtém o ID do objeto de um documento como objId.

No entanto, resultado é uma instância do modelo de banco de dados, que posteriormente contém o documento retornado como res.

Como criar o ponto de extremidade PUT

O manipulador PUT, em rotas/atualização.go, é semelhante ao manipulador POST. Desta vez, ele atualiza uma postagem existente por seu ID de objeto exclusivo:

pacote rotasimportar (
	getcollection "CRUD_API/Coleção"
	base de dados "CRUD_API/bancos de dados"
	modelo "CRUD_API/modelo"
"contexto"
"net/http"
"Tempo"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
função Atualizar postagem(c*gin. Contexto){
	ctx, cancel := context. WithTimeout (context. Background(), 10 * tempo. Segundo)
var DB = banco de dados. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Postagens")
postId := c. Param("postId")
var pós modelo. Postagens
adiar cancelar()
objId, _ := primitivo. ObjectIDFromHex (postId)
se errar := c. BindJSON(&publicar); err!= nil {
 c. JSON(http. StatusInternalServerError, gin. H{"mensagem": err})
Retorna
	}
editado := bson. M{"título": publicar. Título, "artigo": publicar. Artigo}
resultado, err := postCollection. UpdateOne (ctx, bson. M{"Eu iria": objId}, bson. M{"$set": editado})
res := mapa[string]interface{}{"dados": resultado}
se errar != nil {
 c. JSON(http. StatusInternalServerError, gin. H{"mensagem": err})
Retorna
	}
se resultado. MatchedCount < 1 {
 c. JSON(http. StatusInternalServerError, gin. H{"mensagem": "Dados não'não existe"})
Retorna
	}c. JSON(http. StatusCriado, gin. H{"mensagem": "dados atualizados com sucesso!", "Dados": res})
}

Um formato JSON da instância do modelo (publicar) chama cada campo de modelo do banco de dados. A variável de resultado usa o MongoDB $set operador para atualizar um documento necessário chamado por seu ID de objeto.

o resultado. MatchedCount condição impede que o código seja executado se não houver registro no banco de dados ou o ID passado for inválido.

Criando um ponto de extremidade DELETE

O ponto de extremidade DELETE, em delete.go, remove um documento com base no ID do objeto passado como parâmetro de URL:

pacote rotasimportar (
	getcollection "CRUD_API/Coleção"
	base de dados "CRUD_API/bancos de dados"
"contexto"
"net/http"
"Tempo"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
função Apague a postagem(c*gin. Contexto){
	ctx, cancel := context. WithTimeout (context. Background(), 10*tempo. Segundo)
var DB = banco de dados. ConnectDB()
	postId := c. Param("postId")
var postCollection = getcollection. GetCollection (DB, "Postagens") 
	adiar cancelar()
	objId, _ := primitivo. ObjectIDFromHex (postId) 
	resultado, err := postCollection. DeleteOne (ctx, bson. M{"Eu iria": objId}) 
	res := mapa[string]interface{}{"dados": resultado}
se errar != nil {
 c. JSON(http. StatusInternalServerError, gin. H{"mensagem": err})
Retorna
	}
se resultado. Contagem excluída < 1 {
 c. JSON(http. StatusInternalServerError, gin. H{"mensagem": "Nenhum dado para excluir"})
Retorna
	}c. JSON(http. StatusCriado, gin. H{"mensagem": "Artigo excluído com sucesso", "Dados": res})
}

Este código exclui um registro usando o Excluir um função. Também utiliza o resultado. Contagem excluída para impedir que o código seja executado se o banco de dados estiver vazio ou o ID do objeto for inválido.

Crie o arquivo do executor da API

Por fim, crie um main.go dentro do diretório raiz do seu projeto. A estrutura final do seu projeto deve ficar assim:

Este arquivo trata da execução do roteador para cada endpoint:

pacote a Principalimportar (
 rotas "CRUD_API/rotas"
"github.com/gin-gonic/gin"
)
função a Principal(){
 roteador := gin.Predefinição()
roteador. PUBLICAR("/", rotas. Criar postagem)
// chamado como localhost: 3000/getOne/{id}
 roteador. PEGUE("getOne/:postId", rotas. ReadOnePost)
// chamado como localhost: 3000/atualizar/{Eu iria}
 roteador. COLOCAR("/update/:postId", rotas. Atualização de postagem)
// chamado como localhost: 3000/excluir/{Eu iria}
 roteador. EXCLUIR("/excluir/:postId", rotas. Apague a postagem)roteador. Corre("localhost: 3000")
}

Este arquivo é o pacote principal que executa outros arquivos. Ele começa importando os manipuladores de rota. A seguir é o roteador variável, um Gin instância que evoca as ações HTTP e chama cada endpoint por seu nome de função do rotas pacote.

Seu projeto CRUD é executado em localhost: 3000. Para executar o servidor e testar a API CRUD, execute o seguinte comando em seu diretório base:

vaicorrea Principal.vai

Transforme seu projeto Golang CRUD em um produto utilizável

Você criou com sucesso uma API CRUD com Go; Parabéns! Embora este seja um projeto menor, você viu o que é necessário para executar solicitações HTTP regulares em Go.

Você pode ser mais criativo expandindo isso para um aplicativo mais prático que agrega valor aos usuários. Go é uma linguagem de programação adequada para uma variedade de casos de uso.

About Technology - denizatm.com