😠 👨🏽‍🤝‍👨🏻 🚵🏿 जूलिया। वेब सेवाएँ ➕ 🍖 🕸️

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

ध्यान दें कि जूलिया के युवाओं के कारण, प्रतिस्पर्धी पैकेज का एक सेट है। इसलिए, हम यह पता लगाने की कोशिश करेंगे कि उनका उपयोग कैसे और क्यों करना है। साथ ही, हम उनकी सहायता से समान JSON वेब सेवा के कार्यान्वयन की तुलना करते हैं।

जूलिया का बुनियादी ढांचा पिछले दो साल में सक्रिय रूप से विकसित हुआ है। और, इस मामले में, यह केवल पाठ की एक सुंदर शुरुआत के लिए खुदा हुआ एक ऑन-लाइन वाक्यांश नहीं है, बल्कि इस तथ्य पर जोर है कि सब कुछ तीव्रता से बदल रहा है, और जो कुछ साल पहले प्रासंगिक था वह अब पुराना हो गया है। हालांकि, हम स्थिर पैकेजों को उजागर करने और उनकी मदद से वेब सेवाओं को लागू करने के बारे में सिफारिशें देने का प्रयास करेंगे। निश्चितता के लिए, हम एक वेब सेवा बनाएंगे जो निम्नलिखित प्रारूप में JSON डेटा के साथ POST अनुरोध स्वीकार करती है:

{ "title": "something", "body": "something" }

हम मानते हैं कि हम जो सेवा बनाते हैं वह रेस्टफुल नहीं है। हमारा मुख्य कार्य मार्गों का वर्णन करने और हैंडलर का अनुरोध करने के तरीकों पर ठीक से विचार करना है।

HTTP.jl पैकेज

यह पैकेज जूलिया में HTTP प्रोटोकॉल का मुख्य कार्यान्वयन है और धीरे-धीरे नई सुविधाएँ प्राप्त कर रहा है। HTTP क्लाइंट अनुरोधों को निष्पादित करने के लिए विशिष्ट संरचनाओं और कार्यों को लागू करने के अलावा, यह पैकेज HTTP सर्वर बनाने के लिए कार्यों को भी लागू करता है। उसी समय, जैसा कि यह विकसित होता है, पैकेज में फ़ंक्शन प्राप्त होते हैं जो प्रोग्रामर के लिए हैंडलर रजिस्टर करने के लिए काफी सुविधाजनक बनाते हैं और इस प्रकार, विशिष्ट सेवाओं का निर्माण करते हैं। इसके अलावा, नवीनतम संस्करणों में, WebSocket प्रोटोकॉल के लिए अंतर्निहित समर्थन है, जिसके कार्यान्वयन को पहले एक अलग पैकेज WebSocket.jl के हिस्से के रूप में बनाया गया था। यही है, वर्तमान में, HTTP.jl, एक प्रोग्रामर की अधिकांश जरूरतों को पूरा कर सकता है। अधिक विस्तार से कुछ उदाहरणों पर विचार करें।

HTTP क्लाइंट

हम क्लाइंट कोड के साथ कार्यान्वयन शुरू करते हैं, जिसका उपयोग हम संचालन को सत्यापित करने के लिए करेंगे।

 #!/usr/bin/env julia --project=@. import HTTP import JSON.json const PORT = "8080" const HOST = "127.0.0.1" const NAME = "Jemand" #    struct Document title::String body::String end #         Base.show(r::HTTP.Messages.Response) = println(r.status == 200 ? String(r.body) : "Error: " * r.status) #    r = HTTP.get("http://$(HOST):$(PORT)") show(r) #   /user/:name r = HTTP.get("http://$(HOST):$(PORT)/user/$(NAME)"; verbose=1) show(r) #  JSON- POST- doc = Document("Some document", "Test document with some content.") r = HTTP.post( "http://$(HOST):$(PORT)/resource/process", [("Content-Type" => "application/json")], json(doc); verbose=3) show(r)

