Golang je eden najbolje plačanih in zahtevanih programskih jezikov s številnimi aplikacijami. V kombinaciji z ogrodji, kot so Gin, Revel in gorilla/mux, lahko preprosto ustvarite API z Go.
Naučite se ustvariti CRUD API v Golangu z uporabo ogrodja Gin HTTP.
Začetna nastavitev in namestitev
Začnite z Golangom tako, da ga namestite v svoj računalnik, če tega še niste storili.
Ko je nameščen, je naslednji korak ustvariti korensko mapo projekta na vašem računalniku in inicializirati modul Go v tem korenskem imeniku.
Če želite to narediti, odprite CLI, se pomaknite do korenske mape projekta in zaženite:
go mod init ime_modula
Videli boste ime svojega modula (npr. CRUD_API) in njegovo različico, ko odprete go.mod mapa. Vsi paketi po meri bodo izhajali iz tega nadrejenega modula. Vsak uvožen paket po meri ima torej obliko:
uvoz(paket CRUD_API/paket-ime-imenika)Nato namestite pakete, potrebne za ustvarjanje API-ja CRUD. V tem primeru uporabite Gin Gonic za usmerjanje končnih točk API-ja:
pojdi dobiti github.com/gin-gonic/gin
Zdaj namestite gonilnik MongoDB za shranjevanje podatkov:
pojdi dobiti go.mongodb.org/mongo-driver/mongoKako se povezati Pojdite na MongoDB
Vse, kar potrebujete, je vaš MongoDB URI za povezavo Golanga z bazo podatkov. Če se lokalno povezujete z MongoDB Atlas, je običajno videti takole:
Mongo_URL = "mongodb://127.0.0.1:27017"Zdaj ustvarite novo mapo v korenskem imeniku projekta in jo pokličite baze podatkov. V tej mapi ustvarite datoteko Go in jo poimenujte baza podatkov.go.
To je vaš paket baze podatkov in začne se z uvozom zahtevanih knjižnic:
paket zbirka podatkovuvoz (
"kontekstu"
"fmt"
"dnevnik"
"čas"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)funk ConnectDB() *mongo. Stranka {
Mongo_URL := "mongodb://127.0.0.1:27017"
stranka, napaka := mongo. NewClient (možnosti. Client().ApplyURI(Mongo_URL))if err != nil {
dnevnik.Usodno(napaka)
}ctx, prekliči := kontekst. WithTimeout (kontekst. Ozadje(), 10 * čas. drugič)
napaka = stranka. Poveži (ctx)
odloži prekliči()if err != nil {
dnevnik.Usodno(napaka)
}
fmt. Println("Povezan z mongoDB")
vrnitev stranka
}
Najboljša praksa je, da spremenljivke okolja, kot je povezovalni niz baze podatkov, skrijete v a .env mapa z uporabo paketa dotenv. Zaradi tega je vaša koda bolj prenosljiva in je uporabna pri uporabi a Primerek gruče v oblaku MongoDB, na primer.
The ConnectDB funkcija vzpostavi povezavo in vrne nov objekt MongoDB Client.
Ustvari zbirko podatkovnih baz
MongoDB shranjuje podatke v zbirke, ki zagotavljajo vmesnik do osnovnih podatkov baze podatkov.
Za upravljanje funkcije pridobivanja zbirke začnite z ustvarjanjem nove mape, Zbirka, v korenu vašega projekta. Zdaj ustvarite novo datoteko Go, getCollection.go, ki pridobi zbirko iz baze podatkov:
paket getcollectionuvoz (
"go.mongodb.org/mongo-driver/mongo"
)
funkGetCollection(stranka *mongo.Stranka, collectionNamevrvica) *mongo.Zbirka {
zbirka := stranka. Baza podatkov ("myGoappDB").Zbirka("Objave")
vrnitev zbirka
}
Ta funkcija pridobi zbirko iz baze podatkov MongoDB. Ime baze podatkov je v tem primeru myGoappDB, z Objave kot svojo zbirko.
Ustvarite model baze podatkov
Ustvarite novo mapo v korenskem imeniku in jo pokličite model. Ta mapa obravnava vaš model baze podatkov.
V tej mapi ustvarite novo datoteko Go in jo pokličite model.go. Vaš model je v tem primeru objava v spletnem dnevniku z naslovom:
paket modeluvoz (
"go.mongodb.org/mongo-driver/bson/primitive"
)
vrsta Objavi strukturo {
IDprimitiven.ObjectID
Naslovni niz
Niz člena
}
Ustvarjanje API-ja CRUD z Go
Sledi ustvarjanje API-ja CRUD. Če želite začeti s tem razdelkom, ustvarite novo mapo znotraj korenskega imenika vašega projekta za upravljanje končnih točk. Pokliči poti.
Za vsako dejanje v tej mapi ustvarite ločeno datoteko Go. Lahko jih na primer poimenujete create.go, preberi.pojdi, posodobitev.go, in delete.go. Te upravljalnike boste izvozili kot poti paket.
Kako ustvariti končno točko POST v Go
Začnite z definiranjem končne točke POST za zapisovanje podatkov v bazo podatkov.
V notranjosti routes/create.go, dodajte naslednje:
paket potiuvoz (
getcollection "CRUD_API/Zbirka"
zbirka podatkov "CRUD_API/baze podatkov"
model "CRUD_API/model"
"kontekstu"
"dnevnik"
"net/http"
"čas"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson/primitive"
)funk CreatePost(c *gin. kontekst){
var DB = baza podatkov. ConnectDB()
var postCollection = getcollection. GetCollection (DB, "Objave")
ctx, prekliči := kontekst. WithTimeout (kontekst. Ozadje(), 10*čas. drugič)
objava := novo(model. objave)
odloži prekliči()če je napaka := c. BindJSON(&post); napaka != nič {
c. JSON(http. StatusBadRequest, gin. H{"sporočilo": napaka})
dnevnik.Usodno(napaka)
vrnitev
}postPayload := model. Objave{
Id: primitiven.NewObjectID(),
Naslov: post.Naslov,
Članek: post.Članek,
}rezultat, napaka := postCollection. InsertOne (ctx, postPayload)
if err != nil {
c. JSON(http. StatusInternalServerError, gin. H{"sporočilo": napaka})
vrnitev
}
c. JSON(http. Stanje ustvarjeno, gin. H{"sporočilo": "Uspešno objavljeno", "podatki": zemljevid[string]vmesnik{}{"podatke": rezultat}})
}
Ta koda se začne z uvozom modulov po meri projekta. Nato uvozi pakete tretjih oseb, vključno z gin in Gonilnik MongoDB.
Nadalje, postCollection hrani zbirko podatkovnih baz. Zlasti c. BindJSON("objava") je primerek modela JSON, ki kliče vsako polje modela kot postPayload; to gre v bazo podatkov.
Kako ustvariti končno točko GET
Končna točka GET, v routes/read.go, prebere en sam dokument iz baze podatkov prek njegovega edinstvenega ID-ja. Začne se tudi z uvozom paketov po meri in paketov tretjih oseb:
paket potiuvoz (
getcollection "CRUD_API/Zbirka"
zbirka podatkov "CRUD_API/baze podatkov"
model "CRUD_API/model"
"kontekstu"
"net/http"
"čas"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)funk ReadOnePost(c *gin. kontekst){
ctx, prekliči := kontekst. WithTimeout (kontekst. Ozadje(), 10*čas. drugič)
var DB = baza podatkov. ConnectDB()
var postCollection = getcollection. GetCollection (DB, "Objave")postId := c. Param("postId")
var model rezultata. Objaveodloži prekliči()
objId, _ := primitiven. ObjectIDFromHex (postId)
napaka := postCollection. FindOne (ctx, bson. M{"id": objId}).Decode(&rezultat)
res := zemljevid[niz]vmesnik{}{"podatki": rezultat}
if err != nil {
c. JSON(http. StatusInternalServerError, gin. H{"sporočilo": napaka})
vrnitev
}
c. JSON(http. Stanje ustvarjeno, gin. H{"sporočilo": "uspeh!", "podatki":res})
}
The postId spremenljivka je deklaracija parametra. ID predmeta dokumenta dobi kot objId.
vendar rezultat je primerek modela baze podatkov, ki pozneje hrani vrnjeni dokument kot res.
Kako ustvariti končno točko PUT
Obravnavalnik PUT, v routes/update.go, je podoben upravljalniku POST. Tokrat posodobi obstoječo objavo z edinstvenim ID-jem objekta:
paket potiuvoz (
getcollection "CRUD_API/Zbirka"
zbirka podatkov "CRUD_API/baze podatkov"
model "CRUD_API/model"
"kontekstu"
"net/http"
"čas"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)funk UpdatePost(c *gin. kontekst){
ctx, prekliči := kontekst. WithTimeout (kontekst. Ozadje(), 10 * čas. drugič)
var DB = baza podatkov. ConnectDB()
var postCollection = getcollection. GetCollection (DB, "Objave")postId := c. Param("postId")
var post model. Objaveodloži prekliči()
objId, _ := primitiven. ObjectIDFromHex (postId)
če je napaka := c. BindJSON(&post); napaka != nič {
c. JSON(http. StatusInternalServerError, gin. H{"sporočilo": napaka})
vrnitev
}urejeno := bson. M{"naslov": post. Naslov, "Članek": post. Članek}
rezultat, napaka := postCollection. UpdateOne (ctx, bson. M{"id": objId}, bson. M{"$set": urejeno})
res := zemljevid[niz]vmesnik{}{"podatki": rezultat}
if err != nil {
c. JSON(http. StatusInternalServerError, gin. H{"sporočilo": napaka})
vrnitev
}če rezultat. MatchedCount < 1 {
c. JSON(http. StatusInternalServerError, gin. H{"sporočilo": "Podatki ne'ne obstaja"})
vrnitev
}
c. JSON(http. Stanje ustvarjeno, gin. H{"sporočilo": "podatki so bili uspešno posodobljeni!", "podatki":res})
}
Format JSON primerka modela (post) pokliče vsako polje modela iz baze podatkov. Spremenljivka rezultata uporablja MongoDB $set operater za posodobitev zahtevanega dokumenta, ki ga kliče njegov ID objekta.
The rezultat. MatchedCount pogoj prepreči izvajanje kode, če v bazi podatkov ni nobenega zapisa ali če je posredovani ID neveljaven.
Ustvarjanje končne točke DELETE
Končna točka DELETE, v delete.go, odstrani dokument na podlagi ID-ja predmeta, posredovanega kot parameter URL:
paket potiuvoz (
getcollection "CRUD_API/Zbirka"
zbirka podatkov "CRUD_API/baze podatkov"
"kontekstu"
"net/http"
"čas"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)funk DeletePost(c *gin. kontekst){
ctx, prekliči := kontekst. WithTimeout (kontekst. Ozadje(), 10*čas. drugič)
var DB = baza podatkov. ConnectDB()
postId := c. Param("postId")var postCollection = getcollection. GetCollection (DB, "Objave")
odloži prekliči()
objId, _ := primitiven. ObjectIDFromHex (postId)
rezultat, napaka := postCollection. DeleteOne (ctx, bson. M{"id": objId})
res := zemljevid[niz]vmesnik{}{"podatki": rezultat}if err != nil {
c. JSON(http. StatusInternalServerError, gin. H{"sporočilo": napaka})
vrnitev
}če rezultat. DeletedCount < 1 {
c. JSON(http. StatusInternalServerError, gin. H{"sporočilo": "Ni podatkov za brisanje"})
vrnitev
}
c. JSON(http. Stanje ustvarjeno, gin. H{"sporočilo": "Članek uspešno izbrisan", "podatki":res})
}
Ta koda izbriše zapis z uporabo DeleteOne funkcijo. Uporablja tudi rezultat. DeletedCount lastnost, ki preprečuje izvajanje kode, če je baza podatkov prazna ali je ID objekta neveljaven.
Ustvarite datoteko API Runner
Končno ustvarite a main.go znotraj korenskega imenika vašega projekta. Vaša končna struktura projekta bi morala izgledati takole:
Ta datoteka obravnava izvajanje usmerjevalnika za vsako končno točko:
paket glavniuvoz (
poti "CRUD_API/routes"
"github.com/gin-gonic/gin"
)funk glavni(){
usmerjevalnik := gin.Privzeto()usmerjevalnik. OBJAVI("/", poti. CreatePost)
// imenovan kot lokalni gostitelj: 3000/getOne/{id}
usmerjevalnik. GET("getOne/:postId", poti. ReadOnePost)// imenovan kot lokalni gostitelj: 3000/nadgradnja/{id}
usmerjevalnik. PUT("/update/:postId", poti. UpdatePost)// imenovan kot lokalni gostitelj: 3000/izbrisati/{id}
usmerjevalnik. DELETE("/izbrisati/:postId", poti. Izbriši objavo)
usmerjevalnik. Zaženi ("lokalni gostitelj: 3000")
}
Ta datoteka je glavni paket, ki poganja druge datoteke. Začne se z uvozom upravljavcev poti. Naslednja je usmerjevalnik spremenljivka, a gin primerek, ki prikliče dejanja HTTP in pokliče vsako končno točko z imenom funkcije iz poti paket.
Vaš projekt CRUD teče naprej lokalni gostitelj: 3000. Za zagon strežnika in preizkusite CRUD API, zaženite naslednji ukaz v svojem osnovnem imeniku:
pojditečiglavni.pojdiSpremenite svoj projekt Golang CRUD v uporaben izdelek
Uspešno ste ustvarili CRUD API z Go; čestitke! Čeprav je to manjši projekt, ste videli, kaj je potrebno za izvajanje običajnih zahtev HTTP v Go.
Lahko postanete bolj ustvarjalni, če to razširite v bolj praktično aplikacijo, ki uporabnikom prinaša vrednost. Go je primeren programski jezik za vrsto primerov uporabe.
