గోలాంగ్ యొక్క జిన్ మరియు మొంగోడిబితో CRUD APIని ఎలా సృష్టించాలి

గోలాంగ్ యొక్క జిన్ మరియు మొంగోడిబితో CRUD APIని ఎలా సృష్టించాలి

అనేక అప్లికేషన్‌లతో అత్యధికంగా చెల్లించే, డిమాండ్ ఉన్న ప్రోగ్రామింగ్ భాషల్లో గోలాంగ్ ఒకటి. జిన్, రెవెల్ మరియు గొరిల్లా/మక్స్ వంటి ఫ్రేమ్‌వర్క్‌లతో జత చేసినప్పుడు, మీరు గోతో సులభంగా APIని సృష్టించవచ్చు.





Gin HTTP ఫ్రేమ్‌వర్క్‌ని ఉపయోగించి గోలాంగ్‌లో CRUD APIని ఎలా సృష్టించాలో తెలుసుకోండి.





రోజు యొక్క వీడియోను తయారు చేయండి

ప్రారంభ సెటప్ మరియు ఇన్‌స్టాలేషన్

గోలాంగ్‌తో ప్రారంభించండి మీరు ఇప్పటికే అలా చేయకుంటే దాన్ని మీ కంప్యూటర్‌లో ఇన్‌స్టాల్ చేయడం ద్వారా.





ఇన్‌స్టాల్ చేసిన తర్వాత, మీ మెషీన్‌లో ప్రాజెక్ట్ రూట్ ఫోల్డర్‌ను సృష్టించడం మరియు ఆ రూట్ డైరెక్టరీలో గో మాడ్యూల్‌ను ప్రారంభించడం తదుపరి దశ.

దీన్ని చేయడానికి, తెరవండి ఒక CLI , మీ ప్రాజెక్ట్ రూట్ ఫోల్డర్‌కి నావిగేట్ చేసి, అమలు చేయండి:



go mod init module_name 

మీరు మీ మాడ్యూల్ పేరును చూస్తారు (ఉదా. CRUD_API ) మరియు మీరు తెరిచినప్పుడు దాని వెర్షన్ go.mod ఫైల్. అన్ని అనుకూల ప్యాకేజీలు ఈ పేరెంట్ మాడ్యూల్ నుండి వస్తాయి. కాబట్టి ఏదైనా దిగుమతి చేయబడిన అనుకూల ప్యాకేజీ రూపం తీసుకుంటుంది:

4k 2018 కోసం ఉత్తమ hdmi కేబుల్
import(package CRUD_API/package-directory-name)

తర్వాత, CRUD APIని సృష్టించడానికి అవసరమైన ప్యాకేజీలను ఇన్‌స్టాల్ చేయండి. ఈ సందర్భంలో, ఉపయోగించండి జిన్ గోనిక్ API ముగింపు పాయింట్లను రూట్ చేయడానికి:





go get github.com/gin-gonic/gin 

ఇప్పుడు డేటాను నిల్వ చేయడానికి MongoDB డ్రైవర్‌ను ఇన్‌స్టాల్ చేయండి:

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

మొంగోడిబికి ఎలా కనెక్ట్ చేయాలి

డేటాబేస్‌తో గోలాంగ్‌ని కనెక్ట్ చేయడానికి మీకు కావలసిందల్లా మీ MongoDB URI. మీరు స్థానికంగా MongoDB అట్లాస్‌కి కనెక్ట్ చేస్తున్నట్లయితే ఇది సాధారణంగా ఇలా కనిపిస్తుంది:





Mongo_URL = "mongodb://127.0.0.1:27017"

ఇప్పుడు మీ ప్రాజెక్ట్ రూట్ డైరెక్టరీలో కొత్త ఫోల్డర్‌ని సృష్టించి, దానికి కాల్ చేయండి డేటాబేస్లు . ఈ ఫోల్డర్ లోపల గో ఫైల్‌ని సృష్టించి, దానికి పేరు పెట్టండి database.go .

ఇది మీ డేటాబేస్ ప్యాకేజీ, మరియు ఇది అవసరమైన లైబ్రరీలను దిగుమతి చేయడం ద్వారా ప్రారంభమవుతుంది:

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
}

a లో డేటాబేస్ కనెక్షన్ స్ట్రింగ్ వంటి ఎన్విరాన్మెంట్ వేరియబుల్స్‌ను దాచడం ఉత్తమ పద్ధతి .env ఫైల్ dotenv ప్యాకేజీని ఉపయోగించి . ఇది మీ కోడ్‌ను మరింత పోర్టబుల్‌గా చేస్తుంది మరియు aని ఉపయోగిస్తున్నప్పుడు ఉపయోగపడుతుంది MongoDB క్లౌడ్ క్లస్టర్ ఉదాహరణ , ఉదాహరణకి.

