गोलांग के जिन और मोंगोडीबी के साथ एक सीआरयूडी एपीआई कैसे बनाएं

गोलंग कई अनुप्रयोगों के साथ शीर्ष-भुगतान, इन-डिमांड प्रोग्रामिंग भाषाओं में से एक है। जब Gin, Revel, और gorilla/mux जैसे चौखटे के साथ जोड़ा जाता है, तो आप आसानी से Go के साथ एक API बना सकते हैं।

Gin HTTP फ्रेमवर्क का उपयोग करके गोलांग में CRUD API बनाने का तरीका जानें।

---

---

दिन का मेकअप वीडियो

प्रारंभिक सेटअप और स्थापना

Golang . के साथ शुरुआत करें यदि आपने पहले से ऐसा नहीं किया है तो इसे अपने कंप्यूटर पर इंस्टॉल करके।

एक बार इंस्टॉल हो जाने पर, अगला चरण आपकी मशीन पर प्रोजेक्ट रूट फ़ोल्डर बनाना और उस रूट निर्देशिका में गो मॉड्यूल को प्रारंभ करना है।

ऐसा करने के लिए, खोलें एक सीएलआई , अपने प्रोजेक्ट रूट फ़ोल्डर में नेविगेट करें और चलाएं:

go mod init module_name 

आपको अपना मॉड्यूल नाम दिखाई देगा (उदा. सीआरयूडी_एपीआई ) और इसका संस्करण जब आप खोलते हैं गो.मोड फ़ाइल। सभी कस्टम पैकेज इस पैरेंट मॉड्यूल से आएंगे। तो कोई भी आयातित कस्टम पैकेज फॉर्म लेता है:

import(package CRUD_API/package-directory-name)

इसके बाद, सीआरयूडी एपीआई बनाने के लिए आवश्यक पैकेज स्थापित करें। इस मामले में, उपयोग करें जिन गोनिक एपीआई समापन बिंदुओं को रूट करने के लिए:

---

---

go get github.com/gin-gonic/gin 

अब डेटा स्टोर करने के लिए MongoDB ड्राइवर स्थापित करें:

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

कैसे कनेक्ट करें MongoDB पर जाएं

गोलंग को डेटाबेस से जोड़ने के लिए आपको बस अपने MongoDB URI की आवश्यकता है। यदि आप स्थानीय रूप से MongoDB एटलस से जुड़ रहे हैं तो यह आमतौर पर ऐसा दिखता है:

---

---

Mongo_URL = "mongodb://127.0.0.1:27017"

अब अपने प्रोजेक्ट रूट डायरेक्टरी में एक नया फोल्डर बनाएं और उसे कॉल करें डेटाबेस . इस फोल्डर के अंदर एक गो फाइल बनाएं और उसे नाम दें डेटाबेस.गो .

यह आपका डेटाबेस पैकेज है, और यह आवश्यक पुस्तकालयों को आयात करके शुरू होता है:

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 
} 

डेटाबेस कनेक्शन स्ट्रिंग जैसे पर्यावरण चर को छिपाने के लिए यह सबसे अच्छा अभ्यास है .env फ़ाइल dotenv पैकेज का उपयोग करना . यह आपके कोड को अधिक पोर्टेबल बनाता है और a . का उपयोग करते समय काम आता है MongoDB क्लाउड क्लस्टर उदाहरण , उदाहरण के लिए।

विंडोज़ मीडिया प्लेयर पर वीडियो घुमाना

कनेक्टडीबी फ़ंक्शन एक कनेक्शन स्थापित करता है और एक नया MongoDB क्लाइंट ऑब्जेक्ट देता है।

डेटाबेस संग्रह बनाएं

MongoDB संग्रह में डेटा संग्रहीत करता है, जो अंतर्निहित डेटाबेस डेटा को एक इंटरफ़ेस प्रदान करता है।

संग्रह-प्राप्त करने की कार्यक्षमता को संभालने के लिए, एक नया फ़ोल्डर बनाकर प्रारंभ करें, संग्रह , आपके प्रोजेक्ट रूट में। अब एक नई गो फाइल बनाएं, 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 , साथ पदों इसके संग्रह के रूप में।

डेटाबेस मॉडल बनाएं

अपनी रूट डायरेक्टरी के अंदर एक नया फोल्डर बनाएं और उसे कॉल करें नमूना . यह फ़ोल्डर आपके डेटाबेस मॉडल को संभालता है।

उस फोल्डर के अंदर एक नई गो फाइल बनाएं और उसे कॉल करें model.go . आपका मॉडल, इस मामले में, एक ब्लॉग पोस्ट है जिसका शीर्षक है:

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

Go . के साथ CRUD API बनाना

अगला सीआरयूडी एपीआई निर्माण है। इस खंड के साथ शुरू करने के लिए, अपने अंतिम बिंदुओं को संभालने के लिए अपनी प्रोजेक्ट रूट निर्देशिका में एक नया फ़ोल्डर बनाएं। इसे कहते हैं मार्गों .

