Golang ir viena no vislabāk apmaksātajām, pieprasītajām programmēšanas valodām ar daudzām lietojumprogrammām. Savienojot pārī ar tādiem ietvariem kā Gin, Revel un gorilla/mux, varat viegli izveidot API, izmantojot Go.

Uzziniet, kā izveidot CRUD API Golangā, izmantojot Gin HTTP ietvaru.

Sākotnējā iestatīšana un instalēšana

Sāciet darbu ar Golangu instalējot to savā datorā, ja vēl neesat to izdarījis.

Pēc instalēšanas nākamais solis ir izveidot projekta saknes mapi savā datorā un inicializēt Go moduli šajā saknes direktorijā.

Lai to izdarītu, atveriet CLI, dodieties uz sava projekta saknes mapi un palaidiet:

go mod init moduļa_nosaukums

Jūs redzēsit sava moduļa nosaukumu (piem., CRUD_API) un tā versiju, atverot go.mod failu. Visas pielāgotās pakotnes nāks no šī vecākmoduļa. Tātad jebkurai importētajai pielāgotajai pakotnei ir šāda forma:

imports(iepakojums CRUD_API/iepakojums-direktorija nosaukums)

Pēc tam instalējiet pakotnes, kas nepieciešamas CRUD API izveidei. Šajā gadījumā izmantojiet Džins Goniks lai maršrutētu API galapunktus:

instagram viewer 
aiziet gūt github.com/gin-gonic/gin

Tagad instalējiet MongoDB draiveri, lai saglabātu datus:

aiziet gūt go.mongodb.org/mongo-driver/mongo

Kā izveidot savienojumu Dodieties uz MongoDB

Viss, kas jums nepieciešams, ir jūsu MongoDB URI, lai savienotu Golang ar datu bāzi. Parasti tas izskatās šādi, ja vietēji veidojat savienojumu ar MongoDB Atlas:

Mongo_URL = "mongodb://127.0.0.1:27017"

Tagad izveidojiet jaunu mapi sava projekta saknes direktorijā un izsauciet to datubāzēm. Izveidojiet Go failu šajā mapē un nosauciet to datubāze.go.

Šī ir jūsu datu bāzes pakotne, un tā sākas, importējot nepieciešamās bibliotēkas:

iepakojums datu bāze
imports (
"kontekstā"
"fmt"
"žurnāls"
"laiks"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)


func ConnectDB() *mongo. Klients {
	Mongo_URL := "mongodb://127.0.0.1:27017"
	klients, err := mongo. NewClient (opcijas. Klients().ApplyURI(Mongo_URL))


if err != nil {
žurnāls.Lentenīgi(kļūda)
	}


ctx, atcelt := kontekstu. WithTimeout (konteksts. Fons(), 10 * laiks. Otrkārt)
	err = klients. Savienot (ctx)
	atlikt atcelt ()


if err != nil {
žurnāls.Lentenīgi(kļūda)
	}
fmt. Println("Savienots ar mongoDB")
atgriezties klients
}

Labākā prakse ir paslēpt vides mainīgos, piemēram, datubāzes savienojuma virkni a .env failu izmantojot dotenv pakotni. Tas padara jūsu kodu pārnēsājamāku un noderēs, izmantojot a MongoDB mākoņu klastera gadījums, piemēram.

The ConnectDB funkcija izveido savienojumu un atgriež jaunu MongoDB klienta objektu.

Izveidot datu bāzes kolekciju

MongoDB glabā datus kolekcijās, kas nodrošina saskarni ar pamatā esošajiem datu bāzes datiem.

Lai apstrādātu kolekcijas ielādes funkcionalitāti, vispirms izveidojiet jaunu mapi, Kolekcija, jūsu projekta saknē. Tagad izveidojiet jaunu Go failu, getCollection.go, kas iegūst kolekciju no datu bāzes:

iepakojums iegūt kolekciju
imports (
"go.mongodb.org/mongo-driver/mongo"
)
funcGetCollection(klients *mongo.Klients, kolekcijas nosaukumsvirkne) *mongo.Kolekcija {
	kolekcija := klients. Datu bāze("myGoappDB").Kolekcija("Ziņas")
atgriezties kolekcija
}

Šī funkcija iegūst kolekciju no MongoDB datu bāzes. Šajā gadījumā datu bāzes nosaukums ir myGoappDB, ar Ziņas kā tās kolekcija.

Izveidojiet datu bāzes modeli

Izveidojiet jaunu mapi saknes direktorijā un izsauciet to modelis. Šī mape apstrādā jūsu datu bāzes modeli.

Izveidojiet jaunu Go failu šajā mapē un izsauciet to model.go. Šajā gadījumā jūsu modelis ir emuāra ziņa ar tā nosaukumu:

iepakojums modelis
imports (
"go.mongodb.org/mongo-driver/bson/primitive"
)
veids Post struct {
IDprimitīvs.ObjectID
	Virsraksta virkne
	Raksta virkne
}

CRUD API izveide, izmantojot Go