HTTP पैकेज ऐसे तरीके प्रदान करता है जो HTTP प्रोटोकॉल कमांड के नाम से मेल खाते हैं। इस मामले में, हम get करते get और post । वैकल्पिक नाम का तर्क verbose आपको डिबगिंग जानकारी की मात्रा को आउटपुट के रूप में सेट करने की अनुमति देता है। तो, उदाहरण के लिए, verbose=1 का उत्पादन होगा:

 GET /user/Jemand HTTP/1.1 HTTP/1.1 200 OK <= (GET /user/Jemand HTTP/1.1)

और verbose=3 के मामले में verbose=3 हमें पहले से ही प्रेषित और प्राप्त डेटा का एक पूरा सेट मिलता है:

 DEBUG: 2019-04-21T22:40:40.961 eb4f ️-> "POST /resource/process HTTP/1.1\r\n" (write) DEBUG: 2019-04-21T22:40:40.961 eb4f ️-> "Content-Type: application/json\r\n" (write) DEBUG: 2019-04-21T22:40:40.961 eb4f ️-> "Host: 127.0.0.1\r\n" (write) DEBUG: 2019-04-21T22:40:40.961 eb4f ️-> "Content-Length: 67\r\n" (write) DEBUG: 2019-04-21T22:40:40.961 eb4f ️-> "\r\n" (write) DEBUG: 2019-04-21T22:40:40.961 e1c6 ️-> "{\"title\":\"Some document\",\"body\":\"Test document with some content.\"}" (unsafe_write) DEBUG: 2019-04-21T22:40:40.963 eb4f ️<- "HTTP/1.1 200 OK\r\n" (readuntil) DEBUG: "Content-Type: application/json\r\n" DEBUG: "Transfer-Encoding: chunked\r\n" DEBUG: "\r\n" DEBUG: 2019-04-21T22:40:40.963 eb4f ️<- "5d\r\n" (readuntil) DEBUG: 2019-04-21T22:40:40.963 eb4f ️<- "{\"body\":\"Test document with some content.\",\"server_mark\":\"confirmed\",\"title\":\"Some document\"}" (unsafe_read) DEBUG: 2019-04-21T22:40:40.968 eb4f ️<- "\r\n" (readuntil) DEBUG: "0\r\n" DEBUG: 2019-04-21T22:40:40.968 eb4f ️<- "\r\n" (readuntil)

भविष्य में, हम केवल verbose=1 उपयोग करेंगे ताकि जो हो रहा है उसके बारे में केवल न्यूनतम जानकारी देखने के लिए।

कोड के बारे में कुछ टिप्पणियां।

 doc = Document("Some document", "Test document with some content.")

चूंकि हमने पहले दस्तावेज़ संरचना (इसके अलावा, अपरिवर्तनीय) की घोषणा की थी, एक निर्माता डिफ़ॉल्ट रूप से इसके लिए उपलब्ध है, जिसके तर्क संरचना के घोषित क्षेत्रों के अनुरूप हैं। इसे JSON में बदलने के लिए, हम JSON.jl पैकेज और इसके json(doc) विधि का उपयोग करते हैं।
टुकड़े पर ध्यान दें:

 r = HTTP.post( "http://$(HOST):$(PORT)/resource/process", [("Content-Type" => "application/json")], json(doc); verbose=3)

चूंकि हम JSON पास कर रहे हैं, इसलिए आपको Content-Type हेडर में स्पष्ट रूप से application/json टाइप करना होगा। शीर्ष लेखों को HTTP.post विधि (हालांकि, अन्य सभी की तरह) में सरणी (प्रकार वेक्टर, लेकिन HTTP.post ) का उपयोग करके हेडर - वैल्यू जोड़े वाले पास दिए जाते हैं।

स्वास्थ्य परीक्षण के लिए, हम तीन प्रश्न करेंगे:

रूट रूट के लिए अनुरोध प्राप्त करें;
प्रारूप / उपयोगकर्ता / नाम में अनुरोध प्राप्त करें, जहां नाम प्रेषित नाम है;
JSON ऑब्जेक्ट के साथ POST अनुरोध / संसाधन / प्रक्रिया पारित हुई। हम एक ही दस्तावेज़ प्राप्त करने की उम्मीद करते हैं, लेकिन server_mark फ़ील्ड के साथ जोड़ा गया।

