गो में HTTP रिक्वेस्ट कैसे करें

वर्ल्ड वाइड वेब के कामकाज को नियंत्रित करने वाले मूलभूत सिद्धांतों में से एक अनुरोधों और प्रतिक्रियाओं का आदान-प्रदान है। जब आप किसी वेब पेज तक पहुँचने के लिए अनुरोध भेजते हैं, तो सर्वर उपयुक्त डेटा के साथ प्रतिक्रिया करता है।

विभिन्न प्रकार के इंटरनेट संचार को नियंत्रित करने वाले लोकप्रिय प्रोटोकॉल में शामिल हैं एचटीटीपी (हाइपरटेक्स्ट परहस्त शिष्टाचार), एफ़टीपी (फाइल ट्रांसफर प्रोटोकॉल), और एसएमटीपी (सरल डाक स्थानांतरण प्रोटोकॉल)।

HTTP वह प्रोटोकॉल है जिसका उपयोग आप आमतौर पर तब करते हैं जब आप कोई वेबसाइट देखते हैं या वेब-सक्षम ऐप का उपयोग करते हैं। आप गो सहित कई प्रोग्रामिंग भाषाओं के HTTP अनुरोधों के साथ भी काम कर सकते हैं।

HTTP अनुरोध क्या है?

HTTP परिभाषित करता है कि कैसे क्लाइंट, जैसे वेब ब्राउज़र, सर्वर को अनुरोध भेजते हैं जो प्रतिक्रिया देता है। एक HTTP अनुरोध में उस संसाधन के बारे में जानकारी होती है जिसे क्लाइंट एक्सेस करने का प्रयास कर रहा है। अनुरोध संदेश में आमतौर पर एक URL शामिल होता है जो संसाधन और अन्य वैकल्पिक डेटा जैसे हेडर और क्वेरी पैरामीटर की पहचान करता है।

वहाँ हैं कई प्रकार के HTTP अनुरोध, जिसमें GET, POST, PUT, DELETE, HEAD, OPTIONS, और CONNECT शामिल हैं। पहले चार विधि प्रकार सबसे आम हैं; वे क्रमशः CRUD संचालन को पढ़ते हैं, बनाते हैं, अद्यतन करते हैं और हटाते हैं।

PUT अनुरोध प्रकार का उपयोग अक्सर PATCH अनुरोध प्रकार के साथ परस्पर विनिमय के लिए किया जाता है। वे एक ही उद्देश्य प्राप्त करते हैं, वे केवल उस डेटा में भिन्न होते हैं जिसमें वे अनुरोध को शामिल करने की अपेक्षा करते हैं।

सामान्य HTTP विधियों का उपयोग करके अनुरोध भेजना

गो बिल्ट-इन है एचटीटीपी पैकेट कार्यों और संरचनाओं का एक सेट प्रदान करता है जिसका उपयोग आप वेब सर्वर बनाने और HTTP अनुरोधों को प्रबंधित करने के लिए कर सकते हैं। यह एक बहुत ही मजबूत पैकेज है और सभी गो वेब फ्रेमवर्क किसी न किसी तरह से इसके ऊपर निर्मित होते हैं। यह गो का उप-पैकेज है जाल पैकेट।

गो में HTTP अनुरोध बनाने के लिए, आप इसका उपयोग कर सकते हैं एचटीटीपी। नई विनती() कार्य करें और उपयुक्त विधि, URL, हेडर और अनुरोध निकाय सेट करें। रिक्वेस्ट क्रिएट करने के बाद आप गो का इस्तेमाल कर सकते हैं नेट/एचटीटीपी पैकेज का एचटीटीपी। ग्राहक{} इसे चलाने और प्रतिक्रिया प्राप्त करने के लिए संरचना।

