Kako stvoriti CRUD API s Golangovim Ginom i MongoDB-om

Kako stvoriti CRUD API s Golangovim Ginom i MongoDB-om

Golang je jedan od najplaćenijih i traženih programskih jezika s mnogo aplikacija. U kombinaciji s okvirima kao što su Gin, Revel i gorilla/mux, možete jednostavno izraditi API s Go-om.





Naučite kako stvoriti CRUD API u Golangu pomoću Gin HTTP okvira.





MAKEUSEOF VIDEO DANA

Početno postavljanje i instalacija

Započnite s Golangom tako da ga instalirate na svoje računalo ako to već niste učinili.





Nakon instalacije, sljedeći korak je stvaranje korijenske mape projekta na vašem računalu i inicijalizacija Go modula u tom korijenskom direktoriju.

Da biste to učinili, otvorite a CLI , dođite do korijenske mape projekta i pokrenite:



go mod init module_name 

Vidjet ćete naziv svog modula (npr. CRUD_API ) i njegovu verziju kada otvorite go.mod datoteka. Svi prilagođeni paketi dolazit će iz ovog nadređenog modula. Dakle, svaki uvezeni prilagođeni paket ima oblik:

import(package CRUD_API/package-directory-name)

Zatim instalirajte pakete potrebne za stvaranje CRUD API-ja. U ovom slučaju, koristite Gin Gonic za usmjeravanje API krajnjih točaka:





go get github.com/gin-gonic/gin 

Sada instalirajte MongoDB Driver za pohranu podataka:

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

Kako se povezati Idite na MongoDB

Sve što trebate je vaš MongoDB URI za povezivanje Golanga s bazom podataka. Obično izgleda ovako ako se povezujete na MongoDB Atlas lokalno:





Mongo_URL = "mongodb://127.0.0.1:27017"

Sada stvorite novu mapu u korijenskom direktoriju vašeg projekta i pozovite je baze podataka . Stvorite Go datoteku unutar ove mape i dajte joj naziv baza podataka.go .

Ovo je vaš paket baze podataka i počinje uvozom potrebnih biblioteka:

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
}

Najbolja je praksa sakriti varijable okruženja poput niza povezivanja baze podataka u a .env datoteka pomoću paketa dotenv . To čini vaš kod prenosivijim i korisnim kada koristite a Instanca MongoDB klastera u oblaku , na primjer.

The ConnectDB funkcija uspostavlja vezu i vraća novi objekt MongoDB klijenta.

Stvorite zbirku baze podataka

MongoDB pohranjuje podatke u zbirkama, koje pružaju sučelje za temeljne podatke baze podataka.

Za rukovanje funkcijom dohvaćanja zbirke, počnite stvaranjem nove mape, Kolekcija , u korijenu vašeg projekta. Sada izradite novu Go datoteku, getCollection.go , koji dobiva kolekciju iz baze podataka:

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
}

Ova funkcija dobiva kolekciju iz MongoDB baze podataka. Naziv baze podataka, u ovom slučaju, je myGoappDB , sa Postovi kao svoju zbirku.

Stvorite model baze podataka

Napravite novu mapu unutar svog korijenskog direktorija i pozovite je model . Ova mapa upravlja vašim modelom baze podataka.

Stvorite novu Go datoteku unutar te mape i pozovite je model.ići . Vaš je model, u ovom slučaju, post na blogu s naslovom:

package model 

import (
"go.mongodb.org/mongo-driver/bson/primitive"
)

type Post struct {
ID primitive.ObjectID
Title string
Article string
}

Stvaranje CRUD API-ja uz Go

Sljedeće je stvaranje CRUD API-ja. Da biste započeli s ovim odjeljkom, napravite novu mapu unutar korijenskog direktorija vašeg projekta za rukovanje krajnjim točkama. Nazovi to rute .

Stvorite zasebnu Go datoteku u ovoj mapi za svaku radnju. Na primjer, možete ih imenovati stvoriti.krenuti , čitati.ići , ažuriraj.kreni , i izbrisati.krenuti . Ove rukovatelje ćete izvesti kao rute paket.

Kako stvoriti krajnju točku POST-a u Go

Započnite definiranjem POST krajnje točke za upisivanje podataka u bazu podataka.

Unutra rute/create.go , dodajte sljedeće:

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

Ovaj kôd počinje uvozom prilagođenih modula projekta. Zatim uvozi pakete trećih strana uključujući Džin i MongoDB upravljački program .

Unaprijediti, postCollection čuva zbirku baze podataka. Posebno, c.BindJSON('post') je JSONificirana instanca modela koja poziva svako polje modela kao postPayload ; ovo ide u bazu podataka.

Kako stvoriti GET krajnju točku

GET krajnja točka, u rute/read.go , čita jedan dokument iz baze podataka preko njegovog jedinstvenog ID-a. Također počinje uvozom prilagođenih paketa i paketa trećih strana:

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 postovi varijabla je deklaracija parametra. Dobiva ID objekta dokumenta kao objId .

Međutim, proizlaziti je instanca modela baze podataka, koja kasnije čuva vraćeni dokument kao res .

Kako stvoriti krajnju točku PUT

Rukovatelj PUT, u rute/ažuriranje.go , sličan je POST rukovatelju. Ovaj put ažurira postojeću objavu svojim jedinstvenim ID-om 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})
}

JSON format instance modela ( objaviti ) poziva svako polje modela iz baze podataka. Varijabla rezultata koristi MongoDB $set operator za ažuriranje traženog dokumenta koji se poziva njegovim ID-om objekta.

The rezultat.MatchedCount uvjet sprječava izvođenje koda ako u bazi podataka nema zapisa ili je proslijeđeni ID nevažeći.

Stvaranje krajnje točke DELETE

Krajnja točka DELETE, u izbrisati.krenuti , uklanja dokument na temelju ID-a objekta proslijeđenog kao URL parametar:

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

Ovaj kod briše zapis pomoću DeleteOne funkcija. Također koristi rezultat.DeletedCount svojstvo za sprječavanje izvođenja koda ako je baza podataka prazna ili je ID objekta nevažeći.

Stvorite datoteku API Runner

Na kraju, stvorite a glavni.krenuti unutar korijenskog direktorija vašeg projekta. Vaša konačna struktura projekta trebala bi izgledati ovako:

  Struktura Golang CRUD projekta

Ova datoteka upravlja izvršavanjem usmjerivača za svaku krajnju točku:

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

Ova datoteka je glavni paket koji pokreće druge datoteke. Započinje uvozom rukovatelja rutama. Sljedeće je ruter varijabla, a džin instanca koja evocira HTTP radnje i poziva svaku krajnju točku prema nazivu funkcije iz rute paket.

Vaš CRUD projekt radi dalje lokalni host: 3000 . Za pokretanje poslužitelja i testirajte CRUD API , pokrenite sljedeću naredbu u svom osnovnom direktoriju:

mogu li baciti na xbox one
go run main.go

Pretvorite svoj Golang CRUD projekt u upotrebljiv proizvod

Uspješno ste izradili CRUD API s Goom; Čestitamo! Iako je ovo manji projekt, vidjeli ste što je potrebno za izvršavanje uobičajenih HTTP zahtjeva u Gou.

Možete postati kreativniji ako ovo proširite na praktičniju aplikaciju koja donosi vrijednost korisnicima. Go je prikladan programski jezik za niz slučajeva upotrebe.