हम सभी सर्वर कार्यान्वयन विकल्पों का परीक्षण करने के लिए इस क्लाइंट कोड का उपयोग करेंगे।

HTTP सर्वर

आपके द्वारा क्लाइंट का पता लगाने के बाद, सर्वर को लागू करना शुरू करने का समय आ गया है। इसके साथ शुरू करने के लिए, हम केवल HTTP.jl की सहायता से सेवा को मूल विकल्प के रूप में बनाए रखने के लिए HTTP.jl , जिसे अन्य पैकेजों की स्थापना की आवश्यकता नहीं है। हम आपको याद दिलाते हैं कि अन्य सभी पैकेज HTTP.jl उपयोग HTTP.jl

 #!/usr/bin/env julia --project=@. import Sockets import HTTP import JSON #    #    index(req::HTTP.Request) = HTTP.Response(200, "Hello World") #     function welcome_user(req::HTTP.Request) # dump(req) user = "" if (m = match( r".*/user/([[:alpha:]]+)", req.target)) != nothing user = m[1] end return HTTP.Response(200, "Hello " * user) end #  JSON function process_resource(req::HTTP.Request) # dump(req) message = JSON.parse(String(req.body)) @info message message["server_mark"] = "confirmed" return HTTP.Response(200, JSON.json(message)) end #      const ROUTER = HTTP.Router() HTTP.@register(ROUTER, "GET", "/", index) HTTP.@register(ROUTER, "GET", "/user/*", welcome_user) HTTP.@register(ROUTER, "POST", "/resource/process", process_resource) HTTP.serve(ROUTER, Sockets.localhost, 8080)

उदाहरण में, आपको निम्नलिखित कोड पर ध्यान देना चाहिए:

 dump(req)

कंसोल को सब कुछ प्रिंट करता है जिसे ऑब्जेक्ट द्वारा जाना जाता है। जिसमें डेटा प्रकार, मूल्य, साथ ही सभी नेस्टेड फ़ील्ड और उनके मूल्य शामिल हैं। यह विधि पुस्तकालय अनुसंधान और डिबगिंग दोनों के लिए उपयोगी है।

पंक्ति

 (m = match( r".*/user/([[:alpha:]]+)", req.target))

एक नियमित अभिव्यक्ति है जो उस मार्ग को पार्स करती है जिस पर हैंडलर पंजीकृत है। HTTP.jl पैकेज एक मार्ग में एक पैटर्न की पहचान करने के लिए स्वचालित तरीके प्रदान नहीं HTTP.jl ।

process_resource हैंडलर के अंदर, हम उस JSON को पार्स करते हैं जिसे सेवा द्वारा स्वीकार किया जाता है।

 message = JSON.parse(String(req.body))

डेटा req.body फ़ील्ड के माध्यम से पहुँचा है। ध्यान दें कि डेटा बाइट सरणी प्रारूप में आता है। इसलिए, एक स्ट्रिंग के रूप में उनके साथ काम करने के लिए, एक स्ट्रिंग में एक स्पष्ट रूपांतरण किया जाता है। JSON.parse विधि एक JSON.jl पैकेज विधि है जो डेटा को JSON.jl और एक ऑब्जेक्ट का निर्माण करती है। चूंकि इस मामले में वस्तु एक साहचर्य सरणी (डिक्ट) है, हम आसानी से इसमें एक नई कुंजी जोड़ सकते हैं। पंक्ति

 message["server_mark"] = "confirmed"

confirmed गए मान के साथ server_mark कुंजी जोड़ता है।

HTTP.serve(ROUTER, Sockets.localhost, 8080) लाइन HTTP.serve(ROUTER, Sockets.localhost, 8080) होने पर सेवा HTTP.serve(ROUTER, Sockets.localhost, 8080) हो HTTP.serve(ROUTER, Sockets.localhost, 8080) है HTTP.serve(ROUTER, Sockets.localhost, 8080) ।