निम्नलिखित कोड नमूने उपयोग करते हैं reqres.in, HTTP अनुरोधों के परीक्षण के लिए सार्वजनिक रूप से उपलब्ध API। आप अपने गो प्रोग्राम में GET, POST, PUT और DELETE अनुरोधों का परीक्षण करने के लिए इसका उपयोग कर सकते हैं।

पोस्ट अनुरोध

नीचे दिया गया कोड एक ऐसा फ़ंक्शन है जो एक POST अनुरोध भेजता है /api/users नाम और नौकरी के साथ एक नया उपयोगकर्ता बनाने के लिए reqres.in का समापन बिंदु।

पैकेट मुख्य
आयात (
"बाइट्स"
"एन्कोडिंग/जेसन"
"एफएमटी"
"आईओ"
"नेट/एचटीटीपी"
)
समारोहउपयोगकर्ता बनाइये(नाम, नौकरी डोरी) {
 fmt. प्रिंटलन("उपयोगकर्ता बना रहा है...")
 एपीयूआरएल := " https://reqres.in/api/users"
 उपयोगकर्ता डेटा: = []बाइट(`{"नाम":"` + नाम + `", "नौकरी":"` + नौकरी + `"}`)
// नया http अनुरोध बनाएं
 अनुरोध, त्रुटि: = http. नई विनती("डाक", एपीआईयूआरएल, बाइट्स. न्यूबफ़र (उपयोगकर्ता डेटा))
 अनुरोध। शीर्ष लेख। तय करना("सामग्री प्रकार", "आवेदन/जेसन; वर्णसेट = यूटीएफ -8")
// अनुरोध भेजें
 क्लाइंट := &http. ग्राहक{}
 प्रतिक्रिया, त्रुटि: = क्लाइंट। करना (अनुरोध)
अगर त्रुटि! = शून्य {
 fmt. Println (त्रुटि)
 }
 प्रतिक्रिया शरीर, त्रुटि: = io. सभी पढ़ें (प्रतिक्रिया। शरीर)
अगर त्रुटि! = शून्य {
 fmt. Println (त्रुटि)
 }
 स्वरूपित डेटा: = प्रारूप JSON (प्रतिक्रिया बॉडी)
 fmt. प्रिंटलन("दर्जा: ", जवाब। दर्जा)
 fmt. प्रिंटलन("प्रतिक्रिया निकाय:", स्वरूपित डेटा)
// निष्पादन के बाद मेमोरी को साफ करें
आस्थगित करें जवाब। शरीर। बंद करना()
}

प्रारूपJSON एक कस्टम फ़ंक्शन है जिसे आप आउटपुट डेटा को स्वरूपित करने के लिए लिख सकते हैं। यहां बताया गया है कि आप इसे कैसे लागू कर सकते हैं:

// कार्य JSON डेटा स्वरूपित करने के लिए
समारोहप्रारूपJSON(आंकड़े []बाइट)डोरी {
वर आउट बाइट्स। बफर
 त्रुटि: = json. इंडेंट (और बाहर, डेटा, "", " ")
अगर गलती! = शून्य {
 fmt. प्रिंट्लन (इरेट)
 }
 घ:= बाहर। बाइट्स ()
वापस करनाडोरी(डी)
}

आप कॉल कर सकते हैं उपयोगकर्ता बनाइये() इस तरह एक कार्यक्रम में कार्य करें:

समारोहमुख्य() {
 fmt. प्रिंटलन("पोस्ट अनुरोध किया जा रहा है...")
 उपयोगकर्ता बनाइये("टिम ओमोलाना", "लेखक")
}

जब आप टर्मिनल में प्रोग्राम चलाते हैं, तो जाओ दौड़ो कमांड, आपको इस तरह का आउटपुट दिखाई देगा:

अनुरोध प्राप्त करें

निम्नलिखित कोड एक फ़ंक्शन है जो एक उपयोगकर्ता को उनकी विशिष्ट आईडी का उपयोग करके reqres.in सर्वर से पुनर्प्राप्त करने के लिए एक GET अनुरोध भेजता है।

