Come creare un'API CRUD con Golang's Gin e MongoDB

Golang è uno dei linguaggi di programmazione più richiesti e più pagati con molte applicazioni. Se abbinato a framework come Gin, Revel e gorilla/mux, puoi creare facilmente un'API con Go.

Scopri come creare un'API CRUD in Golang utilizzando il framework Gin HTTP.

Configurazione e installazione iniziali

Inizia con Golang installandolo sul tuo computer se non l'hai già fatto.

Una volta installato, il passaggio successivo consiste nel creare una cartella principale del progetto sulla macchina e inizializzare un modulo Go in quella directory principale.

Per fare ciò, apri una CLI, vai alla cartella principale del tuo progetto ed esegui:

vai mod init nome_modulo

Vedrai il nome del tuo modulo (ad es. API_CRUD) e la sua versione quando apri il file vai.mod file. Tutti i pacchetti personalizzati proverranno da questo modulo padre. Quindi qualsiasi pacchetto personalizzato importato assume la forma:

importare(pacchetto API_CRUD/pacchetto-nome-directory)

Quindi, installa i pacchetti necessari per creare l'API CRUD. In questo caso, utilizzare Gin Gonic per instradare gli endpoint API:

andare ottenere github.com/gin-gonic/gin

Ora installa il driver MongoDB per archiviare i dati:

andare ottenere go.mongodb.org/mongo-driver/mongo

Come connettersi Vai a MongoDB

Tutto ciò di cui hai bisogno è il tuo URI MongoDB per connettere Golang al database. In genere è simile a questo se ti stai connettendo a MongoDB Atlas localmente:

Mongo_URL = "mongodb://127.0.0.1:27017"

Ora crea una nuova cartella nella directory principale del tuo progetto e chiamala banche dati. Crea un file Go all'interno di questa cartella e assegnagli un nome database.go.

Questo è il tuo pacchetto di database e inizia importando le librerie richieste:

pacchetto Banca dati
importare (
"contesto"
"fmt"
"tronco d'albero"
"volta"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
funz ConnectDB() *mongo. Cliente {
	Mongo_URL := "mongodb://127.0.0.1:27017"
	cliente, err := mongo. Nuovo cliente (opzioni. Cliente().ApplicaURI(Mongo_URL))
se err != zero {
tronco d'albero.Fatale(err)
	}
ctx, annulla := contesto. WithTimeout (contesto. Sfondo(), 10 * tempo. Secondo)
	err = cliente. Connetti (ctx)
	rinviare annullare()
se err != zero {
tronco d'albero.Fatale(err)
	}
fmt. Stampaln("Collegato a mongoDB")
Restituzione cliente
}

È consigliabile nascondere le variabili di ambiente come la stringa di connessione al database in a .env file usando il pacchetto dotenv. Questo rende il tuo codice più portabile ed è utile quando usi a Istanza del cluster cloud MongoDB, Per esempio.

Il ConnectDB La funzione stabilisce una connessione e restituisce un nuovo oggetto client MongoDB.

Crea raccolta di database

MongoDB archivia i dati nelle raccolte, che forniscono un'interfaccia ai dati del database sottostante.

Per gestire la funzionalità di recupero della raccolta, inizia creando una nuova cartella, Collezione, nella radice del tuo progetto. Ora crea un nuovo file Go, getCollection.go, che ottiene la raccolta dal database:

pacchetto getcollection
importare (
"go.mongodb.org/mongo-driver/mongo"
)
funzOttieni Collezione(cliente *mongo.Cliente, collectionNamecorda) *mongo.Collezione {
	raccolta := cliente. Banca dati("myGoappDB").Collezione("Messaggi")
Restituzione collezione
}

Questa funzione ottiene la raccolta dal database MongoDB. Il nome del database, in questo caso, è myGoappDB, insieme a Messaggi come sua collezione.

Crea il modello di database

Crea una nuova cartella all'interno della tua directory principale e chiamala modello. Questa cartella gestisce il tuo modello di database.

Crea un nuovo file Go all'interno di quella cartella e chiamalo modello.go. Il tuo modello, in questo caso, è un post del blog con il suo titolo:

pacchetto modello
importare (
"go.mongodb.org/mongo-driver/bson/primitive"
)
genere Post struttura {
IDprimitivo.IDOggetto
	Stringa del titolo
	Stringa articolo
}

Creazione di un'API CRUD con Go

Il prossimo passo è la creazione dell'API CRUD. Per iniziare con questa sezione, crea una nuova cartella all'interno della directory principale del tuo progetto per gestire i tuoi endpoint. Chiamalo itinerari.

Crea un file Go separato in questa cartella per ogni azione. Ad esempio, puoi nominarli crea.vai, leggi.vai, aggiorna.vai, e elimina.vai. Esporterai questi gestori come file itinerari pacchetto.

Come creare l'endpoint POST in Go

Inizia definendo l'endpoint POST per scrivere i dati nel database.

Dentro percorsi/crea.go, aggiungi quanto segue:

pacchetto itinerari
importare (
	getcollection "CRUD_API/Raccolta"
	Banca dati "CRUD_API/database"
	modello "CRUD_API/modello"
"contesto"
"tronco d'albero"
"rete/http"
"volta"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson/primitive"
)
funz CreaPost(c *gin. Contesto){
var DB = banca dati. ConnettiDB()
	var postCollection = getcollection. GetCollection (DB, "Messaggi")
	ctx, annulla := contesto. WithTimeout (contesto. Sfondo(), 10*tempo. Secondo)
	posta := nuovo(modello. post)
	rinviare annullare()
se erro := c. BindJSON(&inviare); err != zero {
 c. JSON(http. StatusBadRequest, gin. H{"Messaggio": ehm})
tronco d'albero.Fatale(err)
Restituzione
	}
postPayload := modello. Messaggi{
Id: primitivo.NuovoIDOggetto(),
Titolo: inviare.Titolo,
Articolo: inviare.Articolo,
	}
risultato, err := postCollection. InsertOne (ctx, postPayload)
se err != zero {
 c. JSON(http. StatusInternalServerError, gin. H{"Messaggio": ehm})
Restituzione
	}
c. JSON(http. StatusCreated, gin. H{"Messaggio": "Inserito con successo", "Dati": map[string]interfaccia{}{"dati": risultato}})
}

Questo codice inizia importando i moduli personalizzati del progetto. Quindi importa i pacchetti di terze parti inclusi Gin e Driver MongoDB.

Ulteriore, postCollezione detiene la raccolta del database. In particolare, c. BindJSON("post") è un'istanza del modello JSONified che chiama ogni campo del modello come dopo il carico utile; questo va nel database.

Come creare l'endpoint GET

L'endpoint GET, in percorsi/read.go, legge un singolo documento dal database tramite il suo ID univoco. Inizia anche importando pacchetti personalizzati e di terze parti:

pacchetto itinerari
importare (
	getcollection "CRUD_API/Raccolta"
	Banca dati "CRUD_API/database"
	modello "CRUD_API/modello"
"contesto"
"rete/http"
"volta"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
funz Leggi OnePost(c *gin. Contesto){
	ctx, annulla := contesto. WithTimeout (contesto. Sfondo(), 10*tempo. Secondo)
var DB = banca dati. ConnettiDB()
	var postCollection = getcollection. GetCollection (DB, "Messaggi")
ID post := c. Param("postId")
var modello di risultato. Messaggi
rinviare annullare()
objId, _ := primitivo. ObjectIDFromHex (postId)
err := postCollezione. FindOne (ctx, bson. M{"id": objId}).Decode(&risultato)
res := mappa[stringa]interfaccia{}{"data": risultato}
se err != zero {
 c. JSON(http. StatusInternalServerError, gin. H{"Messaggio": ehm})
Restituzione
	}
c. JSON(http. StatusCreated, gin. H{"Messaggio": "successo!", "Dati": ris})
}

Il postId variabile è una dichiarazione di parametro. Ottiene l'ID oggetto di un documento come objId.

Tuttavia, risultato è un'istanza del modello di database, che in seguito conserva il documento restituito come ris.

Come creare l'endpoint PUT

Il gestore PUT, in percorsi/aggiornamento.vai, è simile al gestore POST. Questa volta, aggiorna un post esistente in base al suo ID oggetto univoco:

pacchetto itinerari
importare (
	getcollection "CRUD_API/Raccolta"
	Banca dati "CRUD_API/database"
	modello "CRUD_API/modello"
"contesto"
"rete/http"
"volta"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
funz Aggiorna Post(c *gin. Contesto){
	ctx, annulla := contesto. WithTimeout (contesto. Sfondo(), 10 * tempo. Secondo)
var DB = banca dati. ConnettiDB()
	var postCollection = getcollection. GetCollection (DB, "Messaggi")
ID post := c. Param("postId")
var post modello. Messaggi
rinviare annullare()
objId, _ := primitivo. ObjectIDFromHex (postId)
se erro := c. BindJSON(&inviare); err != zero {
 c. JSON(http. StatusInternalServerError, gin. H{"Messaggio": ehm})
Restituzione
	}
modificato := bson. M{"titolo": inviare. Titolo, "articolo": inviare. Articolo}
risultato, err := postCollection. UpdateOne (ctx, bson. M{"id": objId}, bson. M{"$ impostato": modificato})
res := mappa[stringa]interfaccia{}{"data": risultato}
se err != zero {
 c. JSON(http. StatusInternalServerError, gin. H{"Messaggio": ehm})
Restituzione
	}
se risultato. Conteggio abbinato < 1 {
 c. JSON(http. StatusInternalServerError, gin. H{"Messaggio": "I dati non't esiste"})
Restituzione
	}
c. JSON(http. StatusCreated, gin. H{"Messaggio": "dati aggiornati con successo!", "Dati": ris})
}

Un formato JSON dell'istanza del modello (inviare) richiama ogni campo del modello dal database. La variabile di risultato utilizza MongoDB $ impostato operatore per aggiornare un documento richiesto chiamato dal suo ID oggetto.

Il risultato. Conteggio abbinato condizione impedisce l'esecuzione del codice se non ci sono record nel database o l'ID passato non è valido.

Creazione di un punto finale DELETE

L'endpoint DELETE, in elimina.vai, rimuove un documento in base all'ID oggetto passato come parametro URL:

pacchetto itinerari
importare (
	getcollection "CRUD_API/Raccolta"
	Banca dati "CRUD_API/database"
"contesto"
"rete/http"
"volta"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
funz EliminaPost(c *gin. Contesto){
	ctx, annulla := contesto. WithTimeout (contesto. Sfondo(), 10*tempo. Secondo)
var DB = banca dati. ConnettiDB()
	ID post := c. Param("postId")
var postCollection = getcollection. GetCollection (DB, "Messaggi") 
	rinviare annullare()
	objId, _ := primitivo. ObjectIDFromHex (postId) 
	risultato, err := postCollection. DeleteOne (ctx, bson. M{"id": objId}) 
	res := mappa[stringa]interfaccia{}{"data": risultato}
se err != zero {
 c. JSON(http. StatusInternalServerError, gin. H{"Messaggio": ehm})
Restituzione
	}
se risultato. Conte eliminati < 1 {
 c. JSON(http. StatusInternalServerError, gin. H{"Messaggio": "Nessun dato da eliminare"})
Restituzione
	}
c. JSON(http. StatusCreated, gin. H{"Messaggio": "Articolo cancellato con successo", "Dati": ris})
}

Questo codice elimina un record utilizzando il Elimina Uno funzione. Utilizza anche il risultato. Conte eliminati proprietà per impedire l'esecuzione del codice se il database è vuoto o l'ID oggetto non è valido.

Crea il file Runner dell'API

Infine, crea un main.go all'interno della directory principale del tuo progetto. La struttura del tuo progetto finale dovrebbe assomigliare a questa:

Questo file gestisce l'esecuzione del router per ogni endpoint:

pacchetto principale
importare (
 itinerari "CRUD_API/percorsi"
"github.com/gin-gonic/gin"
)
funz principale(){
 router := gin.Predefinito()
router. INVIARE("/", itinerari. CreaPost)
// chiamato come localhost: 3000/getOne/{id}
 router. OTTENERE("getOne/:postId", itinerari. ReadOnePost)
// chiamato come localhost: 3000/aggiornare/{id}
 router. METTERE("/update/:postId", itinerari. Post di aggiornamento)
// chiamato come localhost: 3000/Elimina/{id}
 router. ELIMINA("/Elimina/:postId", percorsi. EliminaPost)
router. Correre("host locale: 3000")
}

Questo file è il pacchetto principale che esegue altri file. Inizia importando i gestori del percorso. Il prossimo è il router variabile, A Gin istanza che evoca le azioni HTTP e chiama ogni endpoint con il nome della sua funzione da itinerari pacchetto.

Il tuo progetto CRUD continua host locale: 3000. Per eseguire il server e testare l'API CRUD, esegui il seguente comando nella tua directory di base:

andarecorrereprincipale.andare

Trasforma il tuo progetto Golang CRUD in un prodotto utilizzabile

Hai creato con successo un'API CRUD con Go; Congratulazioni! Sebbene questo sia un progetto minore, hai visto cosa serve per eseguire richieste HTTP regolari in Go.

Puoi diventare più creativo espandendolo in un'applicazione più pratica che offre valore agli utenti. Go è un linguaggio di programmazione adatto per una vasta gamma di casi d'uso.