HTTP.jl पर आधारित सेवा के लिए नियंत्रण प्रतिक्रिया ( verbose=1 के साथ ग्राहक कोड चलाते समय प्राप्त)

 GET / HTTP/1.1 HTTP/1.1 200 OK <= (GET / HTTP/1.1) Hello World GET /user/Jemand HTTP/1.1 HTTP/1.1 200 OK <= (GET /user/Jemand HTTP/1.1) Hello Jemand POST /resource/process HTTP/1.1 HTTP/1.1 200 OK <= (POST /resource/process HTTP/1.1) {"body":"Test document with some content.","server_mark":"confirmed","title":"Some document"}

Hello Jemand verbose=1 साथ डिबगिंग जानकारी की पृष्ठभूमि के खिलाफ, हम स्पष्ट रूप से लाइनें देख सकते हैं: Hello World , Hello Jemand , "server_mark":"confirmed" ।

सेवा कोड देखने के बाद, एक स्वाभाविक प्रश्न उठता है - अगर हमें HTTP में सब कुछ इतना सरल है, तो हमें अन्य सभी पैकेजों की आवश्यकता क्यों है। इसका बहुत ही सरल उत्तर है। HTTP - गतिशील हैंडलर को पंजीकृत करने की अनुमति देता है, लेकिन यहां तक कि एक निर्देशिका से एक स्थिर चित्र फ़ाइल को पढ़ने के लिए एक अलग कार्यान्वयन की आवश्यकता होती है। इसलिए, हम उन पैकेजों पर भी विचार करते हैं जो वेब एप्लिकेशन बनाने पर केंद्रित हैं।

Mux.jl पैकेज

यह पैकेज जूलिया पर लागू वेब अनुप्रयोगों के लिए एक मध्यवर्ती परत के रूप में तैनात है। इसका कार्यान्वयन बहुत हल्का है। हैंडलर का वर्णन करने का एक आसान तरीका प्रदान करना मुख्य उद्देश्य है। यह कहना नहीं है कि परियोजना विकसित नहीं हो रही है, लेकिन यह धीरे-धीरे विकसित हो रही है। हालाँकि, समान मार्गों की सेवा करने वाली हमारी सेवा के लिए कोड देखें।

 #!/usr/bin/env julia --project=@. using Mux using JSON @app test = ( Mux.defaults, page(respond("<h1>Hello World!</h1>")), page("/user/:user", req -> "<h1>Hello, $(req[:params][:user])!</h1>"), route("/resource/process", req -> begin message = JSON.parse(String(req[:data])) @info message message["server_mark"] = "confirmed" return Dict( :body => JSON.json(message), :headers => [("Content-Type" => "application/json")] ) end), Mux.notfound() ) serve(test, 8080) Base.JLOptions().isinteractive == 0 && wait()

यहां page विधि का उपयोग करते हुए मार्गों का वर्णन किया गया है। वेब एप्लिकेशन को @app मैक्रो का उपयोग करके घोषित किया गया है। page विधि के तर्क मार्ग और हैंडलर हैं। एक हैंडलर को एक फ़ंक्शन के रूप में निर्दिष्ट किया जा सकता है जो एक अनुरोध को इनपुट के रूप में स्वीकार करता है, या इसे एक लंबो फ़ंक्शन के रूप में निर्दिष्ट किया जा सकता है। अतिरिक्त उपयोगी कार्यों में से, Mux.notfound() निर्दिष्ट Not found प्रतिक्रिया भेजने के लिए मौजूद है। और क्लाइंट को जो परिणाम भेजा जाना चाहिए, उसे HTTP.Response में पैक करने की आवश्यकता नहीं है, जैसा कि हमने पिछले उदाहरण में किया था, क्योंकि Mux इसे स्वयं करेगा। हालाँकि, आपको अभी भी JSON को स्वयं करना है, जैसा कि प्रतिक्रिया के लिए ऑब्जेक्ट को क्रमबद्ध करना है - JSON.json(message) ।

  message = JSON.parse(String(req[:data])) message["server_mark"] = "confirmed" return Dict( :body => JSON.json(message), :headers => [("Content-Type" => "application/json")] )

प्रतिक्रिया को खेतों के साथ एक सहयोगी सरणी के रूप में भेजा जाता है :body :headers ।

