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

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

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

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

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

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

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

गो मॉड इनिट मॉड्यूल_नाम

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

आयात(पैकेट सीआरयूडी_एपीआई/पैकेट-निर्देशिका-नाम)

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

जाओ प्राप्त github.com/gin-gonic/gin

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

जाओ प्राप्त go.mongodb.org/mongo-driver/mongo

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

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

मोंगो_यूआरएल = "मोंगोडब: //127.0.0.1:27017"

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

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

पैकेट डेटाबेस
आयात (
"संदर्भ"
"एफएमटी"
"लकड़ी का लट्ठा"
"समय"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
समारोह कनेक्टडीबी() *मोंगो. ग्राहक {
	Mongo_URL := "मोंगोडब: //127.0.0.1:27017"
	ग्राहक, त्रुटि: = mongo. न्यू क्लाइंट (विकल्प। क्लाइंट ()। लागू करें (Mongo_URL))
अगर गलती!= शून्य {
लकड़ी का लट्ठा।घातक(ग़लती होना)
	}
सीटीएक्स, रद्द करें: = संदर्भ। टाइमआउट के साथ (संदर्भ। पृष्ठभूमि (), 10 * समय। दूसरा)
	त्रुटि = ग्राहक। कनेक्ट (सीटीएक्स)
	स्थगित रद्द करें ()
अगर गलती!= शून्य {
लकड़ी का लट्ठा।घातक(ग़लती होना)
	}
एफएमटी प्रिंट्लन("मोंगोडीबी से जुड़ा")
वापसी ग्राहक
}

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

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

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

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

संग्रह-प्राप्त करने की कार्यक्षमता को संभालने के लिए, एक नया फ़ोल्डर बनाकर प्रारंभ करें, संग्रह, आपके प्रोजेक्ट रूट में। अब एक नई गो फाइल बनाएं, getCollection.go, जो डेटाबेस से संग्रह प्राप्त करता है:

पैकेट संग्रह प्राप्त करें
आयात (
"go.mongodb.org/mongo-driver/mongo"
)
समारोहसंग्रह प्राप्त करें(ग्राहक *मोंगो।ग्राहक, संग्रहनामडोरी) *मोंगो।संग्रह {
	संग्रह: = ग्राहक। डेटाबेस("myGoappDB")।संग्रह("पदों")
वापसी संग्रह
}

यह फ़ंक्शन MongoDB डेटाबेस से संग्रह प्राप्त करता है। इस मामले में, डेटाबेस का नाम है myGoappDB, साथ पदों इसके संग्रह के रूप में।

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

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

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

पैकेट नमूना
आयात (
"go.mongodb.org/mongo-driver/bson/primitive"
)
प्रकार पोस्ट स्ट्रक्चर {
पहचानप्राचीन.ऑब्जेक्टआईडी
	शीर्षक स्ट्रिंग
	लेख स्ट्रिंग
}

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

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

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

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

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

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

पैकेट मार्गों
आयात (
	संग्रह प्राप्त करें "CRUD_API/संग्रह"
	डेटाबेस "CRUD_API/डेटाबेस"
	नमूना "CRUD_API/मॉडल"
"संदर्भ"
"लकड़ी का लट्ठा"
"नेट/http"
"समय"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson/primitive"
)
समारोह पोस्ट बनाएं(सी * जिन। संदर्भ){
वर डीबी = डेटाबेस। कनेक्टडीबी ()
	वर पोस्टकोलेक्शन = getCollection. गेटकोलेक्शन (डीबी, "पदों")
	सीटीएक्स, रद्द करें: = संदर्भ। टाइमआउट के साथ (संदर्भ। पृष्ठभूमि (), 10 * समय। दूसरा)
	पोस्ट := नया(नमूना। पोस्ट)
	स्थगित रद्द करें ()
अगर गलती: = सी। बिंदजसन(&पद); गलती! = शून्य {
 सी। जेएसओएन (http. StatusBadRequest, जिन। एच{"संदेश": गलती})
लकड़ी का लट्ठा।घातक(ग़लती होना)
वापसी
	}
पोस्टपेलोड: = मॉडल। पोस्ट{
पहचान: प्राचीन.न्यूऑब्जेक्टआईडी(),
शीर्षक: पद।शीर्षक,
लेख: पद।लेख,
	}
परिणाम, त्रुटि: = पोस्टकोलेक्शन। इंसर्टऑन (सीटीएक्स, पोस्टपेलोड)
अगर गलती!= शून्य {
 सी। जेएसओएन (http. StatusInternalServerError, gin. एच{"संदेश": गलती})
वापसी
	}
सी। जेएसओएन (http. स्थिति निर्मित, जिन। एच{"संदेश": "सफलतापूर्वक पोस्ट किया गया", "जानकारी": नक्शा [स्ट्रिंग] इंटरफ़ेस {}{}"जानकारी": नतीजा}})
}

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

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

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

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

पैकेट मार्गों
आयात (
	संग्रह प्राप्त करें "CRUD_API/संग्रह"
	डेटाबेस "CRUD_API/डेटाबेस"
	नमूना "CRUD_API/मॉडल"
"संदर्भ"
"नेट/http"
"समय"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
समारोह एक पोस्ट पढ़ें(सी * जिन। संदर्भ){
	सीटीएक्स, रद्द करें: = संदर्भ। टाइमआउट के साथ (संदर्भ। पृष्ठभूमि (), 10 * समय। दूसरा)
वर डीबी = डेटाबेस। कनेक्टडीबी ()
	वर पोस्टकोलेक्शन = getCollection. गेटकोलेक्शन (डीबी, "पदों")
पोस्ट आईडी: = सी। परम ("पोस्ट आईडी")
वर परिणाम मॉडल। पदों
स्थगित रद्द करें ()
objId, _:= आदिम। ऑब्जेक्टआईडीफ्रॉमहेक्स (पोस्टआईडी)
त्रुटि: = पोस्टकोलेक्शन। FindOne (ctx, bson. एम{"पहचान": objId})। डीकोड (&नतीजा)
रेस: = नक्शा [स्ट्रिंग]इंटरफेस{}{"डेटा": परिणाम}
अगर गलती!= शून्य {
 सी। जेएसओएन (http. StatusInternalServerError, gin. एच{"संदेश": गलती})
वापसी
	}
सी। जेएसओएन (http. स्थिति निर्मित, जिन। एच{"संदेश": "सफलता!", "जानकारी": रेस})
}

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

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

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

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

पैकेट मार्गों
आयात (
	संग्रह प्राप्त करें "CRUD_API/संग्रह"
	डेटाबेस "CRUD_API/डेटाबेस"
	नमूना "CRUD_API/मॉडल"
"संदर्भ"
"नेट/http"
"समय"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
समारोह अपडेटपोस्ट(सी * जिन। संदर्भ){
	सीटीएक्स, रद्द करें: = संदर्भ। टाइमआउट के साथ (संदर्भ। पृष्ठभूमि (), 10 * समय। दूसरा)
वर डीबी = डेटाबेस। कनेक्टडीबी ()
	वर पोस्टकोलेक्शन = getCollection. गेटकोलेक्शन (डीबी, "पदों")
पोस्ट आईडी: = सी। परम ("पोस्ट आईडी")
वर पोस्ट मॉडल। पदों
स्थगित रद्द करें ()
objId, _:= आदिम। ऑब्जेक्टआईडीफ्रॉमहेक्स (पोस्टआईडी)
अगर गलती: = सी। बिंदजसन(&पद); गलती! = शून्य {
 सी। जेएसओएन (http. StatusInternalServerError, gin. एच{"संदेश": गलती})
वापसी
	}
संपादित: = bson. एम{"शीर्षक": पद। शीर्षक, "लेख": पद। लेख}
परिणाम, त्रुटि: = पोस्टकोलेक्शन। अपडेटऑन (ctx, bson. एम{"पहचान": objId}, bson. एम{"$सेट": संपादित})
रेस: = नक्शा [स्ट्रिंग]इंटरफेस{}{"डेटा": परिणाम}
अगर गलती!= शून्य {
 सी। जेएसओएन (http. StatusInternalServerError, gin. एच{"संदेश": गलती})
वापसी
	}
अगर परिणाम। मिलान गणना < 1 {
 सी। जेएसओएन (http. StatusInternalServerError, gin. एच{"संदेश": "डेटा करता है'टी मौजूद है"})
वापसी
	}
सी। जेएसओएन (http. स्थिति निर्मित, जिन। एच{"संदेश": "डेटा सफलतापूर्वक अपडेट किया गया!", "जानकारी": रेस})
}

मॉडल उदाहरण का एक JSON प्रारूप (पद) डेटाबेस से प्रत्येक मॉडल फ़ील्ड को कॉल करता है। परिणाम चर MongoDB का उपयोग करता है $सेट ऑपरेटर अपने ऑब्जेक्ट आईडी द्वारा बुलाए गए एक आवश्यक दस्तावेज़ को अद्यतन करने के लिए।

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

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

DELETE समापन बिंदु, में Delete.go, URL पैरामीटर के रूप में पारित ऑब्जेक्ट आईडी के आधार पर दस्तावेज़ को निकालता है:

पैकेट मार्गों
आयात (
	संग्रह प्राप्त करें "CRUD_API/संग्रह"
	डेटाबेस "CRUD_API/डेटाबेस"
"संदर्भ"
"नेट/http"
"समय"
"github.com/gin-gonic/gin"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
समारोह पोस्ट को हटाएं(सी * जिन। संदर्भ){
	सीटीएक्स, रद्द करें: = संदर्भ। टाइमआउट के साथ (संदर्भ। पृष्ठभूमि (), 10 * समय। दूसरा)
वर डीबी = डेटाबेस। कनेक्टडीबी ()
	पोस्ट आईडी: = सी। परम ("पोस्ट आईडी")
वर पोस्टकोलेक्शन = getCollection. गेटकोलेक्शन (डीबी, "पदों") 
	स्थगित रद्द करें ()
	objId, _:= आदिम। ऑब्जेक्टआईडीफ्रॉमहेक्स (पोस्टआईडी) 
	परिणाम, त्रुटि: = पोस्टकोलेक्शन। DeleteOne (ctx, bson. एम{"पहचान": objId}) 
	रेस: = नक्शा [स्ट्रिंग]इंटरफेस{}{"डेटा": परिणाम}
अगर गलती!= शून्य {
 सी। जेएसओएन (http. StatusInternalServerError, gin. एच{"संदेश": गलती})
वापसी
	}
अगर परिणाम। हटाई गई गणना < 1 {
 सी। जेएसओएन (http. StatusInternalServerError, gin. एच{"संदेश": "हटाने के लिए कोई डेटा नहीं"})
वापसी
	}
सी। जेएसओएन (http. स्थिति निर्मित, जिन। एच{"संदेश": "लेख सफलतापूर्वक हटाया गया", "जानकारी": रेस})
}

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

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

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

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

पैकेट मुख्य
आयात (
 मार्गों "CRUD_API/मार्ग"
"github.com/gin-gonic/gin"
)
समारोह मुख्य(){
 राउटर: = जिन.चूक()
राउटर। पद("/", मार्ग। पोस्ट बनाएं)
// लोकलहोस्ट कहा जाता है: 3000/getOne/{id}
 राउटर। प्राप्त("getOne/:postId", मार्ग। रीडवनपोस्ट)
// लोकलहोस्ट के रूप में कहा जाता है: 3000/अपडेट करें/{पहचान}
 राउटर। रखना("/update/:postId", मार्ग। अपडेटपोस्ट)
// लोकलहोस्ट के रूप में कहा जाता है: 3000/मिटाना/{पहचान}
 राउटर। मिटाना("/मिटाना/:postId", मार्ग। पोस्ट को हटाएं)
राउटर। दौड़ना("लोकलहोस्ट: 3000")
}

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

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

जाओदौड़नामुख्य।जाओ

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

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

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