Nākamais ir CRUD API izveide. Lai sāktu ar šo sadaļu, izveidojiet jaunu mapi projekta saknes direktorijā, lai apstrādātu galapunktus. Sauc to maršrutos.

Katrai darbībai šajā mapē izveidojiet atsevišķu Go failu. Piemēram, varat tos nosaukt izveidot.go, lasīt.iet, update.go, un delete.go. Jūs eksportēsit šos apdarinātājus kā maršrutos iepakojums.

Kā izveidot POST galapunktu programmā Go

Sāciet, definējot POST galapunktu, lai ierakstītu datus datu bāzē.

Iekšā routes/create.go, pievienojiet šo:

iepakojums maršrutos
imports (
	iegūt kolekciju "CRUD_API/kolekcija"
	datu bāze "CRUD_API/datu bāzes"
	modelis "CRUD_API/modelis"
"kontekstā"
"žurnāls"
"net/http"
"laiks"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson/primitive"
)


func CreatePost(c *gin. konteksts){
var DB = datubāze. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Ziņas")
	ctx, atcelt := kontekstu. WithTimeout (konteksts. Fons(), 10*laiks. Otrkārt)
	ziņa := jauns(modelis. Ziņas)
	atlikt atcelt ()


ja kļūda := c. BindJSON(&pasts); err != nil {
 c. JSON (http. StatusBadRequest, gin. H{"ziņa": err})
žurnāls.Lentenīgi(kļūda)
atgriezties
	}


postPayload := modelis. Ziņas{
Id: primitīvs.NewObjectID(),
Nosaukums: pastu.Tituls,
Raksts: pastu.Raksts,
	}


rezultāts, err := postCollection. InsertOne (ctx, postPayload)


if err != nil {
 c. JSON (http. StatusInternalServerError, gin. H{"ziņa": err})
atgriezties
	}
c. JSON (http. StatussIzveidots, Džins. H{"ziņa": "Veiksmīgi publicēts", "Dati": kartes[string]interfeiss{}{"datus": rezultāts}})
}

Šis kods sākas, importējot projekta pielāgotos moduļus. Pēc tam tas importē trešo pušu pakotnes, tostarp Džins un MongoDB draiveris.

Tālāk, postKolekcija glabā datu bāzes kolekciju. Īpaši c. BindJSON("ziņa") ir JSONificēta modeļa instance, kas katru modeļa lauku izsauc kā pēcPayload; tas nonāk datu bāzē.

Kā izveidot GET galapunktu

GET galapunkts, in routes/read.go, nolasa vienu dokumentu no datu bāzes, izmantojot tā unikālo ID. Tas sākas arī ar pielāgotu un trešo pušu pakotņu importēšanu:

iepakojums maršrutos
imports (
	iegūt kolekciju "CRUD_API/kolekcija"
	datu bāze "CRUD_API/datu bāzes"
	modelis "CRUD_API/modelis"
"kontekstā"
"net/http"
"laiks"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)


func ReadOnePost(c *gin. konteksts){
	ctx, atcelt := kontekstu. WithTimeout (konteksts. Fons(), 10*laiks. Otrkārt)
var DB = datubāze. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Ziņas")


postId := c. Param("postId")
var rezultātu modelis. Ziņas


atlikt atcelt ()


objId, _ := primitīvs. ObjectIDFromHex (postId)


err := postCollection. FindOne (ctx, bson. M{"id": objId}).Atšifrēt(&rezultāts)


res := karte [virkne]saskarne{}{"data": rezultāts}


if err != nil {
 c. JSON (http. StatusInternalServerError, gin. H{"ziņa": err})
atgriezties
	}
c. JSON (http. StatussIzveidots, Džins. H{"ziņa": "panākumus!", "Dati": res})
}

The postId mainīgais ir parametru deklarācija. Tas iegūst dokumenta objekta ID kā objId.

tomēr rezultāts ir datu bāzes modeļa gadījums, kas vēlāk satur atgriezto dokumentu kā res.

Kā izveidot PUT galapunktu

PUT apdarinātājs, iekšā routes/update.go, ir līdzīgs POST apstrādātājam. Šoreiz tas atjaunina esošu ziņu pēc tā unikālā objekta ID:

iepakojums maršrutos
imports (
	iegūt kolekciju "CRUD_API/kolekcija"
	datu bāze "CRUD_API/datu bāzes"
	modelis "CRUD_API/modelis"
"kontekstā"
"net/http"
"laiks"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)