serve(test, 8080) विधि के साथ सर्वर शुरू करना अतुल्यकालिक है, इसलिए जूलिया में विकल्पों में से एक को पूरा करने के लिए प्रतीक्षा को व्यवस्थित करना कोड को कॉल करना है:

 Base.JLOptions().isinteractive == 0 && wait()

अन्यथा, सेवा HTTP.jl पर पिछले संस्करण के HTTP.jl

सेवा के लिए नियंत्रण प्रतिक्रिया:

 GET / HTTP/1.1 HTTP/1.1 200 OK <= (GET / HTTP/1.1) <h1>Hello World!</h1> GET /user/Jemand HTTP/1.1 HTTP/1.1 200 OK <= (GET /user/Jemand HTTP/1.1) <h1>Hello, Jemand!</h1> POST /resource/process HTTP/1.1 HTTP/1.1 200 OK <= (POST /resource/process HTTP/1.1) {"body":"Test document with some content.","server_mark":"confirmed","title":"Some document"}

पैकेज बड्डू.ज्ल

पैकेज को फीनिक्स फ्रेमवर्क के प्रभाव में विकसित किया गया था, जो बदले में, एलिक्सिर पर लागू किया गया था और एलिक्सिर पर प्रक्षेपण में रूबी समुदाय से वेब निर्माण विचारों का कार्यान्वयन है। यह परियोजना काफी सक्रिय रूप से विकसित हो रही है और इसे RESTful API और हल्के वेब एप्लिकेशन बनाने के लिए एक उपकरण के रूप में तैनात किया गया है। JSON सीरियलाइजेशन और डीरिएरलाइजेशन को सरल बनाने के लिए कार्य हैं। यह HTTP.jl और Mux.jl में गुम है। आइए हमारी वेब सेवा के कार्यान्वयन को देखें।

 #!/usr/bin/env julia --project=@. using Bukdu using JSON #   struct WelcomeController <: ApplicationController conn::Conn end #   index(c::WelcomeController) = render(JSON, "Hello World") welcome_user(c::WelcomeController) = render(JSON, "Hello " * c.params.user) function process_resource(c::WelcomeController) message = JSON.parse(String(c.conn.request.body)) @info message message["server_mark"] = "confirmed" render(JSON, message) end #   routes() do get("/", WelcomeController, index) get("/user/:user", WelcomeController, welcome_user, :user => String) post("/resource/process", WelcomeController, process_resource) end #   Bukdu.start(8080) Base.JLOptions().isinteractive == 0 && wait()

पहली बात जिस पर आपको ध्यान देना चाहिए वह है नियंत्रक राज्य के भंडारण के लिए संरचना की घोषणा।

 struct WelcomeController <: ApplicationController conn::Conn end

इस मामले में, यह एक ठोस प्रकार है जो अमूर्त प्रकार के ApplicationController वंशज के रूप में बनाया गया है।

नियंत्रक के लिए तरीके पिछले कार्यान्वयन के संबंध में एक समान तरीके से घोषित किए जाते हैं। हमारी JSON ऑब्जेक्ट के हैंडलर में थोड़ा अंतर है।

 function process_resource(c::WelcomeController) message = JSON.parse(String(c.conn.request.body)) @info message message["server_mark"] = "confirmed" render(JSON, message) end

जैसा कि आप देख सकते हैं, JSON.parse पद्धति का उपयोग करके स्वतंत्र रूप से JSON.parse भी किया जाता है, लेकिन JSON.parse render(JSON, message) विधि का उपयोग प्रतिक्रिया JSON.parse लिए किया जाता है।

मार्गों की घोषणा पारंपरिक शैली में माणिक के लिए की जाती है, जिसमें do...end ब्लॉक का उपयोग शामिल है।

 routes() do get("/", WelcomeController, index) get("/user/:user", WelcomeController, welcome_user, :user => String) post("/resource/process", WelcomeController, process_resource) end