ది కనెక్ట్డిబి ఫంక్షన్ కనెక్షన్‌ని ఏర్పరుస్తుంది మరియు కొత్త MongoDB క్లయింట్ ఆబ్జెక్ట్‌ను అందిస్తుంది.

డేటాబేస్ సేకరణను సృష్టించండి

MongoDB సేకరణలలో డేటాను నిల్వ చేస్తుంది, ఇది అంతర్లీన డేటాబేస్ డేటాకు ఇంటర్‌ఫేస్‌ను అందిస్తుంది.

సేకరణ-పొందడం కార్యాచరణను నిర్వహించడానికి, కొత్త ఫోల్డర్‌ని సృష్టించడం ద్వారా ప్రారంభించండి, సేకరణ , మీ ప్రాజెక్ట్ రూట్‌లో. ఇప్పుడు కొత్త Go ఫైల్‌ని సృష్టించండి, getCollection.go , ఇది డేటాబేస్ నుండి సేకరణను పొందుతుంది:

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
}

ఈ ఫంక్షన్ MongoDB డేటాబేస్ నుండి సేకరణను పొందుతుంది. ఈ సందర్భంలో డేటాబేస్ పేరు myGoappDB , తో పోస్ట్‌లు దాని సేకరణగా.

డేటాబేస్ మోడల్‌ను సృష్టించండి

మీ రూట్ డైరెక్టరీ లోపల కొత్త ఫోల్డర్‌ని తయారు చేసి, దానికి కాల్ చేయండి మోడల్ . ఈ ఫోల్డర్ మీ డేటాబేస్ మోడల్‌ను నిర్వహిస్తుంది.

ఆ ఫోల్డర్ లోపల కొత్త Go ఫైల్‌ని సృష్టించి, దానికి కాల్ చేయండి మోడల్.గో . మీ మోడల్, ఈ సందర్భంలో, దాని శీర్షికతో కూడిన బ్లాగ్ పోస్ట్:

package model 

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

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

Goతో CRUD APIని సృష్టిస్తోంది

తదుపరిది CRUD API సృష్టి. ఈ విభాగంతో ప్రారంభించడానికి, మీ ముగింపు పాయింట్‌లను నిర్వహించడానికి మీ ప్రాజెక్ట్ రూట్ డైరెక్టరీలో కొత్త ఫోల్డర్‌ను రూపొందించండి. కాల్ చేయండి మార్గాలు .

ప్రతి చర్య కోసం ఈ ఫోల్డర్‌లో ప్రత్యేక Go ఫైల్‌ని సృష్టించండి. ఉదాహరణకు, మీరు వాటిని పేరు పెట్టవచ్చు సృష్టించు.గో , చదవండి.వెళ్ళు , update.go , మరియు delete.go . మీరు ఈ హ్యాండ్లర్‌లను ఎగుమతి చేస్తారు మార్గాలు ప్యాకేజీ.

గోలో POST ఎండ్‌పాయింట్‌ను ఎలా సృష్టించాలి

డేటాబేస్‌లో డేటాను వ్రాయడానికి POST ముగింపు బిందువును నిర్వచించడం ద్వారా ప్రారంభించండి.

మీరు సోషల్ మీడియా నుండి నిష్క్రమించినప్పుడు ఏమి జరుగుతుంది

లోపల మార్గాలు/create.go , కింది వాటిని జోడించండి:

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

ప్రాజెక్ట్ యొక్క అనుకూల మాడ్యూల్‌లను దిగుమతి చేయడం ద్వారా ఈ కోడ్ ప్రారంభమవుతుంది. ఇది తర్వాత సహా థర్డ్-పార్టీ ప్యాకేజీలను దిగుమతి చేస్తుంది జిన్ మరియు మొంగోడిబి డ్రైవర్ .

ఇంకా, పోస్ట్ సేకరణ డేటాబేస్ సేకరణను కలిగి ఉంది. ముఖ్యంగా, c.BindJSON('పోస్ట్') ప్రతి మోడల్ ఫీల్డ్‌ని ఇలా పిలిచే JSONified మోడల్ ఉదాహరణ పోస్ట్ పేలోడ్ ; ఇది డేటాబేస్‌లోకి వెళుతుంది.

GET ఎండ్‌పాయింట్‌ను ఎలా సృష్టించాలి

GET ముగింపు పాయింట్, ఇన్ మార్గాలు/read.go , డేటాబేస్ నుండి దాని ప్రత్యేక 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 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})
}

ది పోస్ట్‌లు వేరియబుల్ అనేది పారామీటర్ డిక్లరేషన్. ఇది పత్రం యొక్క ఆబ్జెక్ట్ IDని పొందుతుంది objId .

