Golang on üks enimtasuvaid ja nõutavamaid programmeerimiskeeli, millel on palju rakendusi. Kui see on seotud raamistikega, nagu Gin, Revel ja gorilla/mux, saate Go abil hõlpsasti API luua.

Siit saate teada, kuidas Gin HTTP raamistikku kasutades Golangis CRUD API-d luua.

Esialgne seadistamine ja installimine

Alustage Golangiga installides selle oma arvutisse, kui te pole seda veel teinud.

Pärast installimist tuleb järgmiseks sammuks luua oma masinas projekti juurkaust ja lähtestada selles juurkataloogis Go moodul.

Selleks avage CLI, navigeerige oma projekti juurkausta ja käivitage:

minge mod init mooduli_nimi

Näete oma mooduli nime (nt. CRUD_API) ja selle versiooni, kui avate go.mod faili. Kõik kohandatud paketid pärinevad sellest ülemmoodulist. Seega on mis tahes imporditud kohandatud pakett järgmisel kujul:

importida(pakett CRUD_API/pakett-kataloogi nimi)

Järgmisena installige CRUD API loomiseks vajalikud paketid. Sel juhul kasutage Gin Gonic API lõpp-punktide suunamiseks:

mine saada github.com/gin-gonic/gin

Nüüd installige andmete salvestamiseks MongoDB draiver:

mine saada go.mongodb.org/mongo-driver/mongo

Kuidas ühendada Minge MongoDB-sse

Kõik, mida vajate, on teie MongoDB URI, et ühendada Golang andmebaasiga. Tavaliselt näeb see välja järgmine, kui loote ühenduse MongoDB Atlasega kohapeal:

Mongo_URL = "mongodb://127.0.0.1:27017"

Nüüd looge oma projekti juurkataloogis uus kaust ja helistage sellele andmebaasid. Looge selles kaustas Go-fail ja nimetage see andmebaas.go.

See on teie andmebaasipakett ja see algab vajalike teekide importimisega:

pakett andmebaasi
importida (
"kontekst"
"fmt"
"logi"
"aega"
"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, eksitus := mongo. NewClient (valikud. Klient().ApplyURI(Mongo_URL))


if err != nil {
logi.Tappev(eks)
	}


ctx, tühista := kontekst. WithTimeout (kontekst. Taust(), 10 * aeg. Teine)
	err = klient. Ühenda (ctx)
	lükka tühistama()


if err != nil {
logi.Tappev(eks)
	}
fmt. Println("Ühendatud mongoDB-ga")
tagasi klient
}

Parim tava on peita keskkonnamuutujad, näiteks andmebaasi ühendusstring a-s .env faili kasutades dotenv paketti. See muudab teie koodi kaasaskantavamaks ja on kasulik, kui kasutate a MongoDB pilveklastri eksemplar, näiteks.

The ConnectDB funktsioon loob ühenduse ja tagastab uue MongoDB kliendiobjekti.

Loo andmebaasikogu

MongoDB salvestab andmed kogudesse, mis pakuvad liidest andmebaasi aluseks olevatele andmetele.

Kogu toomise funktsiooniga tegelemiseks alustage uue kausta loomisega, Kollektsioon, teie projekti juurtes. Looge nüüd uus Go-fail, getCollection.go, mis saab kogu andmebaasist:

pakett saada kogumine
importida (
"go.mongodb.org/mongo-driver/mongo"
)
funcGetCollection(klient *mongo.Klient, kollektsiooni nimistring) *mongo.Kogu {
	kollektsioon := klient. Andmebaas("myGoappDB").Kogu ("Postitused")
tagasi kogumine
}

See funktsioon hangib kollektsiooni MongoDB andmebaasist. Andmebaasi nimi on antud juhul myGoappDB, koos Postitused selle kollektsioonina.

Looge andmebaasi mudel

Looge juurkataloogis uus kaust ja helistage sellele mudel. See kaust haldab teie andmebaasi mudelit.

Looge selles kaustas uus Go-fail ja helistage sellele model.go. Teie mudel on antud juhul ajaveebipostitus selle pealkirjaga:

pakett mudel
importida (
"go.mongodb.org/mongo-driver/bson/primitive"
)
tüüp Postitusstruktuur {
IDprimitiivne.ObjectID
	Pealkirja string
	Artikli string
}

CRUD API loomine rakendusega Go

Järgmine on CRUD API loomine. Selle jaotisega alustamiseks looge oma projekti juurkataloogis oma lõpp-punktide haldamiseks uus kaust. Kutsu seda marsruute.

