A Golang az egyik legjobban fizető, igényes programozási nyelv számos alkalmazással. Ha olyan keretrendszerekkel párosítja, mint a Gin, a Revel és a gorilla/mux, könnyen létrehozhat API-t a Go segítségével.

Ismerje meg, hogyan hozhat létre CRUD API-t a Golangban a Gin HTTP keretrendszer használatával.

Kezdeti beállítás és telepítés

Kezdje el a Golangot telepítse a számítógépére, ha még nem tette meg.

A telepítés után a következő lépés egy projekt gyökérmappája létrehozása a gépen, és a Go modul inicializálása abban a gyökérkönyvtárban.

Ehhez nyissa meg egy CLI, keresse meg a projekt gyökérmappáját, és futtassa:

go mod init modul_name

Látni fogja a modul nevét (pl. CRUD_API) és annak verziója, amikor megnyitja a go.mod fájlt. Minden egyéni csomag ebből a szülőmodulból származik. Tehát minden importált egyedi csomag a következő formában van:

import(csomag CRUD_API/csomag-könyvtárnév)

Ezután telepítse a CRUD API létrehozásához szükséges csomagokat. Ebben az esetben használja Gin Gonic az API-végpontok irányításához:

instagram viewer 
megy kap github.com/gin-gonic/gin

Most telepítse a MongoDB illesztőprogramot az adatok tárolására:

megy kap go.mongodb.org/mongo-driver/mongo

Csatlakozás Ugrás a MongoDB-hez

Csak a MongoDB URI-ra van szüksége a Golang és az adatbázis összekapcsolásához. Általában így néz ki, ha helyileg csatlakozik a MongoDB Atlashoz:

Mongo_URL = "mongodb://127.0.0.1:27017"

Most hozzon létre egy új mappát a projekt gyökérkönyvtárában, és hívja meg adatbázisok. Hozzon létre egy Go fájlt ebben a mappában, és nevezze el adatbázis.go.

Ez az Ön adatbáziscsomagja, és a szükséges könyvtárak importálásával kezdődik:

csomag adatbázis
import (
"kontextus"
"fmt"
"log"
"idő"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)


func ConnectDB() *mongó. Ügyfél {
	Mongo_URL := "mongodb://127.0.0.1:27017"
	kliens, err := mongo. NewClient (opciók. Ügyfél().ApplyURI(Mongo_URL))


if err != nil {
log.Halálos(téved)
	}


ctx, cancel := kontextus. WithTimeout (kontextus. Háttér(), 10 * idő. Második)
	err = ügyfél. Csatlakozás (ctx)
	defer cancel()


if err != nil {
log.Halálos(téved)
	}
fmt. Println("Csatlakozva a mongoDB-hez")
Visszatérés ügyfél
}

A legjobb gyakorlat a környezeti változók, például az adatbázis-kapcsolati karakterlánc elrejtése a .env fájlt dotenv csomag használatával. Ez a kódot hordozhatóbbá teszi, és hasznos lehet a MongoDB felhőfürt példány, például.

Az ConnectDB függvény kapcsolatot létesít, és egy új MongoDB Client objektumot ad vissza.

Adatbázis-gyűjtemény létrehozása

A MongoDB gyűjteményekben tárolja az adatokat, amelyek interfészt biztosítanak az alapul szolgáló adatbázisadatokhoz.

A gyűjtemény-lekérési funkció kezeléséhez először hozzon létre egy új mappát, Gyűjtemény, a projekt gyökérben. Most hozzon létre egy új Go fájlt, getCollection.go, amely megkapja a gyűjteményt az adatbázisból:

csomag kap gyűjteményt
import (
"go.mongodb.org/mongo-driver/mongo"
)
funcGetCollection(ügyfél *mongó.Ügyfél, gyűjteményNévhúr) *mongó.Gyűjtemény {
	gyűjtemény := kliens. adatbázis("myGoappDB").Gyűjtemény("Hozzászólások")
Visszatérés Gyűjtemény
}

Ez a függvény a gyűjteményt a MongoDB adatbázisból szerzi be. Az adatbázis neve ebben az esetben az myGoappDB, val vel Hozzászólások mint gyűjteménye.

Készítse el az adatbázis-modellt

Hozzon létre egy új mappát a gyökérkönyvtárban, és hívja meg modell. Ez a mappa kezeli az adatbázis-modellt.

Hozzon létre egy új Go fájlt a mappában, és hívja meg model.go. Ebben az esetben az Ön modellje egy blogbejegyzés a következő címmel:

csomag modell
import (
"go.mongodb.org/mongo-driver/bson/primitive"
)
típus Post struct {
IDprimitív.ObjectID
	Cím karakterlánc
	Cikk karakterlánc
}

CRUD API létrehozása a Go segítségével

