Kaip sukurti CRUD API naudojant „Golang's Gin“ ir „MongoDB“.

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ą.

---

---

DIENOS VAIZDO ĮRAŠO PAGALBA

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 module_name 

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:

import(package CRUD_API/package-directory-name)

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

---

---

go get github.com/gin-gonic/gin 

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

go get 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:

---

---

kiek duomenų naudoja „YouTube“ televizija

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:

package database 
  
import ( 
	"context" 
	"fmt" 
	"log" 
	"time" 
	"go.mongodb.org/mongo-driver/mongo" 
	"go.mongodb.org/mongo-driver/mongo/options" 
) 
  
func ConnectDB() *mongo.Client { 
	Mongo_URL := "mongodb://127.0.0.1:27017" 
	client, err := mongo.NewClient(options.Client().ApplyURI(Mongo_URL)) 
  
	if err != nil { 
		log.Fatal(err) 
	} 
  
	ctx, cancel := context.WithTimeout(context.Background(), 10 * time.Second) 
	err = client.Connect(ctx) 
	defer cancel() 
  
	if err != nil { 
		log.Fatal(err) 
	} 
  
	fmt.Println("Connected to mongoDB") 
	return client 
} 

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.

kaip padaryti ekrano kopiją „snapchat“, niekam nežinant

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:

package getcollection 
  
import ( 
	"go.mongodb.org/mongo-driver/mongo" 
) 
  
func GetCollection(client *mongo.Client, collectionName string) *mongo.Collection { 
	collection := client.Database("myGoappDB").Collection("Posts") 
	return collection 
} 

Š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:

package model 
  
import ( 
	"go.mongodb.org/mongo-driver/bson/primitive" 
) 
  
type Post struct { 
	ID      primitive.ObjectID 
	Title   string 
	Article string 
}

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:

package routes 
  
import ( 
	getcollection "CRUD_API/Collection" 
	database "CRUD_API/databases" 
	model "CRUD_API/model" 
	"context" 
	"log" 
	"net/http" 
	"time" 
	"github.com/gin-gonic/gin" 
	"go.mongodb.org/mongo-driver/bson/primitive" 
) 
  
func CreatePost(c *gin.Context) { 
	var DB = database.ConnectDB() 
	var postCollection = getcollection.GetCollection(DB, "Posts") 
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) 
	post := new(model.Posts) 
	defer cancel() 
  
	if err := c.BindJSON(&post); err != nil { 
		c.JSON(http.StatusBadRequest, gin.H{"message": err}) 
		log.Fatal(err) 
		return 
	} 
  
	postPayload := model.Posts{ 
		Id:      primitive.NewObjectID(), 
		Title:   post.Title, 
		Article: post.Article, 
	} 
  
	result, err := postCollection.InsertOne(ctx, postPayload) 
  
	if err != nil { 
		c.JSON(http.StatusInternalServerError, gin.H{"message": err}) 
		return 
	} 
  
	c.JSON(http.StatusCreated, gin.H{"message": "Posted successfully", "Data": map[string]interface{}{"data": result}}) 
} 

Š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('post') 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:

package routes 
  
import ( 
	getcollection "CRUD_API/Collection" 
	database "CRUD_API/databases" 
	model "CRUD_API/model" 
	"context" 
	"net/http" 
	"time" 
	"github.com/gin-gonic/gin" 
	"go.mongodb.org/mongo-driver/bson" 
	"go.mongodb.org/mongo-driver/bson/primitive" 
) 
  
func ReadOnePost(c *gin.Context) { 
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) 
	var DB = database.ConnectDB() 
	var postCollection = getcollection.GetCollection(DB, "Posts") 
  
	postId := c.Param("postId") 
	var result model.Posts 
  
	defer cancel() 
  
	objId, _ := primitive.ObjectIDFromHex(postId) 
  
	err := postCollection.FindOne(ctx, bson.M{"id": objId}).Decode(&result) 
  
	res := map[string]interface{}{"data": result} 
  
	if err != nil { 
		c.JSON(http.StatusInternalServerError, gin.H{"message": err}) 
		return 
	} 
  
	c.JSON(http.StatusCreated, gin.H{"message": "success!", "Data": res}) 
} 

