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.

---

---

FARE USO DEL VIDEO DEL GIORNO

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:

go mod init module_name 

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:

import(package CRUD_API/package-directory-name)

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

---

---

go get github.com/gin-gonic/gin 

Ora installa il driver MongoDB per archiviare i dati:

go get 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:

package database 
  
import ( 
	"context" 
	"fmt" 
	"log" 
	"time" 
	"go.mongodb.org/mongo-driver/mongo" 
	"go.mongodb.org/mongo-driver/mongo/options" 
) 
  
func ConnectDB() *mongo.Client { 
	Mongo_URL := "mongodb://127.0.0.1:27017" 
	client, err := mongo.NewClient(options.Client().ApplyURI(Mongo_URL)) 
  
	if err != nil { 
		log.Fatal(err) 
	} 
  
	ctx, cancel := context.WithTimeout(context.Background(), 10 * time.Second) 
	err = client.Connect(ctx) 
	defer cancel() 
  
	if err != nil { 
		log.Fatal(err) 
	} 
  
	fmt.Println("Connected to mongoDB") 
	return client 
} 

È 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.

come creare un gioco su roblox

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

cos'è la zona ar sul mio telefono?

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:

package getcollection 
  
import ( 
	"go.mongodb.org/mongo-driver/mongo" 
) 
  
func GetCollection(client *mongo.Client, collectionName string) *mongo.Collection { 
	collection := client.Database("myGoappDB").Collection("Posts") 
	return collection 
} 

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:

package model 
  
import ( 
	"go.mongodb.org/mongo-driver/bson/primitive" 
) 
  
type Post struct { 
	ID      primitive.ObjectID 
	Title   string 
	Article string 
}

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:

package routes 
  
import ( 
	getcollection "CRUD_API/Collection" 
	database "CRUD_API/databases" 
	model "CRUD_API/model" 
	"context" 
	"log" 
	"net/http" 
	"time" 
	"github.com/gin-gonic/gin" 
	"go.mongodb.org/mongo-driver/bson/primitive" 
) 
  
func CreatePost(c *gin.Context) { 
	var DB = database.ConnectDB() 
	var postCollection = getcollection.GetCollection(DB, "Posts") 
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) 
	post := new(model.Posts) 
	defer cancel() 
  
	if err := c.BindJSON(&post); err != nil { 
		c.JSON(http.StatusBadRequest, gin.H{"message": err}) 
		log.Fatal(err) 
		return 
	} 
  
	postPayload := model.Posts{ 
		Id:      primitive.NewObjectID(), 
		Title:   post.Title, 
		Article: post.Article, 
	} 
  
	result, err := postCollection.InsertOne(ctx, postPayload) 
  
	if err != nil { 
		c.JSON(http.StatusInternalServerError, gin.H{"message": err}) 
		return 
	} 
  
	c.JSON(http.StatusCreated, gin.H{"message": "Posted successfully", "Data": map[string]interface{}{"data": result}}) 
} 

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:

package routes 
  
import ( 
	getcollection "CRUD_API/Collection" 
	database "CRUD_API/databases" 
	model "CRUD_API/model" 
	"context" 
	"net/http" 
	"time" 
	"github.com/gin-gonic/gin" 
	"go.mongodb.org/mongo-driver/bson" 
	"go.mongodb.org/mongo-driver/bson/primitive" 
) 
  
func ReadOnePost(c *gin.Context) { 
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) 
	var DB = database.ConnectDB() 
	var postCollection = getcollection.GetCollection(DB, "Posts") 
  
	postId := c.Param("postId") 
	var result model.Posts 
  
	defer cancel() 
  
	objId, _ := primitive.ObjectIDFromHex(postId) 
  
	err := postCollection.FindOne(ctx, bson.M{"id": objId}).Decode(&result) 
  
	res := map[string]interface{}{"data": result} 
  
	if err != nil { 
		c.JSON(http.StatusInternalServerError, gin.H{"message": err}) 
		return 
	} 
  
	c.JSON(http.StatusCreated, gin.H{"message": "success!", "Data": res}) 
} 

Il messaggi 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:

package routes 
  
import ( 
	getcollection "CRUD_API/Collection" 
	database "CRUD_API/databases" 
	model "CRUD_API/model" 
	"context" 
	"net/http" 
	"time" 
	"github.com/gin-gonic/gin" 
	"go.mongodb.org/mongo-driver/bson" 
	"go.mongodb.org/mongo-driver/bson/primitive" 
) 
  
func UpdatePost(c *gin.Context) { 
	ctx, cancel := context.WithTimeout(context.Background(), 10 * time.Second) 
	var DB = database.ConnectDB() 
	var postCollection = getcollection.GetCollection(DB, "Posts") 
  
	postId := c.Param("postId") 
	var post model.Posts 
  
	defer cancel() 
  
	objId, _ := primitive.ObjectIDFromHex(postId) 
  
	if err := c.BindJSON(&post); err != nil { 
		c.JSON(http.StatusInternalServerError, gin.H{"message": err}) 
		return 
	} 
  
	edited := bson.M{"title": post.Title, "article": post.Article} 
  
	result, err := postCollection.UpdateOne(ctx, bson.M{"id": objId}, bson.M{"$set": edited}) 
  
	res := map[string]interface{}{"data": result} 
  
	if err != nil { 
		c.JSON(http.StatusInternalServerError, gin.H{"message": err}) 
		return 
	} 
  
	if result.MatchedCount < 1 { 
		c.JSON(http.StatusInternalServerError, gin.H{"message": "Data doesn't exist"}) 
		return 
	} 
  
	c.JSON(http.StatusCreated, gin.H{"message": "data updated successfully!", "Data": res}) 
} 

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 result.MatchedCount 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:

package routes 
  
import ( 
	getcollection "CRUD_API/Collection" 
	database "CRUD_API/databases" 
	"context" 
	"net/http" 
	"time" 
	"github.com/gin-gonic/gin" 
	"go.mongodb.org/mongo-driver/bson" 
	"go.mongodb.org/mongo-driver/bson/primitive" 
) 
  
func DeletePost(c *gin.Context) { 
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) 
	var DB = database.ConnectDB() 
	postId := c.Param("postId") 
  
	var postCollection = getcollection.GetCollection(DB, "Posts")  
	defer cancel() 
	objId, _ := primitive.ObjectIDFromHex(postId)  
	result, err := postCollection.DeleteOne(ctx, bson.M{"id": objId})  
	res := map[string]interface{}{"data": result} 
  
	if err != nil { 
		c.JSON(http.StatusInternalServerError, gin.H{"message": err}) 
		return 
	} 
  
	if result.DeletedCount < 1 { 
		c.JSON(http.StatusInternalServerError, gin.H{"message": "No data to delete"}) 
		return 
	} 
  
	c.JSON(http.StatusCreated, gin.H{"message": "Article deleted successfully", "Data": res}) 
} 

Questo codice elimina un record utilizzando il Elimina Uno funzione. Utilizza anche il result.DeletedCount 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:

package main 
  
import ( 
    routes "CRUD_API/routes" 
    "github.com/gin-gonic/gin" 
) 
  
func main() { 
    router := gin.Default() 
  
    router.POST("/", routes.CreatePost) 
  
    // called as localhost:3000/getOne/{id} 
    router.GET("getOne/:postId", routes.ReadOnePost) 
  
    // called as localhost:3000/update/{id} 
    router.PUT("/update/:postId", routes.UpdatePost) 
  
    // called as localhost:3000/delete/{id} 
    router.DELETE("/delete/:postId", routes.DeletePost) 
  
    router.Run("localhost: 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:

come cambiare il nome della tua ps4

go run main.go

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.