అయితే, ఫలితం డేటాబేస్ మోడల్ యొక్క ఒక ఉదాహరణ, ఇది తర్వాత తిరిగి వచ్చిన పత్రాన్ని కలిగి ఉంటుంది res .

PUT ఎండ్‌పాయింట్‌ను ఎలా సృష్టించాలి

PUT హ్యాండ్లర్, ఇన్ మార్గాలు/update.go , POST హ్యాండ్లర్‌ను పోలి ఉంటుంది. ఈసారి, ఇది ఇప్పటికే ఉన్న పోస్ట్‌ని దాని ప్రత్యేక ఆబ్జెక్ట్ 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})
}

మోడల్ ఉదాహరణ యొక్క JSON ఫార్మాట్ ( పోస్ట్ ) డేటాబేస్ నుండి ప్రతి మోడల్ ఫీల్డ్‌ను కాల్ చేస్తుంది. ఫలితం వేరియబుల్ MongoDBని ఉపయోగిస్తుంది $ సెట్ ఆపరేటర్ దాని ఆబ్జెక్ట్ ID ద్వారా పిలువబడే అవసరమైన పత్రాన్ని నవీకరించడానికి.

ది ఫలితం. సరిపోలిన గణన డేటాబేస్‌లో రికార్డు లేకుంటే లేదా పాస్ చేసిన ID చెల్లని పక్షంలో కోడ్‌ని అమలు చేయకుండా షరతు నిరోధిస్తుంది.

xbox one కంట్రోలర్ బటన్‌లు పని చేయడం లేదు

DELETE ఎండ్‌పాయింట్‌ని సృష్టిస్తోంది

ముగింపు బిందువును తొలగించు, in delete.go , URL పారామీటర్‌గా పాస్ చేసిన ఆబ్జెక్ట్ ID ఆధారంగా పత్రాన్ని తీసివేస్తుంది:

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

ఈ కోడ్ ఉపయోగించి రికార్డ్‌ను తొలగిస్తుంది ఒకటి తొలగించు ఫంక్షన్. ఇది కూడా ఉపయోగిస్తుంది ఫలితం. తొలగించబడిన కౌంట్ డేటాబేస్ ఖాళీగా ఉంటే లేదా ఆబ్జెక్ట్ ID చెల్లుబాటు కాకుంటే కోడ్ అమలు కాకుండా నిరోధించడానికి ఆస్తి.

API రన్నర్ ఫైల్‌ను సృష్టించండి

చివరగా, aని సృష్టించండి ప్రధాన.గో మీ ప్రాజెక్ట్ రూట్ డైరెక్టరీ లోపల. మీ చివరి ప్రాజెక్ట్ నిర్మాణం ఇలా ఉండాలి:

  గోలాంగ్ CRUD ప్రాజెక్ట్ నిర్మాణం

ఈ ఫైల్ ప్రతి ఎండ్ పాయింట్ కోసం రూటర్ అమలును నిర్వహిస్తుంది:

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

ఈ ఫైల్ ఇతర ఫైల్‌లను అమలు చేసే ప్రధాన ప్యాకేజీ. ఇది రూట్ హ్యాండ్లర్‌లను దిగుమతి చేసుకోవడం ద్వారా ప్రారంభమవుతుంది. తదుపరిది రూటర్ వేరియబుల్, a జిన్ HTTP చర్యలను ప్రేరేపిస్తుంది మరియు ప్రతి ముగింపు బిందువును దాని ఫంక్షన్ పేరుతో పిలుస్తుంది మార్గాలు ప్యాకేజీ.

మీ CRUD ప్రాజెక్ట్ అమలులో ఉంది స్థానిక హోస్ట్:3000 . సర్వర్‌ని అమలు చేయడానికి మరియు CRUD APIని పరీక్షించండి , మీ బేస్ డైరెక్టరీలో కింది ఆదేశాన్ని అమలు చేయండి:

go run main.go

మీ గోలాంగ్ CRUD ప్రాజెక్ట్‌ను ఉపయోగించగల ఉత్పత్తిగా మార్చండి

మీరు గోతో CRUD APIని విజయవంతంగా సృష్టించారు; అభినందనలు! ఇది చిన్న ప్రాజెక్ట్ అయినప్పటికీ, గోలో సాధారణ HTTP అభ్యర్థనలను అమలు చేయడానికి ఏమి అవసరమో మీరు చూసారు.

వినియోగదారులకు విలువను అందించే మరింత ఆచరణాత్మక అప్లికేషన్‌గా దీన్ని విస్తరించడం ద్వారా మీరు మరింత సృజనాత్మకతను పొందవచ్చు. గో అనేది అనేక రకాల వినియోగ సందర్భాలకు తగిన ప్రోగ్రామింగ్ భాష.