Looge selles kaustas iga toimingu jaoks eraldi Go-fail. Näiteks võite neile nimetada loo.go, loe.mine, update.goja delete.go. Ekspordite need töötlejad kui marsruute pakett.

Kuidas luua Go-s POST-i lõpp-punkti

Alustage andmete andmebaasi kirjutamiseks POST-i lõpp-punkti määratlemisest.

Sees routes/create.go, lisage järgmine:

pakett marsruute
importida (
	saada kogumine "CRUD_API/kogu"
	andmebaasi "CRUD_API/andmebaasid"
	mudel "CRUD_API/mudel"
"kontekst"
"logi"
"net/http"
"aega"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson/primitive"
)


func Loo postitus(c *gin. Kontekst){
var DB = andmebaas. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Postitused")
	ctx, tühista := kontekst. WithTimeout (kontekst. Taust(), 10*aeg. Teine)
	postitus := uus(mudel. postitused)
	lükka tühistama()


kui eksite := c. BindJSON(&postitus); eksitus != null {
 c. JSON(http. StatusBadRequest, gin. H{"sõnum": eks})
logi.Tappev(eks)
tagasi
	}


postPayload := mudel. Postitused{
Id: primitiivne.NewObjectID(),
Pealkiri: postitus.Pealkiri,
Artikkel: postitus.Artikkel,
	}


tulemus, err := postCollection. InsertOne (ctx, postPayload)


if err != nil {
 c. JSON(http. StatusInternalServerError, gin. H{"sõnum": eks})
tagasi
	}
c. JSON(http. OlekLoodud, gin. H{"sõnum": "Postitamine õnnestus", "Andmed": kaardi[string]liides{}{"andmeid": tulemus}})
}

See kood algab projekti kohandatud moodulite importimisega. Seejärel impordib see kolmandate osapoolte pakette, sealhulgas Džinn ja MongoDB draiver.

Edasi, postCollection hoiab andmebaasi kogu. Eelkõige c. BindJSON("postitus") on JSONified mudeli eksemplar, mis nimetab iga mudeli välja kui postPayload; see läheb andmebaasi.

Kuidas luua GET-i lõpp-punkti

GET-i lõpp-punkt routes/read.go, loeb unikaalse ID kaudu andmebaasist ühe dokumendi. See algab ka kohandatud ja kolmanda osapoole pakettide importimisega:

pakett marsruute
importida (
	saada kogumine "CRUD_API/kogu"
	andmebaasi "CRUD_API/andmebaasid"
	mudel "CRUD_API/mudel"
"kontekst"
"net/http"
"aega"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)


func ReadOnePost(c *gin. Kontekst){
	ctx, tühista := kontekst. WithTimeout (kontekst. Taust(), 10*aeg. Teine)
var DB = andmebaas. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Postitused")


postituse ID := c. Param("posti ID")
var tulemuse mudel. Postitused


lükka tühistama()


objId, _ := primitiivne. ObjectIDFromHex (postId)


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


res := kaart[string]liides{}{"data": tulemus}


if err != nil {
 c. JSON(http. StatusInternalServerError, gin. H{"sõnum": eks})
tagasi
	}
c. JSON(http. OlekLoodud, gin. H{"sõnum": "edu!", "Andmed": res})
}

The posti ID muutuja on parameetri deklaratsioon. See saab dokumendi objekti ID kui objId.

Kuid, tulemus on andmebaasimudeli eksemplar, mis hiljem hoiab tagastatud dokumenti kui res.

Kuidas luua PUT-i lõpp-punkti

PUT-käitleja, sisse routes/update.go, on sarnane POST-i töötlejaga. Seekord värskendab see olemasolevat postitust selle ainulaadse objekti ID järgi:

pakett marsruute
importida (
	saada kogumine "CRUD_API/kogu"
	andmebaasi "CRUD_API/andmebaasid"
	mudel "CRUD_API/mudel"
"kontekst"
"net/http"
"aega"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)


func UpdatePost(c *gin. Kontekst){
	ctx, tühista := kontekst. WithTimeout (kontekst. Taust(), 10 * aeg. Teine)
var DB = andmebaas. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Postitused")


postituse ID := c. Param("posti ID")
var postimudel. Postitused


lükka tühistama()


objId, _ := primitiivne. ObjectIDFromHex (postId)


kui eksite := c. BindJSON(&postitus); eksitus != null {
 c. JSON(http. StatusInternalServerError, gin. H{"sõnum": eks})
tagasi
	}


redigeeritud := bson. M{"pealkiri": postitus. Pealkiri, "artiklit": postitus. Artikkel}


tulemus, err := postCollection. UpdateOne (ctx, bson. M{"id": objId}, bson. M{"$set": muudetud})


res := kaart[string]liides{}{"data": tulemus}


if err != nil {
 c. JSON(http. StatusInternalServerError, gin. H{"sõnum": eks})
tagasi
	}


kui tulemus. MatchedCount < 1 {
 c. JSON(http. StatusInternalServerError, gin. H{"sõnum": "Andmed ei tee't olemas"})
tagasi
	}
c. JSON(http. OlekLoodud, gin. H{"sõnum": "andmete uuendamine õnnestus!", "Andmed": res})
}