// main.go
समारोहgetUser(पहचान डोरी) {
 fmt. प्रिंटलन("आईडी द्वारा उपयोगकर्ता प्राप्त करना ...")
// आईडी द्वारा उपयोगकर्ता प्राप्त करने के लिए एपीआई के लिए अनुरोध प्राप्त करें
 एपीयूआरएल := " https://reqres.in/api/users/" + आईडी
 अनुरोध, त्रुटि: = http. नई विनती("पाना", एपीआईयूआरएल, शून्य)
अगर त्रुटि! = शून्य {
 fmt. Println (त्रुटि)
 }
 अनुरोध। शीर्ष लेख। तय करना("सामग्री प्रकार", "आवेदन/जेसन; वर्णसेट = यूटीएफ -8")
 क्लाइंट := &http. ग्राहक{}
 प्रतिक्रिया, त्रुटि: = क्लाइंट। करना (अनुरोध)
अगर त्रुटि! = शून्य {
 fmt. Println (त्रुटि)
 }
 प्रतिक्रिया शरीर, त्रुटि: = io. सभी पढ़ें (प्रतिक्रिया। शरीर)
अगर त्रुटि! = शून्य {
 fmt. Println (त्रुटि)
 }
 स्वरूपित डेटा: = प्रारूप JSON (प्रतिक्रिया बॉडी)
 fmt. प्रिंटलन("दर्जा: ", जवाब। दर्जा)
 fmt. प्रिंटलन("प्रतिक्रिया निकाय:", स्वरूपित डेटा)
// निष्पादन के बाद मेमोरी को साफ करें
आस्थगित करें जवाब। शरीर। बंद करना()
}

एक जीईटी अनुरोध सर्वर को डेटा नहीं भेजता है, इसलिए जब यह बनाया जाता है तो यह सर्वर को अनुरोध निकाय को स्वीकार या भेजता नहीं है। यहाँ ऊपर दिए गए फ़ंक्शन के लिए एक उदाहरण कॉल कैसा दिखेगा:

समारोहमुख्य() {
 fmt. प्रिंटलन("अनुरोध प्राप्त करना ...")
 गेटयूजर("2")
}

आउटपुट:

पुट रिक्वेस्ट

PUT अनुरोध POST अनुरोध के समान है क्योंकि यह सर्वर को डेटा भी भेजता है। मुख्य अंतर यह है कि POST एक नया संसाधन बनाता है जबकि PUT मौजूदा संसाधन को अपडेट करता है।

यहाँ एक PUT अनुरोध का कार्यान्वयन है:

// main.go
समारोहupdateUser(नाम, नौकरी, आईडी डोरी) {
 fmt. प्रिंटलन("उपयोगकर्ता अपडेट कर रहा है...")
// उपयोगकर्ता को अपडेट करने के लिए एपीआई को पुट अनुरोध करें
 एपीयूआरएल := " https://reqres.in/api/users/" + आईडी
 उपयोगकर्ता डेटा: = []बाइट(`{"नाम":"` + नाम + `", "नौकरी":"` + नौकरी + `"}`)
// नया http पुट अनुरोध बनाएं
 अनुरोध, त्रुटि: = http. नई विनती("रखना", एपीआईयूआरएल, बाइट्स. न्यूबफ़र (उपयोगकर्ता डेटा))
 अनुरोध। शीर्ष लेख। तय करना("सामग्री प्रकार", "आवेदन/जेसन; वर्णसेट = यूटीएफ -8")
// शेष फ़ंक्शन बॉडी createUser फ़ंक्शन से ...
// अनुरोध करें, प्रतिक्रिया प्राप्त करें, और स्मृति साफ़ करें...
}

इस कोड से, आप देख सकते हैं कि ऊपर दिए गए PUT अनुरोध और POST अनुरोध के बीच केवल विधि का नाम और URL का अंतर है। मौजूदा डेटा को अपडेट करने के लिए PUT का उपयोग करते समय, आपको आईडी को अनुरोध URL में जोड़ना होगा। इस समारोह के लिए एक नमूना कॉल इस तरह दिखेगा:

फंक मेन () {
// आईडी के साथ प्रविष्टि अपडेट करें 2.
 अद्यतन उपयोगकर्ता ("टिम न्यूनाम", "स्टाफ लेखक", "2")
}

उपरोक्त कोड उपयोगकर्ता को अद्यतन करता है और निम्न आउटपुट उत्पन्न करता है:

अनुरोध हटा दें

वेब सर्वर पर डिलीट ऑपरेशन करने के लिए DELETE अनुरोध विधि का उपयोग करें। हटाने का अनुरोध URI द्वारा पहचाने गए संसाधन को हटा देता है। गो में एक डिलीट अनुरोध इस तरह दिखता है:

समारोहउपभोक्ता मिटायें(पहचान डोरी) {
 fmt. प्रिंटलन("उपयोगकर्ता को हटाया जा रहा है...")
// उपयोगकर्ता को हटाने के लिए API से DELETE अनुरोध करें
 एपीयूआरएल := " https://reqres.in/api/users/" + आईडी
// नया http अनुरोध बनाएं
 अनुरोध, त्रुटि: = http. नई विनती("मिटाना", एपीआईयूआरएल, शून्य)
 अनुरोध। शीर्ष लेख। तय करना("सामग्री प्रकार", "आवेदन/जेसन; वर्णसेट = यूटीएफ -8")
 क्लाइंट := &http. ग्राहक{}
 प्रतिक्रिया, त्रुटि: = क्लाइंट। करना (अनुरोध)
अगर त्रुटि! = शून्य {
 fmt. Println (त्रुटि)
 }
 fmt. प्रिंटलन("दर्जा: ", जवाब। दर्जा)
}

DELETE अनुरोध न तो किसी निकाय को स्वीकार करता है और न ही वापस करता है, इसलिए JSON अनुरोध और प्रतिक्रिया निकाय को पार्स या प्रारूपित करने की कोई आवश्यकता नहीं है। प्रतिक्रिया केवल सफलता या विफलता को इंगित करने वाली स्थिति लौटाती है। फ़ंक्शन के लिए नमूना कॉल इसके आउटपुट के साथ कैसा दिखता है:

समारोहमुख्य() {
 fmt. प्रिंटलन("हटाने का अनुरोध किया जा रहा है...")
 उपभोक्ता मिटायें("2")
}

आउटपुट:

के प्रयोग से समय की बचत करें एचटीटीपी। डाक() और एचटीटीपी। पाना() तरीकों से नेट/एचटीटीपी बनाने के लिए पैकेज डाक और पाना का उपयोग किए बिना सीधे अनुरोध करता है नई विनती() समारोह और ग्राहक{} अलग से अनुरोध बनाने और बनाने के लिए संरचना। इसकी जाँच पड़ताल करो नेट/एचटीटीपी दस्तावेज अधिक जानकारी के लिए।

गो एप्लिकेशन में HTTP अनुरोध करना

एचटीटीपी गो में पैकेज HTTP अनुरोध करने और गो अनुप्रयोगों में प्रतिक्रियाओं को संभालने के लिए आवश्यक सब कुछ प्रदान करता है। पैकेज द्वारा प्रदान किए गए कार्य और संरचनाएं आपको GET, POST, PUT, DELETE, और कई अन्य प्रकार के अनुरोध बनाने और भेजने में सक्षम बनाती हैं।

इससे गो में वेब एप्लिकेशन बनाना आसान हो जाता है जो अन्य वेब सेवाओं और एपीआई के साथ इंटरैक्ट कर सकता है। पाने का अच्छा तरीका है गो में HTTP अनुरोध करने से अधिक परिचित एक एप्लिकेशन का निर्माण करना है जो किसी अन्य REST API के लिए अनुरोध करता है आपका अपना।