इसके अलावा, रूबिस्ट के लिए पारंपरिक तरीके से, मार्ग खंड /user/:user में एक खंड घोषित किया जाता है। दूसरे शब्दों में, अभिव्यक्ति का चर हिस्सा, जिस तक पहुंच टेम्पलेट में निर्दिष्ट नाम से किया जा सकता है। इसे सिंटैक्टिक रूप से Symbol प्रतिनिधि के रूप में नामित किया गया है। वैसे, जूलिया के लिए, टाइप Symbol अर्थ है, संक्षेप में, रूबी के लिए समान - यह एक अपरिवर्तनीय स्ट्रिंग है, जिसे एक एकल उदाहरण द्वारा स्मृति में दर्शाया गया है।

तदनुसार, चूंकि हमने एक चर भाग के साथ एक मार्ग घोषित किया है, और इस चर भाग के प्रकार को भी इंगित किया है, हम पहले से निर्दिष्ट नाम से पार्स किए गए डेटा का उल्लेख कर सकते हैं। अनुरोध को संसाधित करने वाली विधि में, हम केवल फॉर्म c.params.user में डॉट के माध्यम से फ़ील्ड तक c.params.user ।

 welcome_user(c::WelcomeController) = render(JSON, "Hello " * c.params.user)

सेवा के लिए नियंत्रण प्रतिक्रिया:

 GET / HTTP/1.1 HTTP/1.1 200 OK <= (GET / HTTP/1.1) "Hello World" GET /user/Jemand HTTP/1.1 HTTP/1.1 200 OK <= (GET /user/Jemand HTTP/1.1) "Hello Jemand" POST /resource/process HTTP/1.1 HTTP/1.1 200 OK <= (POST /resource/process HTTP/1.1) {"body":"Test document with some content.","server_mark":"confirmed","title":"Some document"}

कंसोल के लिए सेवा का निष्कर्ष:

 >./bukdu_json.jl INFO: Bukdu Listening on 127.0.0.1:8080 INFO: GET WelcomeController index 200 / INFO: GET WelcomeController welcome_user 200 /user/Jemand INFO: Dict{String,Any}("body"=>"Test document with some content.","title"=>"Some document") INFO: POST WelcomeController process_resource200 /resource/process

पैकेज जिनी.जेएल

एक महत्वाकांक्षी परियोजना जिसे एमवीसी वेब फ्रेमवर्क के रूप में तैनात किया गया है। उनके दृष्टिकोण में, जूलिया पर "रेल" काफी स्पष्ट रूप से दिखाई दे रही हैं, जिसमें जनरेटर द्वारा बनाई गई निर्देशिका संरचना भी शामिल है। हालांकि, परियोजना विकसित हो रही है, अज्ञात कारणों से, यह पैकेज जूलिया पैकेज रिपॉजिटरी में शामिल नहीं है। यही है, इसकी स्थापना केवल कमांड के साथ गिट रिपॉजिटरी से संभव है:

 julia>] # switch to pkg> mode pkg> add https://github.com/essenciary/Genie.jl

जिनी में हमारी सेवा का कोड इस प्रकार है (हम जनरेटर का उपयोग नहीं करते हैं):

 #!/usr/bin/env julia --project=@. #     import Genie import Genie.Router: route, @params, POST import Genie.Requests: jsonpayload, rawpayload import Genie.Renderer: json! #      route("/") do "Hello World!" end route("/user/:user") do "Hello " * @params(:user) end route("/resource/process", method = POST) do message = jsonpayload() # if message == nothing # dump(Genie.Requests.rawpayload()) # end message["server_mark"] = "confirmed" return message |> json! end #   Genie.AppServer.startup(8080) Base.JLOptions().isinteractive == 0 && wait()

यहां आपको घोषणा के प्रारूप पर ध्यान देना चाहिए।

 route("/") do "Hello World!" end

यह कोड रूबी प्रोग्रामर्स के लिए बहुत परिचित है। do...end विधि के तर्क के रूप में एक हैंडलर और मार्ग के रूप में do...end ब्लॉक करें। ध्यान दें कि जूलिया के लिए इस कोड को फॉर्म में फिर से लिखा जा सकता है:

 route(req -> "Hello World!", "/")

यही है, हैंडलर फ़ंक्शन पहले स्थान पर है, मार्ग दूसरे में है। लेकिन हमारे मामले के लिए, आइए रूबी शैली को छोड़ दें।

