Play फ्रेमवर्क में एसिंक्रोनस HTTP

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

भविष्य [परिणाम]

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

भविष्य को प्राप्त करने के साथ असंगत रूप से कोड ब्लॉक को निष्पादित करने के लिए सभी आवश्यक है [परिणाम] इसे फॉर्म की एक सरल संरचना में लपेटना है:

import play.api.libs.concurrent.Execution.Implicits.defaultContext val futureInt: Future[Int] = scala.concurrent.Future { intensiveComputation()} 

और परिणामी मान वापस करने के लिए, Action.async विधि का उपयोग करें:

 import play.api.libs.concurrent.Execution.Implicits.defaultContext def index = Action.async { val futureInt = scala.concurrent.Future { intensiveComputation() } futureInt.map(i => Ok("Got result: " + i))} 

और यह विकल्प तब तक अच्छा काम करता है जब तक कि कोड सही ढंग से चलता है। लेकिन निष्पादन के दौरान त्रुटियों से कोई भी सुरक्षित नहीं है, और यदि कोड कोड के एक ब्लॉक में एक त्रुटि होती है जो अतुल्यकालिक रूप से चलती है, तो यह इस तथ्य को जन्म दे सकता है कि परिणाम उत्पन्न नहीं होगा। इसका मतलब है कि उपयोगकर्ता को कोई प्रतिक्रिया नहीं मिलेगी और उसका ब्राउज़र तब तक इंतजार करेगा जब तक वह अंत में टैब बंद नहीं कर देता। हालांकि, इससे बचना काफी सरल है: आप प्रत्येक वादे (यानी, भविष्य के परिणाम) के लिए एक समय सीमा निर्धारित कर सकते हैं: यदि इस दौरान हमें वास्तविक परिणाम नहीं मिलता है, तो एक त्रुटि उत्पन्न होगी। यह भी काफी सरलता से किया जाता है:

 import play.api.libs.concurrent.Execution.Implicits.defaultContext import scala.concurrent.duration._ def index = Action.async { val futureInt = scala.concurrent.Future { intensiveComputation() } val timeoutFuture = play.api.libs.concurrent.Promise.timeout("Oops", 1.second) Future.firstCompletedOf(Seq(futureInt, timeoutFuture)).map { case i: Int => Ok("Got result: " + i) case t: String => InternalServerError(t) }} 

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

HTTP स्ट्रीमिंग प्रतिक्रियाएँ

