Golang yra viena iš geriausiai apmokamų, paklausių programavimo kalbų su daugybe programų. Suporavę su tokiomis sistemomis kaip Gin, Revel ir gorilla/mux, galite lengvai sukurti API naudodami Go.

Sužinokite, kaip sukurti CRUD API Golang naudojant Gin HTTP sistemą.

Pradinė sąranka ir diegimas

Pradėkite nuo Golang įdiegę jį savo kompiuteryje, jei to dar nepadarėte.

Įdiegus kitas veiksmas yra sukurti projekto šakninį aplanką savo kompiuteryje ir inicijuoti Go modulį tame šakniniame kataloge.

Norėdami tai padaryti, atidarykite CLI, eikite į projekto šakninį aplanką ir paleiskite:

go mod init modulio_pavadinimas

Pamatysite savo modulio pavadinimą (pvz., CRUD_API) ir jo versija, kai atidarote go.mod failą. Visi pasirinktiniai paketai bus iš šio pagrindinio modulio. Taigi bet koks importuotas pasirinktinis paketas yra tokia forma:

importuoti(paketą CRUD_API/paketą-katalogo pavadinimas)

Tada įdiekite paketus, reikalingus kuriant CRUD API. Tokiu atveju naudokite Gin Gonic Norėdami nukreipti API galinius taškus:

instagram viewer 
eik gauti github.com/gin-gonic/gin

Dabar įdiekite „MongoDB“ tvarkyklę, kad saugotumėte duomenis:

eik gauti go.mongodb.org/mongo-driver/mongo

Kaip prisijungti Eikite į MongoDB

Viskas, ko jums reikia, yra jūsų MongoDB URI, kad galėtumėte prijungti Golangą su duomenų baze. Paprastai tai atrodo taip, jei prie MongoDB Atlas prisijungiate vietoje:

Mongo_URL = "mongodb://127.0.0.1:27017"

Dabar sukurkite naują aplanką savo projekto šakniniame kataloge ir iškvieskite jį duomenų bazės. Šiame aplanke sukurkite Go failą ir pavadinkite jį duomenų bazė.go.

Tai yra jūsų duomenų bazės paketas, kuris prasideda importuojant reikiamas bibliotekas:

paketą duomenų bazėje
importuoti (
"kontekste"
"fmt"
"žurnalas"
"laikas"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)


func ConnectDB() *mongas. Klientas {
	Mongo_URL := "mongodb://127.0.0.1:27017"
	klientas, klaida := mongo. NewClient (parinktys. Klientas().ApplyURI(Mongo_URL))


if err != nil {
žurnalas.Mirtinas(klysti)
	}


ctx, atšaukti := kontekstą. WithTimeout (kontekstas. Fonas (), 10 * laikas. Antra)
	err = klientas. Prisijunkite (ctx)
	atidėti atšaukti ()


if err != nil {
žurnalas.Mirtinas(klysti)
	}
fmt. Println("Prisijungta prie mongoDB")
grąžinti klientas
}

Geriausia yra slėpti aplinkos kintamuosius, pvz., duomenų bazės ryšio eilutę a .env failą naudojant dotenv paketą. Dėl to jūsų kodas tampa lengviau nešiojamas ir bus naudingas naudojant a MongoDB debesų klasterio egzempliorius, pavyzdžiui.

The ConnectDB funkcija užmezga ryšį ir grąžina naują MongoDB kliento objektą.

Sukurti duomenų bazių rinkinį

„MongoDB“ saugo duomenis kolekcijose, kurios suteikia sąsają su pagrindiniais duomenų bazės duomenimis.

Norėdami apdoroti kolekcijos gavimo funkciją, pirmiausia sukurkite naują aplanką, Kolekcija, jūsų projekto šaknyje. Dabar sukurkite naują Go failą, getCollection.go, kuri gauna kolekciją iš duomenų bazės:

paketą gauti kolekciją
importuoti (
"go.mongodb.org/mongo-driver/mongo"
)
funcGetCollection(klientas *mongo.Klientas, kolekcijaNamestyga) *mongo.Kolekcija {
	kolekcija := klientas. duomenų bazė ("myGoappDB").Kolekcija("Įrašai")
grąžinti kolekcija
}

Ši funkcija kolekciją gauna iš MongoDB duomenų bazės. Šiuo atveju duomenų bazės pavadinimas yra myGoappDB, su Įrašai kaip jos kolekcija.

Sukurkite duomenų bazės modelį

Sukurkite naują aplanką savo šakniniame kataloge ir iškvieskite jį modelis. Šis aplankas tvarko jūsų duomenų bazės modelį.

Sukurkite naują „Go“ failą tame aplanke ir iškvieskite jį model.go. Šiuo atveju jūsų modelis yra tinklaraščio įrašas, kurio pavadinimas:

paketą modelis
importuoti (
"go.mongodb.org/mongo-driver/bson/primitive"
)
tipo Paskelbti struktūra {
IDprimityvus.ObjectID
	Pavadinimo eilutė
	Straipsnio eilutė
}

CRUD API sukūrimas naudojant „Go“.

Kitas yra CRUD API kūrimas. Norėdami pradėti nuo šio skyriaus, sukurkite naują aplanką savo projekto šakniniame kataloge, kad galėtumėte tvarkyti savo galinius taškus. Vadink tai maršrutai.

Šiame aplanke kiekvienam veiksmui sukurkite atskirą Go failą. Pavyzdžiui, galite juos pavadinti kurti.eiti, skaityk.eik, update.go, ir delete.go. Eksportuosite šias tvarkykles kaip maršrutai paketą.

Kaip sukurti POST galinį tašką „Go“.

Pradėkite apibrėždami POST galinį tašką, kad galėtumėte įrašyti duomenis į duomenų bazę.

Viduje routes/create.go, pridėkite:

paketą maršrutai
importuoti (
	gauti kolekciją "CRUD_API / kolekcija"
	duomenų bazėje "CRUD_API/duomenų bazės"
	modelis "CRUD_API/modelis"
"kontekste"
"žurnalas"
"net/http"
"laikas"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson/primitive"
)


func CreatePost(c *gin. kontekstas){
var DB = duomenų bazė. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Įrašai")
	ctx, atšaukti := kontekstą. WithTimeout (kontekstas. Fonas (), 10* laikas. Antra)
	įrašas := naujas(modelis. Įrašai)
	atidėti atšaukti ()


jei klysta := c. BindJSON(&paštas); err != nil {
 c. JSON (http. StatusBadRequest, gin. H{"žinutę": klysta})
žurnalas.Mirtinas(klysti)
grąžinti
	}


postPayload := modelis. Įrašai{
Id: primityvus.NewObjectID(),
Pavadinimas: paštu.Pavadinimas,
Straipsnis: paštu.Straipsnis,
	}


rezultatas, klaida := postCollection. InsertOne (ctx, postPayload)


if err != nil {
 c. JSON (http. StatusInternalServerError, gin. H{"žinutę": klysta})
grąžinti
	}
c. JSON (http. BūsenaSukurta, džinas. H{"žinutę": "Paskelbta sėkmingai", "Duomenys": žemėlapio[string]sąsaja{}{"duomenis": rezultatas}})
}

Šis kodas prasideda importuojant projekto pasirinktinius modulius. Tada jis importuoja trečiųjų šalių paketus, įskaitant Džinas ir MongoDB tvarkyklė.

Toliau, postCollection saugo duomenų bazių kolekciją. Pažymėtina, c. BindJSON („įrašas“) yra JSONified modelio egzempliorius, kuris kiekvieną modelio lauką vadina kaip postPayload; tai patenka į duomenų bazę.

Kaip sukurti GET galinį tašką