The pranešimų kintamasis yra parametrų deklaracija. Jis gauna dokumento objekto ID kaip objId .

kaip padaryti, kad žaidimai veiktų greičiau „Android“

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:

package routes 
  
import ( 
	getcollection "CRUD_API/Collection" 
	database "CRUD_API/databases" 
	model "CRUD_API/model" 
	"context" 
	"net/http" 
	"time" 
	"github.com/gin-gonic/gin" 
	"go.mongodb.org/mongo-driver/bson" 
	"go.mongodb.org/mongo-driver/bson/primitive" 
) 
  
func UpdatePost(c *gin.Context) { 
	ctx, cancel := context.WithTimeout(context.Background(), 10 * time.Second) 
	var DB = database.ConnectDB() 
	var postCollection = getcollection.GetCollection(DB, "Posts") 
  
	postId := c.Param("postId") 
	var post model.Posts 
  
	defer cancel() 
  
	objId, _ := primitive.ObjectIDFromHex(postId) 
  
	if err := c.BindJSON(&post); err != nil { 
		c.JSON(http.StatusInternalServerError, gin.H{"message": err}) 
		return 
	} 
  
	edited := bson.M{"title": post.Title, "article": post.Article} 
  
	result, err := postCollection.UpdateOne(ctx, bson.M{"id": objId}, bson.M{"$set": edited}) 
  
	res := map[string]interface{}{"data": result} 
  
	if err != nil { 
		c.JSON(http.StatusInternalServerError, gin.H{"message": err}) 
		return 
	} 
  
	if result.MatchedCount < 1 { 
		c.JSON(http.StatusInternalServerError, gin.H{"message": "Data doesn't exist"}) 
		return 
	} 
  
	c.JSON(http.StatusCreated, gin.H{"message": "data updated successfully!", "Data": 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:

package routes 
  
import ( 
	getcollection "CRUD_API/Collection" 
	database "CRUD_API/databases" 
	"context" 
	"net/http" 
	"time" 
	"github.com/gin-gonic/gin" 
	"go.mongodb.org/mongo-driver/bson" 
	"go.mongodb.org/mongo-driver/bson/primitive" 
) 
  
func DeletePost(c *gin.Context) { 
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) 
	var DB = database.ConnectDB() 
	postId := c.Param("postId") 
  
	var postCollection = getcollection.GetCollection(DB, "Posts")  
	defer cancel() 
	objId, _ := primitive.ObjectIDFromHex(postId)  
	result, err := postCollection.DeleteOne(ctx, bson.M{"id": objId})  
	res := map[string]interface{}{"data": result} 
  
	if err != nil { 
		c.JSON(http.StatusInternalServerError, gin.H{"message": err}) 
		return 
	} 
  
	if result.DeletedCount < 1 { 
		c.JSON(http.StatusInternalServerError, gin.H{"message": "No data to delete"}) 
		return 
	} 
  
	c.JSON(http.StatusCreated, gin.H{"message": "Article deleted successfully", "Data": 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ą:

package main 
  
import ( 
    routes "CRUD_API/routes" 
    "github.com/gin-gonic/gin" 
) 
  
func main() { 
    router := gin.Default() 
  
    router.POST("/", routes.CreatePost) 
  
    // called as localhost:3000/getOne/{id} 
    router.GET("getOne/:postId", routes.ReadOnePost) 
  
    // called as localhost:3000/update/{id} 
    router.PUT("/update/:postId", routes.UpdatePost) 
  
    // called as localhost:3000/delete/{id} 
    router.DELETE("/delete/:postId", routes.DeletePost) 
  
    router.Run("localhost: 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 Localhost: 3000 . Norėdami paleisti serverį ir išbandykite CRUD API , paleiskite šią komandą pagrindiniame kataloge:

go run main.go

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.