A következő lépés a CRUD API létrehozása. Ezzel a szakaszsal kezdésként hozzon létre egy új mappát a projekt gyökérkönyvtárában a végpontok kezelésére. Hívd útvonalak.

Minden egyes művelethez hozzon létre egy külön Go fájlt ebben a mappában. Például elnevezheti őket Create.go, read.go, update.go, és delete.go. Ezeket a kezelőket a következő néven fogja exportálni útvonalak csomag.

A POST végpont létrehozása a Go alkalmazásban

Kezdje a POST végpont meghatározásával az adatok adatbázisba való írásához.

Belül routes/create.go, adja hozzá a következőket:

csomag útvonalak
import (
	kap gyűjteményt "CRUD_API/Gyűjtemény"
	adatbázis "CRUD_API/adatbázisok"
	modell "CRUD_API/modell"
"kontextus"
"log"
"net/http"
"idő"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson/primitive"
)


func CreatePost(c *gin. Kontextus){
var DB = adatbázis. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Hozzászólások")
	ctx, cancel := kontextus. WithTimeout (kontextus. Háttér(), 10*idő. Második)
	hozzászólás := új(modell. bejegyzések)
	defer cancel()


ha hiba := c. BindJSON(&posta); hiba != nil {
 c. JSON(http. StatusBadRequest, gin. H{"üzenet": hiba})
log.Halálos(téved)
Visszatérés
	}


postPayload := modell. Bejegyzések{
Id: primitív.NewObjectID(),
Cím: hozzászólás.Cím,
Cikk: hozzászólás.Cikk,
	}


eredmény, err := postCollection. InsertOne (ctx, postPayload)


if err != nil {
 c. JSON(http. StatusInternalServerError, gin. H{"üzenet": hiba})
Visszatérés
	}
c. JSON(http. ÁllapotCreated, gin. H{"üzenet": "Sikeresen elküldve", "Adat": térkép[karakterlánc]interfész{}{"adat": eredmény}})
}

Ez a kód a projekt egyéni moduljainak importálásával kezdődik. Ezután harmadik féltől származó csomagokat importál, beleértve Gin és MongoDB illesztőprogram.

További, postCollection tárolja az adatbázis gyűjteményt. Nevezetesen, c. BindJSON("bejegyzés") egy JSON-modellpéldány, amely minden modellmezőt a következő néven hív meg postPayload; ez bekerül az adatbázisba.

A GET végpont létrehozása

A GET végpont, in routes/read.go, egyetlen dokumentumot olvas be az adatbázisból annak egyedi azonosítóján keresztül. Egyéni és harmadik féltől származó csomagok importálásával is kezdődik:

csomag útvonalak
import (
	kap gyűjteményt "CRUD_API/Gyűjtemény"
	adatbázis "CRUD_API/adatbázisok"
	modell "CRUD_API/modell"
"kontextus"
"net/http"
"idő"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)


func ReadOnePost(c *gin. Kontextus){
	ctx, cancel := kontextus. WithTimeout (kontextus. Háttér(), 10*idő. Második)
var DB = adatbázis. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Hozzászólások")


postId := c. Param("postId")
var eredmény modell. Hozzászólások


defer cancel()


objId, _ := primitív. ObjectIDFromHex (postId)


err := postCollection. FindOne (ctx, bson. M{"id": objId}).Decode(&eredmény)


res := térkép[karakterlánc]felület{}{"data": eredmény}


if err != nil {
 c. JSON(http. StatusInternalServerError, gin. H{"üzenet": hiba})
Visszatérés
	}
c. JSON(http. ÁllapotCreated, gin. H{"üzenet": "siker!", "Adat": res})
}

Az postId változó egy paraméterdeklaráció. A dokumentum objektumazonosítóját mint objId.

Azonban, eredmény az adatbázismodell egy példánya, amely később a visszaadott dokumentumot mint res.

A PUT végpont létrehozása

A PUT kezelő, be routes/update.go, hasonló a POST kezelőhöz. Ezúttal egy meglévő bejegyzést frissít egyedi objektumazonosítójával:

csomag útvonalak
import (
	kap gyűjteményt "CRUD_API/Gyűjtemény"
	adatbázis "CRUD_API/adatbázisok"
	modell "CRUD_API/modell"
"kontextus"
"net/http"
"idő"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)


func UpdatePost(c *gin. Kontextus){
	ctx, cancel := kontextus. WithTimeout (kontextus. Háttér(), 10 * idő. Második)
var DB = adatbázis. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Hozzászólások")


postId := c. Param("postId")
var posztmodell. Hozzászólások


defer cancel()


objId, _ := primitív. ObjectIDFromHex (postId)


ha hiba := c. BindJSON(&posta); hiba != nil {
 c. JSON(http. StatusInternalServerError, gin. H{"üzenet": hiba})
Visszatérés
	}


szerkesztve := bson. M{"cím": post. Cím, "cikk": post. Cikk}


eredmény, err := postCollection. UpdateOne (ctx, bson. M{"id": objId}, bson. M{"$set": szerkesztve})


res := térkép[karakterlánc]felület{}{"data": eredmény}


if err != nil {
 c. JSON(http. StatusInternalServerError, gin. H{"üzenet": hiba})
Visszatérés
	}


ha eredmény. MatchedCount < 1 {
 c. JSON(http. StatusInternalServerError, gin. H{"üzenet": "Az adatok nem't léteznek"})
Visszatérés
	}
c. JSON(http. ÁllapotCreated, gin. H{"üzenet": "az adatok sikeresen frissítve!", "Adat": res})
}

A modellpéldány JSON formátuma (hozzászólás) minden modellmezőt meghív az adatbázisból. Az eredményváltozó a MongoDB-t használja $set operátort, hogy frissítse az objektumazonosítója által megnevezett szükséges dokumentumot.

Az eredmény. MatchedCount feltétel megakadályozza a kód futását, ha nincs rekord az adatbázisban, vagy az átadott azonosító érvénytelen.

DELETE végpont létrehozása

A DELETE végpont, in delete.go, eltávolít egy dokumentumot az URL-paraméterként átadott objektumazonosító alapján:

csomag útvonalak
import (
	kap gyűjteményt "CRUD_API/Gyűjtemény"
	adatbázis "CRUD_API/adatbázisok"
"kontextus"
"net/http"
"idő"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)


func DeletePost(c *gin. Kontextus){
	ctx, cancel := kontextus. WithTimeout (kontextus. Háttér(), 10*idő. Második)
var DB = adatbázis. ConnectDB()
	postId := c. Param("postId")


var postCollection = getcollection. GetCollection (DB, "Hozzászólások") 
	defer cancel()
	objId, _ := primitív. ObjectIDFromHex (postId) 
	eredmény, err := postCollection. DeleteOne (ctx, bson. M{"id": objId}) 
	res := térkép[karakterlánc]felület{}{"data": eredmény}


if err != nil {
 c. JSON(http. StatusInternalServerError, gin. H{"üzenet": hiba})
Visszatérés
	}


ha eredmény. DeletedCount < 1 {
 c. JSON(http. StatusInternalServerError, gin. H{"üzenet": "Nincs törölni való adat"})
Visszatérés
	}
c. JSON(http. ÁllapotCreated, gin. H{"üzenet": "A cikk sikeresen törölve", "Adat": res})
}

Ez a kód törli a rekordot a DeleteOne funkció. Azt is használja a eredmény. DeletedCount tulajdonság, amely megakadályozza a kód lefutását, ha az adatbázis üres vagy az objektumazonosító érvénytelen.

Hozza létre az API Runner fájlt

Végül hozzon létre a fő.go a projekt gyökérkönyvtárában. A végleges projekt felépítése így néz ki:

Ez a fájl kezeli az útválasztó végrehajtását az egyes végpontokhoz:

csomag fő-
import (
 útvonalak "CRUD_API/útvonalak"
"github.com/gin-gonic/gin"
)


func fő-(){
 router := gin.Alapértelmezett()


router. POST("/", útvonalak. CreatePost)


// localhostként hívva: 3000/getOne/{id}
 router. KAP("getOne/:postId", útvonalak. ReadOnePost)


// localhostként hívják: 3000/frissítés/{id}
 router. PUT("/update/:postId", útvonalak. UpdatePost)


// localhostként hívják: 3000/töröl/{id}
 router. TÖRÖL("/töröl/:postId", útvonalak. DeletePost)
router. Fuss("helyi házigazda: 3000")
}

Ez a fájl a fő csomag, amely más fájlokat futtat. Az útvonalkezelők importálásával kezdődik. Következő a router változó, a gin példány, amely előhívja a HTTP-műveleteket, és minden végpontot a függvénynévvel hív meg a útvonalak csomag.

A CRUD projektje tovább fut helyi házigazda: 3000. A szerver futtatásához és tesztelje a CRUD API-t, futtassa a következő parancsot az alapkönyvtárban:

megyfussfő-.megy

Változtassa Golang CRUD projektjét használható termékké

Sikeresen létrehozott egy CRUD API-t a Go-val; Gratulálunk! Bár ez egy kisebb projekt, már látta, mi kell a szokásos HTTP-kérések végrehajtásához a Go-ban.

Kreatívabbá válhat, ha ezt egy praktikusabb alkalmazássá bővíti, amely értéket biztosít a felhasználók számára. A Go egy megfelelő programozási nyelv számos felhasználási célra.