Mudeli eksemplari JSON-vorming (postitus) kutsub välja iga mudelivälja andmebaasist. Tulemusmuutuja kasutab MongoDB-d $set operaator värskendama vajalikku dokumenti, mida kutsutakse selle objekti ID-ga.

The tulemus. MatchedCount tingimus takistab koodi käitamist, kui andmebaasis pole kirjet või edastatud ID on kehtetu.

DELETE lõpp-punkti loomine

Lõpp-punkt DELETE, in delete.go, eemaldab dokumendi URL-i parameetrina edastatud objekti ID alusel:

pakett marsruute
importida (
	saada kogumine "CRUD_API/kogu"
	andmebaasi "CRUD_API/andmebaasid"
"kontekst"
"net/http"
"aega"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)


func Kustuta postitus(c *gin. Kontekst){
	ctx, tühista := kontekst. WithTimeout (kontekst. Taust(), 10*aeg. Teine)
var DB = andmebaas. ConnectDB()
	postituse ID := c. Param("posti ID")


var postCollection = getcollection. GetCollection (DB, "Postitused") 
	lükka tühistama()
	objId, _ := primitiivne. ObjectIDFromHex (postId) 
	tulemus, err := postCollection. DeleteOne (ctx, bson. M{"id": objId}) 
	res := kaart[string]liides{}{"data": tulemus}


if err != nil {
 c. JSON(http. StatusInternalServerError, gin. H{"sõnum": eks})
tagasi
	}


kui tulemus. KustutatudArv < 1 {
 c. JSON(http. StatusInternalServerError, gin. H{"sõnum": "Kustutamiseks pole andmeid"})
tagasi
	}
c. JSON(http. OlekLoodud, gin. H{"sõnum": "Artikli kustutamine õnnestus", "Andmed": res})
}

See kood kustutab kirje kasutades Kustuta üks funktsiooni. See kasutab ka tulemus. KustutatudArv atribuut koodi käitamise takistamiseks, kui andmebaas on tühi või objekti ID on kehtetu.

Looge API Runneri fail

Lõpuks looge a main.go oma projekti juurkataloogis. Teie lõplik projekti struktuur peaks välja nägema järgmine:

See fail käsitleb ruuteri täitmist iga lõpp-punkti jaoks:

pakett peamine
importida (
 marsruute "CRUD_API/marsruudid"
"github.com/gin-gonic/gin"
)


func peamine(){
 ruuter := gin.Vaikimisi()


ruuter. POSTA("/", marsruudid. Loo postitus)


// kutsutakse kohalikuks hostiks: 3000/getOne/{id}
 ruuter. GET("getOne/:postId", marsruudid. ReadOnePost)


// kutsutakse kohalikuks hostiks: 3000/värskendada/{id}
 ruuter. PUT("/update/:postId", marsruudid. UpdatePost)


// kutsutakse kohalikuks hostiks: 3000/kustutada/{id}
 ruuter. DELETE("/kustutada/:postId", marsruudid. Kustuta postitus)
ruuter. Run("kohalik host: 3000")
}

See fail on põhipakett, mis käitab teisi faile. See algab marsruudihaldurite importimisega. Järgmine on ruuter muutuja, a džinn eksemplar, mis kutsub esile HTTP-toimingud ja kutsub iga lõpp-punkti selle funktsiooni nime järgi marsruute pakett.

Teie CRUD projekt kestab kohalik host: 3000. Serveri käitamiseks ja testige CRUD API-d, käivitage oma põhikataloogis järgmine käsk:

minejooksmapeamine.mine

Muutke oma Golang CRUD-projekt kasutatavaks tooteks

Olete Go-ga edukalt loonud CRUD API; palju õnne! Kuigi see on väike projekt, olete näinud, mida on vaja Go-s tavaliste HTTP-päringute täitmiseks.

Saate muuta loomingulisemaks, laiendades seda praktilisemaks rakenduseks, mis pakub kasutajatele väärtust. Go on sobiv programmeerimiskeel erinevateks kasutusjuhtudeks.