Kako ustvariti CRUD API z Golangovim Gin in MongoDB

Kako ustvariti CRUD API z Golangovim Gin in MongoDB

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.



MAKEUSEOF VIDEO DNEVA

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:



netflix, trenutno imamo težave pri igranju tega naslova 
go mod init module_name

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:

import(package CRUD_API/package-directory-name)

Nato namestite pakete, potrebne za ustvarjanje API-ja CRUD. V tem primeru uporabite Gin Gonic za usmerjanje končnih točk API-ja:



go get github.com/gin-gonic/gin

Zdaj namestite gonilnik MongoDB za shranjevanje podatkov:

go get go.mongodb.org/mongo-driver/mongo

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

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 
}

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:

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 
}

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:

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

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:

superfetch z visoko porabo diska windows 10 
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}}) 
}

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:

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

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}) 
}

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:

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}) 
}

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:

Struktura projekta Golang CRUD

Ta datoteka obravnava izvajanje usmerjevalnika za vsako končno točko:

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") 
}

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:

go run main.go

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