HTTP 1.1 में, एक एकल कनेक्शन का उपयोग कई अनुरोध भेजने के लिए किया जा सकता है ( http://en.wikipedia.org/wiki/HTTP_persistent_connection )। एक शर्त के साथ: सर्वर को प्रतिक्रिया में सामग्री-लंबाई हेडर शामिल करना चाहिए। आमतौर पर, प्रतिक्रियाएं भेजते समय, यह स्थिति इतनी महत्वपूर्ण नहीं होती है, क्योंकि Play सामग्री के आकार की गणना करने में काफी सक्षम है। लेकिन वास्तव में, सब कुछ हमेशा इतना सरल नहीं होता है: इस तथ्य के कारण कि सरलतम मामले में (जब SimpleResult का उपयोग करते हुए) फ्रेमवर्क Enumerator (play.api.libs.iteratee.Enumerator) का उपयोग करता है प्रतिक्रिया शरीर बनाने के लिए, इसे लंबाई की गणना करने के लिए पूरी लंबाई डाउनलोड करने की आवश्यकता है। स्मृति में सामग्री। और बड़ी मात्रा में डेटा के मामले में (कल्पना करें कि आप उपयोगकर्ता को एक वीडियो फ़ाइल वापस करना चाहते हैं) इससे कुछ समस्याएं हो सकती हैं।

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

नोट : एन्यूमरेटर के साथ काम करने के मानक मामलों के लिए, प्ले में इसे बनाने के लिए कारखाने के कार्यों का एक सेट है: एनुमेररेटर.फ्रेमफाइल, उदाहरण के लिए, इसे फ़ाइल की सामग्री के आधार पर बनाता है; Enumerator.fromStream - डेटा स्ट्रीम पर आधारित है। हालाँकि, सामान्य स्थिति में, आपको मैन्युअल रूप से एक एन्यूमरेटर बनाना होगा।

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

 def index = Action { val file = new java.io.File("/tmp/fileToServe.mov") val fileContent: Enumerator[Array[Byte]] = Enumerator.fromFile(file) SimpleResult( header = ResponseHeader(200, Map(CONTENT_LENGTH -> file.length.toString)), body = fileContent )} 

या उपयोगकर्ता को फ़ाइल स्थानांतरित करने के लिए डिज़ाइन किए गए प्ले फ्रेमवर्क फ़ंक्शन का उपयोग करें:

 def index = Action { Ok.sendFile(new java.io.File("/tmp/fileToServe.mov"))} 

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

हालांकि, ऊपर वर्णित सभी विधियां केवल स्थिर सामग्री के मामले में अच्छी हैं, अर्थात, जो पहले से हमारे लिए जानी जाती है। लेकिन क्या होगा, जब तक प्रसारण शुरू नहीं हो जाता है, तब तक सभी सामग्री अभी तक तैयार नहीं है - जिसका अर्थ है कि सभी इच्छा के साथ इसकी लंबाई की गणना करना असंभव होगा? इस मामले में, खंडित उत्तर चंक्ड ट्रांसफर एन्कोडिंग तंत्र ( http://en.wikipedia.org/wiki/Chunked_transfer_encoding ) का उपयोग करके बचाव के लिए आते हैं। यह दृष्टिकोण आपको सामग्री-लंबाई के उपयोग के बिना करने की अनुमति देता है, जिसका अर्थ है कि आप उनकी पीढ़ी के दौरान डेटा स्थानांतरित करना शुरू कर सकते हैं, अभी तक उनके अंतिम आकार को नहीं जानते हैं। क्या प्ले उसके साथ काम कर सकता है? आप अभी भी पूछ रहे हैं:

 def index = Action { val data = getDataStream val dataContent: Enumerator[Array[Byte]] = Enumerator.fromStream(data) ChunkedResult( header = ResponseHeader(200), chunks = dataContent )} 

वरना:

 def index = Action { val data = getDataStream val dataContent: Enumerator[Array[Byte]] = Enumerator.fromStream(data) Ok.chunked(dataContent)} 

आप पास कर सकते हैं और गणना कर सकते हैं:

 def index = Action { Ok.chunked( Enumerator("kiki", "foo", "bar").andThen(Enumerator.eof) )} 

.Then पद्धति का उपयोग कई एन्युमरेटर के अनुक्रम को बनाने के लिए किया जाता है। इस मामले में, उदाहरण के लिए, Enumerator.eof को डेटा के बाद प्रेषित किया जाता है - शून्य लंबाई का एक टुकड़ा, यह दर्शाता है कि स्थानांतरण पूरा हो गया है।

नोट : .Then विधि के बजाय, आप >>> ऑपरेटर का उपयोग कर सकते हैं - कार्यात्मक रूप से उनके बीच कोई अंतर नहीं है, लेकिन बाद का उपयोग करके कोड की पठनीयता को बढ़ा सकते हैं, कोष्ठक की अत्यधिक संख्या को समाप्त कर सकते हैं।

लेकिन इस दृष्टिकोण की अपनी कमियां भी हैं: उदाहरण के लिए, इस तथ्य के कारण कि अंतिम क्षण तक ब्राउज़र को प्रेषित डेटा का अंतिम आकार नहीं पता है, यह पूरा होने वाले प्रतिशत को दिखाने में सक्षम नहीं होगा। लेकिन यह, वास्तव में, यह इतना बड़ा ऋण नहीं है कि इसे स्थानांतरित करने से पहले डेटा पीढ़ी के अंत की प्रतीक्षा करने की आवश्यकता के साथ तुलना की जाए।

धूमकेतु सॉकेट

ऊपर वर्णित खंडित प्रतिक्रिया विधि का एक उपयोग धूमकेतु सॉकेट बनाने के लिए है। यह क्या है यदि सरल है, तो ये उत्तर से मिलकर बने होते हैं

  .  ,      ,    -           ,     . 
 
           ,     Ok.chunked  Ok.stream: 
 
 def comet = Action { val events = Enumerator( """<script>console.log('kiki')</script>""", """<script>console.log('foo')</script>""", """<script>console.log('bar')</script>""" ) Ok.stream(events >>> Enumerator.eof).as(HTML)} 
 
           :    Play framework: 
 
 def comet = Action { val events = Enumerator("kiki", "foo", "bar") Ok.stream((events &> Comet(callback = "console.log")) >>> Enumerator.eof)} 
 
 WebSockets 
   Play ,   Comet sockets   .     : ,      ,  ,      ,       Ajax-.   ,  WebSockets ( http://en.wikipedia.org/wiki/WebSocket ),        . 
 
  ,   WebSockets,         Action: -      .      WebSocket,     Action  , ,     ,        ,   HTTP . 
 
     WebSocket   : 
 
 def index = WebSocket.using[String] { request => // Just consume and ignore the input val in = Iteratee.consume[String]() // Send a single 'Hello!' message and close val out = Enumerator("Hello!").andThen(Enumerator.eof) (in, out)} 
 
 In -   -  Iteratee,   ,   ; out -   - Enumerator,    . 
 
  
  ,  ,      , Play       -      ,   .          :       ,     . 
 

. , , - , .

, Ok.chunked Ok.stream:

def comet = Action { val events = Enumerator( """<script>console.log('kiki')</script>""", """<script>console.log('foo')</script>""", """<script>console.log('bar')</script>""" ) Ok.stream(events >>> Enumerator.eof).as(HTML)}

: Play framework:

def comet = Action { val events = Enumerator("kiki", "foo", "bar") Ok.stream((events &> Comet(callback = "console.log")) >>> Enumerator.eof)}

WebSockets
Play , Comet sockets . : , , , , Ajax-. , WebSockets ( http://en.wikipedia.org/wiki/WebSocket ), .

, WebSockets, Action: - . WebSocket, Action , , , , HTTP .

WebSocket :

def index = WebSocket.using[String] { request => // Just consume and ignore the input val in = Iteratee.consume[String]() // Send a single 'Hello!' message and close val out = Enumerator("Hello!").andThen(Enumerator.eof) (in, out)}

In - - Iteratee, , ; out - - Enumerator, .


, , , Play - , . : , .


  .  ,      ,    -           ,     . 
 
           ,     Ok.chunked  Ok.stream: 
 
 def comet = Action { val events = Enumerator( """<script>console.log('kiki')</script>""", """<script>console.log('foo')</script>""", """<script>console.log('bar')</script>""" ) Ok.stream(events >>> Enumerator.eof).as(HTML)} 
 
           :    Play framework: 
 
 def comet = Action { val events = Enumerator("kiki", "foo", "bar") Ok.stream((events &> Comet(callback = "console.log")) >>> Enumerator.eof)} 
 
 WebSockets 
   Play ,   Comet sockets   .     : ,      ,  ,      ,       Ajax-.   ,  WebSockets ( http://en.wikipedia.org/wiki/WebSocket ),        . 
 
  ,   WebSockets,         Action: -      .      WebSocket,     Action  , ,     ,        ,   HTTP . 
 
     WebSocket   : 
 
 def index = WebSocket.using[String] { request => // Just consume and ignore the input val in = Iteratee.consume[String]() // Send a single 'Hello!' message and close val out = Enumerator("Hello!").andThen(Enumerator.eof) (in, out)} 
 
 In -   -  Iteratee,   ,   ; out -   - Enumerator,    . 
 
  
  ,  ,      , Play       -      ,   .          :       ,     . 
 

. , , - , .

, Ok.chunked Ok.stream:

def comet = Action { val events = Enumerator( """<script>console.log('kiki')</script>""", """<script>console.log('foo')</script>""", """<script>console.log('bar')</script>""" ) Ok.stream(events >>> Enumerator.eof).as(HTML)}

: Play framework:

def comet = Action { val events = Enumerator("kiki", "foo", "bar") Ok.stream((events &> Comet(callback = "console.log")) >>> Enumerator.eof)}

WebSockets
Play , Comet sockets . : , , , , Ajax-. , WebSockets ( http://en.wikipedia.org/wiki/WebSocket ), .

, WebSockets, Action: - . WebSocket, Action , , , , HTTP .

WebSocket :

def index = WebSocket.using[String] { request => // Just consume and ignore the input val in = Iteratee.consume[String]() // Send a single 'Hello!' message and close val out = Enumerator("Hello!").andThen(Enumerator.eof) (in, out)}

In - - Iteratee, , ; out - - Enumerator, .


, , , Play - , . : , .


. , , - , .

, Ok.chunked Ok.stream:

def comet = Action { val events = Enumerator( """<script>console.log('kiki')</script>""", """<script>console.log('foo')</script>""", """<script>console.log('bar')</script>""" ) Ok.stream(events >>> Enumerator.eof).as(HTML)}

: Play framework:

def comet = Action { val events = Enumerator("kiki", "foo", "bar") Ok.stream((events &> Comet(callback = "console.log")) >>> Enumerator.eof)}

WebSockets
Play , Comet sockets . : , , , , Ajax-. , WebSockets ( http://en.wikipedia.org/wiki/WebSocket ), .

, WebSockets, Action: - . WebSocket, Action , , , , HTTP .

WebSocket :

def index = WebSocket.using[String] { request => // Just consume and ignore the input val in = Iteratee.consume[String]() // Send a single 'Hello!' message and close val out = Enumerator("Hello!").andThen(Enumerator.eof) (in, out)}

In - - Iteratee, , ; out - - Enumerator, .


, , , Play - , . : , .


. , , - , .

, Ok.chunked Ok.stream:

def comet = Action { val events = Enumerator( """<script>console.log('kiki')</script>""", """<script>console.log('foo')</script>""", """<script>console.log('bar')</script>""" ) Ok.stream(events >>> Enumerator.eof).as(HTML)}

: Play framework:

def comet = Action { val events = Enumerator("kiki", "foo", "bar") Ok.stream((events &> Comet(callback = "console.log")) >>> Enumerator.eof)}

WebSockets
Play , Comet sockets . : , , , , Ajax-. , WebSockets ( http://en.wikipedia.org/wiki/WebSocket ), .

, WebSockets, Action: - . WebSocket, Action , , , , HTTP .

WebSocket :

def index = WebSocket.using[String] { request => // Just consume and ignore the input val in = Iteratee.consume[String]() // Send a single 'Hello!' message and close val out = Enumerator("Hello!").andThen(Enumerator.eof) (in, out)}

In - - Iteratee, , ; out - - Enumerator, .


, , , Play - , . : , .


  .  ,      ,    -           ,     . 
 
           ,     Ok.chunked  Ok.stream: 
 
 def comet = Action { val events = Enumerator( """<script>console.log('kiki')</script>""", """<script>console.log('foo')</script>""", """<script>console.log('bar')</script>""" ) Ok.stream(events >>> Enumerator.eof).as(HTML)} 
 
           :    Play framework: 
 
 def comet = Action { val events = Enumerator("kiki", "foo", "bar") Ok.stream((events &> Comet(callback = "console.log")) >>> Enumerator.eof)} 
 
 WebSockets 
   Play ,   Comet sockets   .     : ,      ,  ,      ,       Ajax-.   ,  WebSockets ( http://en.wikipedia.org/wiki/WebSocket ),        . 
 
  ,   WebSockets,         Action: -      .      WebSocket,     Action  , ,     ,        ,   HTTP . 
 
     WebSocket   : 
 
 def index = WebSocket.using[String] { request => // Just consume and ignore the input val in = Iteratee.consume[String]() // Send a single 'Hello!' message and close val out = Enumerator("Hello!").andThen(Enumerator.eof) (in, out)} 
 
 In -   -  Iteratee,   ,   ; out -   - Enumerator,    . 
 
  
  ,  ,      , Play       -      ,   .          :       ,     . 
 

. , , - , .

, Ok.chunked Ok.stream:

def comet = Action { val events = Enumerator( """<script>console.log('kiki')</script>""", """<script>console.log('foo')</script>""", """<script>console.log('bar')</script>""" ) Ok.stream(events >>> Enumerator.eof).as(HTML)}

: Play framework:

def comet = Action { val events = Enumerator("kiki", "foo", "bar") Ok.stream((events &> Comet(callback = "console.log")) >>> Enumerator.eof)}

WebSockets
Play , Comet sockets . : , , , , Ajax-. , WebSockets ( http://en.wikipedia.org/wiki/WebSocket ), .

, WebSockets, Action: - . WebSocket, Action , , , , HTTP .

WebSocket :

def index = WebSocket.using[String] { request => // Just consume and ignore the input val in = Iteratee.consume[String]() // Send a single 'Hello!' message and close val out = Enumerator("Hello!").andThen(Enumerator.eof) (in, out)}

In - - Iteratee, , ; out - - Enumerator, .


, , , Play - , . : , .


. , , - , .

, Ok.chunked Ok.stream:

def comet = Action { val events = Enumerator( """<script>console.log('kiki')</script>""", """<script>console.log('foo')</script>""", """<script>console.log('bar')</script>""" ) Ok.stream(events >>> Enumerator.eof).as(HTML)}

: Play framework:

def comet = Action { val events = Enumerator("kiki", "foo", "bar") Ok.stream((events &> Comet(callback = "console.log")) >>> Enumerator.eof)}

WebSockets
Play , Comet sockets . : , , , , Ajax-. , WebSockets ( http://en.wikipedia.org/wiki/WebSocket ), .

, WebSockets, Action: - . WebSocket, Action , , , , HTTP .

WebSocket :

def index = WebSocket.using[String] { request => // Just consume and ignore the input val in = Iteratee.consume[String]() // Send a single 'Hello!' message and close val out = Enumerator("Hello!").andThen(Enumerator.eof) (in, out)}

In - - Iteratee, , ; out - - Enumerator, .


, , , Play - , . : , .


. , , - , .

, Ok.chunked Ok.stream:

def comet = Action { val events = Enumerator( """<script>console.log('kiki')</script>""", """<script>console.log('foo')</script>""", """<script>console.log('bar')</script>""" ) Ok.stream(events >>> Enumerator.eof).as(HTML)}

: Play framework:

def comet = Action { val events = Enumerator("kiki", "foo", "bar") Ok.stream((events &> Comet(callback = "console.log")) >>> Enumerator.eof)}

WebSockets
Play , Comet sockets . : , , , , Ajax-. , WebSockets ( http://en.wikipedia.org/wiki/WebSocket ), .

, WebSockets, Action: - . WebSocket, Action , , , , HTTP .

WebSocket :

def index = WebSocket.using[String] { request => // Just consume and ignore the input val in = Iteratee.consume[String]() // Send a single 'Hello!' message and close val out = Enumerator("Hello!").andThen(Enumerator.eof) (in, out)}

In - - Iteratee, , ; out - - Enumerator, .


, , , Play - , . : , .