Jak vytvořit CRUD API s Golang's Gin a MongoDB

Golang je jedním z nejlépe platících programovacích jazyků s mnoha aplikacemi. Při spárování s frameworky jako Gin, Revel a gorilla/mux můžete snadno vytvořit API s Go.

Naučte se, jak vytvořit CRUD API v Golangu pomocí Gin HTTP frameworku.

Počáteční nastavení a instalace

Začněte s Golangem instalací do počítače, pokud jste tak ještě neučinili.

Po instalaci je dalším krokem vytvoření kořenové složky projektu na vašem počítači a inicializace modulu Go v tomto kořenovém adresáři.

Chcete-li to provést, otevřete CLI, přejděte do kořenové složky projektu a spusťte:

go mod init module_name

Uvidíte název modulu (např. CRUD_API) a jeho verzi, když otevřete soubor go.mod soubor. Všechny vlastní balíčky pocházejí z tohoto nadřazeného modulu. Jakýkoli importovaný vlastní balíček má tedy podobu:

import(balík CRUD_API/balík-název-adresáře)

Dále nainstalujte balíčky potřebné pro vytvoření CRUD API. V tomto případě použijte Gin Gonic pro směrování koncových bodů API:

jít dostat github.com/gin-gonic/gin

Nyní nainstalujte ovladač MongoDB pro ukládání dat:

jít dostat go.mongodb.org/mongo-driver/mongo

Jak se připojit Přejděte na MongoDB

Vše, co potřebujete, je vaše MongoDB URI pro připojení Golangu k databázi. Obvykle to vypadá takto, pokud se připojujete k MongoDB Atlas lokálně:

Mongo_URL = "mongodb://127.0.0.1:27017"

Nyní vytvořte novou složku v kořenovém adresáři projektu a zavolejte ji databází. V této složce vytvořte soubor Go a pojmenujte jej databáze.go.

Toto je váš databázový balíček a začíná importem požadovaných knihoven:

balík databáze
import (
"kontext"
"fmt"
"log"
"čas"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
func ConnectDB() *mongo. Klient {
	Mongo_URL := "mongodb://127.0.0.1:27017"
	klient, chyba := mongo. Nový klient (možnosti. Client().ApplyURI(Mongo_URL))
if err != nula {
log.Osudný(chybovat)
	}
ctx, cancel := kontext. WithTimeout (kontext. Pozadí(), 10 * čas. Druhý)
	chyba = klient. Připojit (ctx)
	odložit zrušení()
if err != nula {
log.Osudný(chybovat)
	}
fmt. Println("Připojeno k mongoDB")
vrátit se klienta
}

Nejlepším postupem je skrýt proměnné prostředí, jako je připojovací řetězec databáze v a .env soubor pomocí balíčku dotenv. Díky tomu je váš kód přenosnější a hodí se při použití a Instance cloudového clusteru MongoDB, například.

The ConnectDB funkce naváže připojení a vrátí nový objekt MongoDB Client.

Vytvořit kolekci databáze

MongoDB ukládá data do kolekcí, které poskytují rozhraní k podkladovým databázovým datům.

Chcete-li zvládnout funkci načítání kolekce, začněte vytvořením nové složky, Sbírka, v kořenovém adresáři vašeho projektu. Nyní vytvořte nový soubor Go, getCollection.go, který získá kolekci z databáze:

balík getcollection
import (
"go.mongodb.org/mongo-driver/mongo"
)
funcGetCollection(klienta *mongo.Klient, název sbírkytětiva) *mongo.Sbírka {
	kolekce := klient. Databáze("myGoappDB").Sbírka("Příspěvky")
vrátit se sbírka
}

Tato funkce získá kolekci z databáze MongoDB. Název databáze je v tomto případě myGoappDB, s Příspěvky jako jeho sbírka.

Vytvořte databázový model

Vytvořte novou složku v kořenovém adresáři a zavolejte ji Modelka. Tato složka zpracovává váš databázový model.

Vytvořte v této složce nový soubor Go a zavolejte jej model.go. Váš model je v tomto případě blogový příspěvek s názvem:

balík Modelka
import (
"go.mongodb.org/mongo-driver/bson/primitive"
)
typ Struktura příspěvku {
IDprimitivní.ObjectID
	Řetězec názvu
	Řetězec článku
}

Vytvoření CRUD API s Go

Další na řadě je vytvoření CRUD API. Chcete-li začít s touto částí, vytvořte v kořenovém adresáři projektu novou složku, která bude spravovat vaše koncové body. Zavolej tomu trasy.

Pro každou akci vytvořte v této složce samostatný soubor Go. Můžete je například pojmenovat create.go, read.go, update.go, a delete.go. Tyto obslužné nástroje exportujete jako trasy balík.

Jak vytvořit koncový bod POST v Go

Začněte definováním koncového bodu POST pro zápis dat do databáze.

Uvnitř routes/create.go, přidejte následující:

balík trasy
import (
	getcollection "CRUD_API/kolekce"
	databáze "CRUD_API/databází"
	Modelka "CRUD_API/model"
"kontext"
"log"
"net/http"
"čas"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson/primitive"
)
func Vytvořit příspěvek(c *gin. Kontext){
var DB = databáze. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Příspěvky")
	ctx, cancel := kontext. WithTimeout (kontext. Pozadí(), 10*krát. Druhý)
	příspěvek := Nový(Modelka. příspěvky)
	odložit zrušení()
pokud chyba := c. BindJSON(&pošta); chyba != nula {
 C. JSON(http. StatusBadRequest, gin. H{"zpráva": err})
log.Osudný(chybovat)
vrátit se
	}
postPayload := model. příspěvky{
Id: primitivní.NewObjectID(),
Titul: pošta.Titul,
Článek: pošta.Článek,
	}
výsledek, err := postCollection. InsertOne (ctx, postPayload)
if err != nula {
 C. JSON(http. StatusInternalServerError, gin. H{"zpráva": err})
vrátit se
	}
C. JSON(http. StatusCreated, gin. H{"zpráva": "Úspěšně odesláno", "Data": map[string]rozhraní{}{"data": výsledek}})
}

Tento kód začíná importem vlastních modulů projektu. Poté importuje balíčky třetích stran včetně Gin a Ovladač MongoDB.

Dále, postCollection uchovává kolekci databáze. Zejména, C. BindJSON("příspěvek") je instance modelu JSONified, která nazývá každé pole modelu jako postPayload; to jde do databáze.

Jak vytvořit koncový bod GET

Koncový bod GET, in routes/read.go, čte jeden dokument z databáze prostřednictvím jeho jedinečného ID. Začíná to také importem vlastních balíčků a balíčků třetích stran:

balík trasy
import (
	getcollection "CRUD_API/kolekce"
	databáze "CRUD_API/databází"
	Modelka "CRUD_API/model"
"kontext"
"net/http"
"čas"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
func ReadOnePost(c *gin. Kontext){
	ctx, cancel := kontext. WithTimeout (kontext. Pozadí(), 10*krát. Druhý)
var DB = databáze. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Příspěvky")
postId := c. Param("postId")
var výsledkový model. Příspěvky
odložit zrušení()
objId, _ := primitivní. ObjectIDFromHex (postId)
err := postCollection. FindOne (ctx, bson. M{"id": objId}).Decode(&výsledek)
res := mapa[řetězec]rozhraní{}{"data": výsledek}
if err != nula {
 C. JSON(http. StatusInternalServerError, gin. H{"zpráva": err})
vrátit se
	}
C. JSON(http. StatusCreated, gin. H{"zpráva": "úspěch!", "Data": res})
}

The postId proměnná je deklarace parametru. Získá ID objektu dokumentu jako objId.

Nicméně, výsledek je instancí databázového modelu, který později obsahuje vrácený dokument jako res.

Jak vytvořit koncový bod PUT

Obslužný program PUT, in routes/update.go, je podobný obslužné rutině POST. Tentokrát aktualizuje existující příspěvek jeho jedinečným ID objektu:

balík trasy
import (
	getcollection "CRUD_API/kolekce"
	databáze "CRUD_API/databází"
	Modelka "CRUD_API/model"
"kontext"
"net/http"
"čas"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
func UpdatePost(c *gin. Kontext){
	ctx, cancel := kontext. WithTimeout (kontext. Pozadí(), 10 * čas. Druhý)
var DB = databáze. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Příspěvky")
postId := c. Param("postId")
var post model. Příspěvky
odložit zrušení()
objId, _ := primitivní. ObjectIDFromHex (postId)
pokud chyba := c. BindJSON(&pošta); chyba != nula {
 C. JSON(http. StatusInternalServerError, gin. H{"zpráva": err})
vrátit se
	}
upraveno := bson. M{"titul": pošta. Titul, "článek": pošta. Článek}
výsledek, err := postCollection. UpdateOne (ctx, bson. M{"id": objId}, bson. M{"$set": upraveno})
res := mapa[řetězec]rozhraní{}{"data": výsledek}
if err != nula {
 C. JSON(http. StatusInternalServerError, gin. H{"zpráva": err})
vrátit se
	}
pokud výsledek. MatchedCount < 1 {
 C. JSON(http. StatusInternalServerError, gin. H{"zpráva": "Data ne't existovat"})
vrátit se
	}
C. JSON(http. StatusCreated, gin. H{"zpráva": "data úspěšně aktualizována!", "Data": res})
}

Formát JSON instance modelu (pošta) volá každé pole modelu z databáze. Proměnná result používá MongoDB $set k aktualizaci požadovaného dokumentu volaného jeho ID objektu.

The výsledek. MatchedCount podmínka zabrání spuštění kódu, pokud v databázi není žádný záznam nebo je předané ID neplatné.

Vytvoření koncového bodu DELETE

Koncový bod DELETE, in delete.go, odstraní dokument na základě ID objektu předaného jako parametr adresy URL:

balík trasy
import (
	getcollection "CRUD_API/kolekce"
	databáze "CRUD_API/databází"
"kontext"
"net/http"
"čas"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
func Smazat příspěvek(c *gin. Kontext){
	ctx, cancel := kontext. WithTimeout (kontext. Pozadí(), 10*krát. Druhý)
var DB = databáze. ConnectDB()
	postId := c. Param("postId")
var postCollection = getcollection. GetCollection (DB, "Příspěvky") 
	odložit zrušení()
	objId, _ := primitivní. ObjectIDFromHex (postId) 
	výsledek, err := postCollection. DeleteOne (ctx, bson. M{"id": objId}) 
	res := mapa[řetězec]rozhraní{}{"data": výsledek}
if err != nula {
 C. JSON(http. StatusInternalServerError, gin. H{"zpráva": err})
vrátit se
	}
pokud výsledek. DeletedCount < 1 {
 C. JSON(http. StatusInternalServerError, gin. H{"zpráva": "Žádná data ke smazání"})
vrátit se
	}
C. JSON(http. StatusCreated, gin. H{"zpráva": "Článek byl úspěšně smazán", "Data": res})
}

Tento kód odstraní záznam pomocí DeleteOne funkce. Používá také výsledek. DeletedCount vlastnost, která zabrání spuštění kódu, pokud je databáze prázdná nebo ID objektu je neplatné.

Vytvořte soubor API Runner

Nakonec vytvořte a main.go v kořenovém adresáři vašeho projektu. Konečná struktura vašeho projektu by měla vypadat takto:

Tento soubor zpracovává spuštění routeru pro každý koncový bod:

balík hlavní
import (
 trasy "CRUD_API/trasy"
"github.com/gin-gonic/gin"
)
func hlavní(){
 router := gin.Výchozí()
router. POŠTA("/", trasy. Vytvořit příspěvek)
// voláno jako localhost: 3000/getOne/{id}
 router. DOSTAT("getOne/:postId", trasy. ReadOnePost)
// voláno jako localhost: 3000/Aktualizace/{id}
 router. DÁT("/update/:postId", trasy. UpdatePost)
// voláno jako localhost: 3000/vymazat/{id}
 router. VYMAZAT("/vymazat/:postId", trasy. Smazat příspěvek)
router. Běh("localhost: 3000")
}

Tento soubor je hlavním balíčkem, který spouští další soubory. Začíná to importem obslužných rutin tras. Další je router proměnná, a gin instance, která vyvolává akce HTTP a volá každý koncový bod podle názvu funkce z trasy balík.

Váš projekt CRUD běží dál localhost: 3000. Chcete-li spustit server a otestujte CRUD API, spusťte ve svém základním adresáři následující příkaz:

jítběhhlavní.jít

Proměňte svůj projekt Golang CRUD na použitelný produkt

Úspěšně jste vytvořili CRUD API s Go; Gratulujeme! I když se jedná o menší projekt, viděli jste, co je potřeba k provádění běžných požadavků HTTP v Go.

Můžete být kreativnější, když to rozšíříte do praktičtější aplikace, která uživatelům přináší hodnotu. Go je vhodný programovací jazyk pro řadu případů použití.