प्रत्येक क्रिया के लिए इस फ़ोल्डर में एक अलग गो फ़ाइल बनाएँ। उदाहरण के लिए, आप उन्हें नाम दे सकते हैं create.go , read.go , update.go , तथा Delete.go . आप इन हैंडलर्स को इस रूप में निर्यात करेंगे मार्गों पैकेट।

गो में पोस्ट एंडपॉइंट कैसे बनाएं

डेटाबेस में डेटा लिखने के लिए POST समापन बिंदु को परिभाषित करके प्रारंभ करें।

अंदर मार्ग / create.go , निम्नलिखित जोड़ें:

फ्लैश ड्राइव से विंडोज़ 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}}) 
} 

यह कोड प्रोजेक्ट के कस्टम मॉड्यूल को आयात करके शुरू होता है। इसके बाद यह तृतीय-पक्ष पैकेज आयात करता है जिसमें शामिल हैं जिन तथा मोंगोडीबी चालक .

आगे, पोस्ट संग्रह डेटाबेस संग्रह रखता है। विशेष रूप से, c.BindJSON ('पोस्ट') एक JSONified मॉडल उदाहरण है जो प्रत्येक मॉडल फ़ील्ड को कॉल करता है पोस्टपेलोड ; यह डेटाबेस में जाता है।

GET समापन बिंदु कैसे बनाएं

GET समापन बिंदु, in मार्ग/read.go , डेटाबेस से किसी एक दस्तावेज़ को उसकी विशिष्ट आईडी के माध्यम से पढ़ता है। यह कस्टम और तृतीय-पक्ष पैकेज आयात करके भी शुरू होता है:

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

पदों चर एक पैरामीटर घोषणा है। यह एक दस्तावेज़ की वस्तु आईडी के रूप में प्राप्त करता है objId .

हालांकि, नतीजा डेटाबेस मॉडल का एक उदाहरण है, जो बाद में लौटाए गए दस्तावेज़ को इस रूप में रखता है रेस .

पुट एंडपॉइंट कैसे बनाएं

पुट हैंडलर, में मार्ग/update.go , POST हैंडलर के समान है। इस बार, यह किसी मौजूदा पोस्ट को उसकी विशिष्ट ऑब्जेक्ट आईडी द्वारा अपडेट करता है:

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 का उपयोग करता है $सेट ऑपरेटर अपने ऑब्जेक्ट आईडी द्वारा बुलाए गए एक आवश्यक दस्तावेज़ को अद्यतन करने के लिए।

परिणाम.मिलान गणना यदि डेटाबेस में कोई रिकॉर्ड नहीं है या पास की गई आईडी अमान्य है, तो स्थिति कोड को चलने से रोकती है।

एक DELETE समापन बिंदु बनाना

DELETE समापन बिंदु, में Delete.go , 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}) 
} 

यह कोड का उपयोग करके एक रिकॉर्ड हटाता है एक हटाएं समारोह। यह का भी उपयोग करता है परिणाम। हटाई गई गणना यदि डेटाबेस खाली है या ऑब्जेक्ट आईडी अमान्य है तो कोड को चलने से रोकने के लिए संपत्ति।

एपीआई रनर फाइल बनाएं

अंत में, एक बनाएं main.go अपने प्रोजेक्ट रूट डायरेक्टरी के अंदर। आपकी अंतिम परियोजना संरचना इस तरह दिखनी चाहिए:

यह फ़ाइल प्रत्येक समापन बिंदु के लिए राउटर निष्पादन को संभालती है:

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

यह फ़ाइल मुख्य पैकेज है जो अन्य फ़ाइलों को चलाता है। यह रूट हैंडलर आयात करके शुरू होता है। अगला है रूटर चर, ए जिन उदाहरण जो HTTP क्रियाओं को उद्घाटित करता है और प्रत्येक समापन बिंदु को उसके फ़ंक्शन नाम से कॉल करता है मार्गों पैकेट।

कार्य प्रबंधक विंडोज़ 10 डिस्क 100

आपका सीआरयूडी प्रोजेक्ट चालू रहता है लोकलहोस्ट: 3000 . सर्वर चलाने के लिए और सीआरयूडी एपीआई का परीक्षण करें , अपनी मूल निर्देशिका में निम्न आदेश चलाएँ:

go run main.go

अपने गोलंग सीआरयूडी प्रोजेक्ट को उपयोगी उत्पाद में बदलें

आपने गो के साथ सफलतापूर्वक एक सीआरयूडी एपीआई बना लिया है; बधाई हो! हालांकि यह एक छोटी परियोजना है, आपने देखा है कि गो में नियमित HTTP अनुरोधों को निष्पादित करने में क्या लगता है।

आप इसे अधिक व्यावहारिक अनुप्रयोग में विस्तारित करके अधिक रचनात्मक हो सकते हैं जो उपयोगकर्ताओं को मूल्य प्रदान करता है। कई उपयोग के मामलों के लिए गो एक उपयुक्त प्रोग्रामिंग भाषा है।