जिन्न स्वचालित रूप से निष्पादन परिणाम को एक HTTP प्रतिक्रिया में पैक करता है। न्यूनतम मामले में, हमें केवल सही प्रकार के परिणाम को वापस करने की आवश्यकता है, उदाहरण के लिए स्ट्रिंग। अतिरिक्त सुविधाओं में से, इनपुट प्रारूप और उसके विश्लेषण का एक स्वचालित सत्यापन कार्यान्वित किया जाता है। उदाहरण के लिए, JSON के लिए, आपको बस jsonpayload() विधि को कॉल करने की आवश्यकता है।

 route("/resource/process", method = POST) do message = jsonpayload() # if message == nothing # dump(Genie.Requests.rawpayload()) # end message["server_mark"] = "confirmed" return message |> json! end

यहाँ कोड टिप्पणी पर ध्यान दें। jsonpayload() विधि nothing देता है यदि किसी कारण से इनपुट फॉर्मेट JSON के रूप में मान्यता प्राप्त नहीं है। ध्यान दें कि इसके लिए, हमारे HTTP क्लाइंट में हेडर [("Content-Type" => "application/json")] जोड़ा जाता है, क्योंकि अन्यथा जिनी भी JSON के रूप में डेटा को पार्स करना शुरू नहीं करेगा। अगर कुछ समझ में नहीं आता है, तो यह rawpayload() लिए उपयोगी है। हालाँकि, चूंकि यह केवल डिबगिंग चरण है, इसलिए आपको इसे कोड में नहीं छोड़ना चाहिए।

इसके अलावा, आपको प्रारूप message |> json! में परिणाम वापस करने पर ध्यान देना चाहिए message |> json! । json!(str) विधि को यहाँ पाइप लाइन में रखा गया है। यह JSON प्रारूप में डेटा का क्रमांकन प्रदान करता है, और यह भी सुनिश्चित करता है कि जिन्न सही Content-Type जोड़ता है। इसके अलावा, इस तथ्य पर ध्यान दें कि उपरोक्त उदाहरणों में ज्यादातर मामलों में return शब्द बेमानी है। उदाहरण के लिए, रूबी की तरह जूलिया, हमेशा अंतिम ऑपरेशन या अंतिम निर्दिष्ट अभिव्यक्ति के मूल्य का परिणाम देता है। यानी return शब्द वैकल्पिक है।

जिनी की क्षमताएं खत्म नहीं होती हैं, लेकिन हमें वेब सेवा को लागू करने के लिए उनकी आवश्यकता नहीं है।

सेवा के लिए नियंत्रण प्रतिक्रिया:

 GET / HTTP/1.1 HTTP/1.1 200 OK <= (GET / HTTP/1.1) Hello World! GET /user/Jemand HTTP/1.1 HTTP/1.1 200 OK <= (GET /user/Jemand HTTP/1.1) Hello Jemand POST /resource/process HTTP/1.1 HTTP/1.1 200 OK <= (POST /resource/process HTTP/1.1) {"body":"Test document with some content.","server_mark":"confirmed","title":"Some document"}