GET galutinis taškas, in routes/read.go, nuskaito vieną dokumentą iš duomenų bazės per savo unikalų ID. Jis taip pat prasideda importuojant pasirinktinius ir trečiųjų šalių paketus:

paketą maršrutai
importuoti (
	gauti kolekciją "CRUD_API / kolekcija"
	duomenų bazėje "CRUD_API/duomenų bazės"
	modelis "CRUD_API/modelis"
"kontekste"
"net/http"
"laikas"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)


func ReadOnePost(c *gin. kontekstas){
	ctx, atšaukti := kontekstą. WithTimeout (kontekstas. Fonas (), 10* laikas. Antra)
var DB = duomenų bazė. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Įrašai")


postId := c. Param("postId")
var rezultato modelis. Įrašai


atidėti atšaukti ()


objId, _ := primityvus. ObjectIDFromHex (postId)


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


res := žemėlapis [eilutė]sąsaja{}{"duomenys": rezultatas}


if err != nil {
 c. JSON (http. StatusInternalServerError, gin. H{"žinutę": klysta})
grąžinti
	}
c. JSON (http. BūsenaSukurta, džinas. H{"žinutę": "sėkmė!", "Duomenys": res})
}

The postId kintamasis yra parametrų deklaracija. Jis gauna dokumento objekto ID kaip objId.

Tačiau rezultatas yra duomenų bazės modelio pavyzdys, kuriame vėliau saugomas grąžintas dokumentas kaip res.

Kaip sukurti PUT galinį tašką

PUT tvarkytuvas, in routes/update.go, yra panašus į POST tvarkyklę. Šį kartą jis atnaujina esamą įrašą pagal unikalų objekto ID:

paketą maršrutai
importuoti (
	gauti kolekciją "CRUD_API / kolekcija"
	duomenų bazėje "CRUD_API/duomenų bazės"
	modelis "CRUD_API/modelis"
"kontekste"
"net/http"
"laikas"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)


func UpdatePost(c *gin. kontekstas){
	ctx, atšaukti := kontekstą. WithTimeout (kontekstas. Fonas (), 10 * laikas. Antra)
var DB = duomenų bazė. ConnectDB()
	var postCollection = getcollection. GetCollection (DB, "Įrašai")


postId := c. Param("postId")
var pašto modelis. Įrašai


atidėti atšaukti ()


objId, _ := primityvus. ObjectIDFromHex (postId)


jei klysta := c. BindJSON(&paštas); err != nil {
 c. JSON (http. StatusInternalServerError, gin. H{"žinutę": klysta})
grąžinti
	}


redaguota := bson. M{"titulą": paštas. Pavadinimas, "straipsnis": paštas. Straipsnis}


rezultatas, klaida := postCollection. UpdateOne (ctx, bson. M{"id": objId}, bson. M{"$set": redaguota})


res := žemėlapis [eilutė]sąsaja{}{"duomenys": rezultatas}


if err != nil {
 c. JSON (http. StatusInternalServerError, gin. H{"žinutę": klysta})
grąžinti
	}


jei rezultatas. MatchedCount < 1 {
 c. JSON (http. StatusInternalServerError, gin. H{"žinutę": "Duomenys nedaro't egzistuoti"})
grąžinti
	}
c. JSON (http. BūsenaSukurta, džinas. H{"žinutę": "duomenys sėkmingai atnaujinti!", "Duomenys": res})
}

modelio egzemplioriaus JSON formatas (paštu) iškviečia kiekvieną modelio lauką iš duomenų bazės. Rezultato kintamasis naudoja MongoDB $set operatorius atnaujinti reikalingą dokumentą, pavadintą jo objekto ID.

The rezultatas. MatchedCount sąlyga neleidžia kodui paleisti, jei duomenų bazėje nėra įrašo arba perduotas ID neteisingas.

DELETE pabaigos taško sukūrimas

Galutinis taškas DELETE, in delete.go, pašalina dokumentą pagal objekto ID, perduotą kaip URL parametras:

paketą maršrutai
importuoti (
	gauti kolekciją "CRUD_API / kolekcija"
	duomenų bazėje "CRUD_API/duomenų bazės"
"kontekste"
"net/http"
"laikas"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)


func Ištrinti Post(c *gin. kontekstas){
	ctx, atšaukti := kontekstą. WithTimeout (kontekstas. Fonas (), 10* laikas. Antra)
var DB = duomenų bazė. ConnectDB()
	postId := c. Param("postId")


var postCollection = getcollection. GetCollection (DB, "Įrašai") 
	atidėti atšaukti ()
	objId, _ := primityvus. ObjectIDFromHex (postId) 
	rezultatas, klaida := postCollection. DeleteOne (ctx, bson. M{"id": objId}) 
	res := žemėlapis [eilutė]sąsaja{}{"duomenys": rezultatas}


if err != nil {
 c. JSON (http. StatusInternalServerError, gin. H{"žinutę": klysta})
grąžinti
	}


jei rezultatas. Ištrintas skaičius < 1 {
 c. JSON (http. StatusInternalServerError, gin. H{"žinutę": "Nėra duomenų, kuriuos reikia ištrinti"})
grąžinti
	}
c. JSON (http. BūsenaSukurta, džinas. H{"žinutę": "Straipsnis sėkmingai ištrintas", "Duomenys": res})
}

Šis kodas ištrina įrašą naudodamas DeleteOne funkcija. Jis taip pat naudoja rezultatas. Ištrintas skaičius ypatybę, kad kodas nebūtų paleistas, jei duomenų bazė tuščia arba objekto ID neteisingas.

Sukurkite API Runner failą

Galiausiai sukurkite a pagrindinis.go savo projekto šakniniame kataloge. Jūsų galutinė projekto struktūra turėtų atrodyti taip:

Šis failas tvarko kiekvieno galutinio taško maršrutizatoriaus vykdymą:

paketą pagrindinis
importuoti (
 maršrutai "CRUD_API/maršrutai"
"github.com/gin-gonic/gin"
)


func pagrindinis(){
 maršrutizatorius := gin.Numatytas()


maršrutizatorius. POST("/", maršrutai. CreatePost)


// vadinamas localhost: 3000/getOne/{id}
 maršrutizatorius. GET("getOne/:postId", maršrutai. ReadOnePost)


// vadinamas localhost: 3000/atnaujinti/{id}
 maršrutizatorius. PUT("/update/:postId", maršrutai. UpdatePost)


// vadinamas localhost: 3000/Ištrinti/{id}
 maršrutizatorius. IŠTRINTI("/Ištrinti/:postId", maršrutai. Ištrinti įrašą)
maršrutizatorius. Vykdyti ("vietinis šeimininkas: 3000")
}

Šis failas yra pagrindinis paketas, kuriame veikia kiti failai. Jis prasideda importuojant maršruto tvarkykles. Kitas yra maršrutizatorius kintamasis, a džinas egzempliorius, kuris iššaukia HTTP veiksmus ir iškviečia kiekvieną galinį tašką jo funkcijos pavadinimu iš maršrutai paketą.

Jūsų CRUD projektas tęsiasi vietinis šeimininkas: 3000. Norėdami paleisti serverį ir išbandykite CRUD API, paleiskite šią komandą pagrindiniame kataloge:

eikpaleistipagrindinis.eik

Paverskite savo Golang CRUD projektą tinkamu produktu

Jūs sėkmingai sukūrėte CRUD API su Go; sveikinu! Nors tai nedidelis projektas, matėte, ko reikia norint vykdyti įprastas HTTP užklausas naudojant „Go“.

Galite tapti kūrybiškesni, išplėtę tai į praktiškesnę programą, kuri suteikia vartotojams vertę. Go yra tinkama programavimo kalba įvairiems naudojimo atvejams.