func UpdatePost(c *gin. konteksts){
	ctx, atcelt := kontekstu. WithTimeout (konteksts. Fons(), 10 * laiks. Otrkārt)
var DB = datubāze. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Ziņas")


postId := c. Param("postId")
var pasta modelis. Ziņas


atlikt atcelt ()


objId, _ := primitīvs. ObjectIDFromHex (postId)


ja kļūda := c. BindJSON(&pasts); err != nil {
 c. JSON (http. StatusInternalServerError, gin. H{"ziņa": err})
atgriezties
	}


rediģēts := bson. M{"virsraksts": pasts. Nosaukums, "rakstu": pasts. pants}


rezultāts, err := postCollection. UpdateOne (ctx, bson. M{"id": objId}, bson. M{"$set": rediģēts})


res := karte [virkne]saskarne{}{"data": rezultāts}


if err != nil {
 c. JSON (http. StatusInternalServerError, gin. H{"ziņa": err})
atgriezties
	}


ja rezultāts. MatchedCount < 1 {
 c. JSON (http. StatusInternalServerError, gin. H{"ziņa": "Dati nav't pastāvēt"})
atgriezties
	}
c. JSON (http. StatussIzveidots, Džins. H{"ziņa": "dati ir veiksmīgi atjaunināti!", "Dati": res})
}

modeļa instances JSON formāts (pastu) izsauc katru modeļa lauku no datu bāzes. Rezultāta mainīgais izmanto MongoDB $set operatoru, lai atjauninātu nepieciešamo dokumentu, ko izsauc tā objekta ID.

The rezultāts. MatchedCount nosacījums neļauj kodam darboties, ja datu bāzē nav ierakstu vai nodotais ID ir nederīgs.

DELETE beigu punkta izveide

Galapunkts DELETE, in delete.go, noņem dokumentu, pamatojoties uz objekta ID, kas nodots kā URL parametrs:

iepakojums maršrutos
imports (
	iegūt kolekciju "CRUD_API/kolekcija"
	datu bāze "CRUD_API/datu bāzes"
"kontekstā"
"net/http"
"laiks"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)


func DeletePost(c *gin. konteksts){
	ctx, atcelt := kontekstu. WithTimeout (konteksts. Fons(), 10*laiks. Otrkārt)
var DB = datubāze. ConnectDB()
	postId := c. Param("postId")


var postCollection = getcollection. GetCollection (DB, "Ziņas") 
	atlikt atcelt ()
	objId, _ := primitīvs. ObjectIDFromHex (postId) 
	rezultāts, err := postCollection. DeleteOne (ctx, bson. M{"id": objId}) 
	res := karte [virkne]saskarne{}{"data": rezultāts}


if err != nil {
 c. JSON (http. StatusInternalServerError, gin. H{"ziņa": err})
atgriezties
	}


ja rezultāts. DeletedCount < 1 {
 c. JSON (http. StatusInternalServerError, gin. H{"ziņa": "Nav datu, ko dzēst"})
atgriezties
	}
c. JSON (http. StatussIzveidots, Džins. H{"ziņa": "Raksts veiksmīgi izdzēsts", "Dati": res})
}

Šis kods izdzēš ierakstu, izmantojot DeleteOne funkciju. Tas izmanto arī rezultāts. DeletedCount rekvizītu, lai novērstu koda palaišanu, ja datu bāze ir tukša vai objekta ID nav derīgs.

Izveidojiet API Runner failu

Visbeidzot izveidojiet a galvenais.go projekta saknes direktorijā. Jūsu galīgajai projekta struktūrai vajadzētu izskatīties šādi:

Šis fails apstrādā maršrutētāja izpildi katram galapunktam:

iepakojums galvenais
imports (
 maršrutos "CRUD_API/maršruti"
"github.com/gin-gonic/gin"
)


func galvenais(){
 maršrutētājs := džins.Noklusējums()


maršrutētājs. POST("/", maršruti. CreatePost)


// izsaukts kā localhost: 3000/getOne/{id}
 maršrutētājs. GŪT("getOne/:postId", maršruti. ReadOnePost)


// izsaukts kā vietējais saimnieks: 3000/Atjaunināt/{id}
 maršrutētājs. PUT("/update/:postId", maršruti. UpdatePost)


// izsaukts kā vietējais saimnieks: 3000/dzēst/{id}
 maršrutētājs. DZĒST("/dzēst/:postId", maršruti. DeletePost)
maršrutētājs. Palaist("vietējais saimnieks: 3000")
}

Šis fails ir galvenā pakotne, kurā darbojas citi faili. Tas sākas ar maršruta apstrādātāju importēšanu. Nākamais ir maršrutētājs mainīgais, a džins gadījums, kas izsauc HTTP darbības un izsauc katru galapunktu pēc tā funkcijas nosaukuma no maršrutos iepakojums.

Jūsu CRUD projekts turpinās vietējais saimnieks: 3000. Lai palaistu serveri un pārbaudiet CRUD API, palaidiet šādu komandu savā bāzes direktorijā:

aizietpalaistgalvenais.iet

Pārvērtiet savu Golang CRUD projektu par lietojamu produktu

Jūs esat veiksmīgi izveidojis CRUD API, izmantojot Go; apsveicu! Lai gan šis ir mazsvarīgs projekts, esat redzējis, kas nepieciešams, lai Go izpildītu parastos HTTP pieprasījumus.

Jūs varat kļūt radošāks, izvēršot to par praktiskāku lietojumprogrammu, kas lietotājiem sniedz vērtību. Go ir piemērota programmēšanas valoda dažādiem lietošanas gadījumiem.