कंसोल के लिए सेवा का निष्कर्ष:

 >./genie_json.jl [ Info: Ready! 2019-04-24 17:18:51:DEBUG:Main: Web Server starting at http://127.0.0.1:8080 2019-04-24 17:18:51:DEBUG:Main: Web Server running at http://127.0.0.1:8080 2019-04-24 17:19:21:INFO:Main: / 200 2019-04-24 17:19:21:INFO:Main: /user/Jemand 200 2019-04-24 17:19:22:INFO:Main: /resource/process 200

पैकेज JuliaWebAPI.jl

यह पैकेज उन दिनों वेब एप्लिकेशन बनाने के लिए एक मध्यवर्ती परत के रूप में तैनात था जब HTTP.jl सिर्फ एक पुस्तकालय था जो प्रोटोकॉल को लागू करता है। इस पैकेज के लेखक ने स्वैगर विनिर्देश (OpenAPI और http://editor.swagger.io/ ) पर आधारित एक सर्वर कोड जनरेटर भी लागू किया है - परियोजना https://github.com/JuliaComputing/Swagger.jl देखें , और इस जनरेटर ने जूलियावेबपीआई का उपयोग किया .jl। हालाँकि, JuliaWebAPI.jl के साथ समस्या यह है कि यह एक POST अनुरोध के माध्यम से सर्वर को प्रेषित अनुरोध (उदाहरण के लिए, JSON) के शरीर को संसाधित करने की क्षमता को लागू नहीं करता है। लेखक का मानना था कि कुंजी-मान प्रारूप में पैरामीटर पारित करना सभी अवसरों के लिए उपयुक्त है ... इस पैकेज का भविष्य स्पष्ट नहीं है। इसके सभी कार्य पहले से ही कई अन्य पैकेजों में लागू हैं, जिनमें HTTP.jl भी शामिल है। Swagger.jl पैकेज भी अब इसका उपयोग नहीं करता है।

WebSockets.jl

WebSocket प्रोटोकॉल का प्रारंभिक कार्यान्वयन। पैकेज का उपयोग लंबे समय से इस प्रोटोकॉल के मुख्य कार्यान्वयन के रूप में किया गया है, हालांकि, वर्तमान में, इसका कार्यान्वयन HTTP.ll पैकेज में शामिल है। WebSockets.jl पैकेज स्वयं HTTP.jl का उपयोग कनेक्शन स्थापित करने के लिए करता है, हालाँकि अब, यह नए घटनाक्रम में इसका उपयोग करने के लायक नहीं है। इसे संगतता के लिए एक पैकेज के रूप में माना जाना चाहिए।

निष्कर्ष

यह समीक्षा जूलिया पर एक वेब सेवा को लागू करने के विभिन्न तरीकों को प्रदर्शित करती है। सबसे आसान और सबसे सार्वभौमिक तरीका सीधे HTTP.jl पैकेज का उपयोग करना है। इसके अलावा, बुकडू.ज्ल और जिनी.ज्ल संकुल बहुत उपयोगी हैं। कम से कम, उनके विकास की निगरानी की जानी चाहिए। Mux.jl पैकेज के बारे में, इसके फायदे अब HTTP.jl की पृष्ठभूमि के विरुद्ध भंग किए जा रहे हैं। इसलिए, व्यक्तिगत राय इसका उपयोग करने के लिए नहीं है। जिनी.जेएल एक बहुत ही आशाजनक ढांचा है। हालांकि, इससे पहले कि आप इसका उपयोग करना शुरू करें, आपको कम से कम यह समझना चाहिए कि लेखक इसे आधिकारिक पैकेज के रूप में पंजीकृत क्यों नहीं करता है।

ध्यान दें कि उदाहरणों में JSON डिजेरलाइज़ेशन कोड का उपयोग त्रुटि से निपटने के बिना किया गया था। जिनी को छोड़कर सभी मामलों में, पार्सिंग त्रुटियों को संभालना और उपयोगकर्ता को इस बारे में सूचित करना आवश्यक है। HTTP.jl के लिए ऐसे कोड का एक उदाहरण:

  local message = nothing local body = IOBuffer(HTTP.payload(req)) try message = JSON.parse(body) catch err @error err.msg return HTTP.Response(400, string(err.msg)) end

सामान्य तौर पर, हम यह कह सकते हैं कि जूलिया में वेब सेवाएँ बनाने के लिए पहले से ही पर्याप्त धनराशि मौजूद है। यही है, उन्हें लिखने के लिए "पहिया को सुदृढ़ करने" की आवश्यकता नहीं है। अगला चरण यह मूल्यांकन करना है कि जूलिया मौजूदा बेंचमार्क में लोड का सामना कैसे कर सकती है, अगर कोई इसे लेने के लिए तैयार है। हालाँकि, अब हमें इस समीक्षा पर ध्यान देना चाहिए।

जूलिया। वेब सेवाएँ

HTTP.jl पैकेज

HTTP क्लाइंट

HTTP सर्वर

Mux.jl पैकेज

पैकेज बड्डू.ज्ल

पैकेज जिनी.जेएल

पैकेज JuliaWebAPI.jl

WebSockets.jl

निष्कर्ष

संदर्भ

More articles: