हम स्केल पर रेस्टफुल वेब सेवा को लागू करते हैं

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

ट्रेनिंग

हम पिछले लेख से आधार के रूप में कार्य लेते हैं, लेकिन हम इसे हल करने का प्रयास करेंगे ताकि समाधान कोड स्क्रीन पर फिट हो जाए। कम से कम 40 इंच और पांचवां फ़ॉन्ट। अंत में, 21 वीं सदी में, xml-configs और दर्जनों अमूर्त कारखानों के मेगाबाइट के बिना सरल कार्यों को हल करना संभव होना चाहिए।

जो लोग लिंक का पालन नहीं करना चाहते हैं, मैं स्पष्ट करता हूं: हम ग्राहक डेटाबेस तक पहुँचने के लिए सबसे सरल सेवा को लागू करने जा रहे हैं। आवश्यक कार्यक्षमता में से डेटाबेस में ऑब्जेक्ट्स का निर्माण और विलोपन है, साथ ही साथ विभिन्न क्षेत्रों द्वारा सॉर्ट करने की क्षमता वाले सभी क्लाइंट की सूची का पेजिनेशन भी है।

ईंटें जिससे हम एक घर बनाएंगे, हम लेते हैं:

• स्काला एक ईंट भी नहीं है, बल्कि एक नींव है,
• अनफ़िल्टर्ड HTTP अनुरोधों को संभालने के लिए एक महान पुस्तकालय है,
• Squeryl - डेटाबेस प्रश्नों के लिए एक पुस्तकालय,
• जैक्सन JSON के साथ काम करने के लिए एक पुस्तकालय है, जो मूल रूप से जावा के लिए लिखा गया है, लेकिन एक धमाके के साथ यह स्काला प्रकारों के साथ मुकाबला करता है,
• स्कैलाज़ एक पुस्तकालय है जो आपको ↦, library, या ∃ जैसे कोड में अलग-अलग मज़ेदार चरित्र लिखने की अनुमति देता है, और साथ ही साथ उपयोगी उपादानों जैसे कि ऐप्लिकेटिव फ़ंक्शंस, मोनॉयड्स, सेमीग्रुप्स और क्लेयरली एरो को लागू करता है। सच है, मुझे अभी तक उत्तरार्द्ध का उपयोग नहीं करना पड़ा है, लेकिन यह इस तथ्य के कारण सबसे अधिक संभावना है कि मैं अभी तक कार्यात्मक ज्ञान की आवश्यक डिग्री तक नहीं पहुंच पाया हूं।

लेख के पाठ्यक्रम में, मैं पर्याप्त स्पष्टीकरण देने की कोशिश करूंगा ताकि कोड को स्काला से परिचित लोगों द्वारा समझा जा सके, लेकिन मैं वादा नहीं करता कि क्या काम करेगा।

लड़ाई में

डेटा मॉडल

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

@JsonIgnoreProperties(Array("_isPersisted")) case class Customer(id: String, firstName: String, lastName: String, email: Option[String], birthday: Option[Date]) extends KeyedEntity[String] 

प्रकार के Option[_] डेटाबेस के अशक्त स्तंभों के अनुरूप हैं। ऐसे फ़ील्ड दो प्रकार के मान ले सकते हैं: Some(value) , यदि कोई मान है, और None , यदि यह नहीं है। Option का उपयोग करने से आप NullPointerException की संभावनाओं को कम कर सकते हैं और कार्यात्मक प्रोग्रामिंग भाषाओं में एक आम बात है (विशेषकर उन जिनमें कोई null अवधारणा नहीं है)।

@JsonIgnoreProperties JSON क्रमांकन से कुछ क्षेत्रों को बाहर करता है। इस मामले में, _isPersisted फ़ील्ड को बाहर करना आवश्यक था, जिसे स्क्वेयर ने जोड़ा।

डेटाबेस स्कीमा की शुरुआत

जिन लोगों ने JDBC के साथ काम किया है, वे जानते हैं कि सबसे पहले डेटाबेस ड्राइवर क्लास को इनिशियलाइज़ करना है। आइए इस अभ्यास से विचलित न हों:

 Class.forName("org.h2.Driver") SessionFactory.concreteFactory = Some(() => Session.create(DriverManager.getConnection("jdbc:h2:test", "sa", ""), new H2Adapter)) 

पहली पंक्ति में, हम जेडीबीसी ड्राइवर को लोड करते हैं, और दूसरे में हम स्क्वीरी लाइब्रेरी को बताते हैं कि किस कारखाने का उपयोग करना है। डेटाबेस के रूप में हम प्रकाश और तेज H2 का उपयोग करते हैं।

अब योजना की बारी आई है:

 object DB extends Schema { val customer = table[Customer] } transaction { allCatch opt DB.create } 

पहले, हम संकेत देते हैं कि हमारे डेटाबेस में एक तालिका है जो Customer वर्ग से मेल खाती है, और फिर हम इस तालिका को बनाने के लिए DDL कमांड निष्पादित करते हैं। वास्तविक जीवन में, स्वचालित टेबल निर्माण का उपयोग आमतौर पर समस्याग्रस्त होता है, लेकिन एक त्वरित प्रदर्शन के लिए यह बहुत सुविधाजनक है। यदि डेटाबेस में तालिकाएँ पहले से मौजूद हैं, तो DB.create एक अपवाद DB.create फेंक DB.create , जिसे हम allCatch opt लिए धन्यवाद, सफलतापूर्वक अनदेखा करेंगे।

JSON सीरियलाइज़ेशन और डिसेरिएलाइज़ेशन

शुरू करने के लिए, JSON पार्सर को इनिशियलाइज़ करें ताकि यह स्केल में स्वीकृत डेटा प्रकारों के साथ काम कर सके:

 val mapper = new ObjectMapper().withModule(DefaultScalaModule) 

अब हम JSON स्ट्रिंग्स को ऑब्जेक्ट्स में बदलने के लिए दो कार्यों को परिभाषित करते हैं:

 def parseCustomerJson(json: String): Option[Customer] = allCatch opt mapper.readValue(json, classOf[Customer]) def readCustomer(req: HttpRequest[_], id: => String): Option[Customer] = parseCustomerJson(Body.string(req)) map (_.copy(id = id)) 

parseCustomerJson फ़ंक्शन वास्तव में JSON को पार्स कर रहा है। allCatch opt के उपयोग के लिए धन्यवाद allCatch opt पार्सिंग प्रक्रिया के दौरान होने allCatch opt अपवाद पकड़े जाएंगे और हमें परिणाम के रूप में None मिलेगा। दूसरा फ़ंक्शन, readCustomer , सीधे HTTP अनुरोध के प्रसंस्करण से संबंधित है - यह अनुरोध निकाय को पढ़ता है, इसे Customer ऑब्जेक्ट में बदल देता है और id फ़ील्ड को निर्दिष्ट मान पर सेट करता है।

यह ध्यान देने योग्य है कि दोनों फ़ंक्शन में रिटर्न वैल्यू के प्रकार को निर्दिष्ट करना आवश्यक नहीं था: कंपाइलर के पास प्रोग्रामर की मदद के बिना टाइप को कम करने के लिए पर्याप्त डेटा था, लेकिन स्पष्ट रूप से निर्दिष्ट प्रकार कभी-कभी कोड की मानव समझ की सुविधा प्रदान करता है।

उलटी प्रक्रिया - HTTP प्रतिक्रिया के शरीर में Customer वस्तु (या List[Customer] सूची) को बदलना - भी मुश्किल नहीं है:

 case class ResponseJson(o: Any) extends ComposeResponse( ContentType("application/json") ~> ResponseString(mapper.writeValueAsString(o))) 

भविष्य में, हम केवल ResponseJson प्रकार की वस्तुओं को वापस करेंगे, और अनफ़िल्टर्ड फ़्रेमवर्क इसे सही HTTP प्रतिक्रिया में बदलने का ध्यान रखेगा।

एक और छोटा स्पर्श नए ग्राहक पहचानकर्ताओं की पीढ़ी है। सबसे आसान, हालांकि हमेशा सबसे सुविधाजनक तरीका नहीं है, यूयूआईडी का उपयोग करना है:

 def nextId = UUID.randomUUID().toString 

HTTP अनुरोध प्रसंस्करण

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

 val service = cycle.Planify { case /*   */ => /* ,   */ } 

हमारी सेवा में दो प्रवेश बिंदु होंगे: /customer और /customer/[id] । चलो दूसरे के साथ शुरू करते हैं:

 case req@Path(Seg("customer" :: id :: Nil)) => req match { case GET(_) => transaction { DB.customer.lookup(id) cata(ResponseJson, NotFound) } case PUT(_) => transaction { readCustomer(req, id) ∘ DB.customer.update cata(_ => Ok, BadRequest) } case DELETE(_) => transaction { DB.customer.delete(id); NoContent } case _ => Pass } 

पहली पंक्ति में, हम यह संकेत देते हैं कि यह कोड केवल फॉर्म /customer/[id] URL को संसाधित करना चाहता है और पारित किए गए पहचानकर्ता को आईडी चर में बाँधता है (यदि अपरिवर्तनीय चर को कहा जा सकता है)। निम्नलिखित पंक्तियों में, हम अनुरोध के प्रकार के आधार पर व्यवहार को परिष्कृत करते हैं। उदाहरण के लिए, चरणों में PUT विधि की प्रक्रिया की जाँच करते हैं:

• transaction { ... } : हम संकेत देते हैं कि हैंडलर के शरीर की अवधि के लिए, एक लेनदेन खोला जाना चाहिए,
• readCustomer(req, id) : पूर्व लिखित विधि का उपयोग करें जो अनुरोध निकाय और रिटर्न Option[Customer] पढ़ता है Option[Customer]
• ∘ : यह प्रतीक विशेष ध्यान देने योग्य है, वास्तव में यह मानचित्र संचालन का एक पर्याय है और आपको विकल्प सामग्री के लिए कुछ फ़ंक्शन लागू करने की अनुमति देता है, यदि यह सामग्री है;
• DB.customer.update : जिस फ़ंक्शन को हम लागू करना चाहते हैं, वह डेटाबेस में इकाई को अपडेट कर रहा है,
• cata(_ => Ok, BadRequest) : यदि Option का कोई मूल्य नहीं है या नहीं तो क्लाइंट के बजाय हमारे पास None अगर Option का कोई मूल्य या BadRequest तो Ok ।

GET और DELETE अनुरोधों को समान रूप से नियंत्रित किया जाता है।

/customer से अनुरोध करने वाले हैंडलर की दूसरी छमाही में, हमें दो सहायक कार्यों की आवश्यकता होगी:

  val field: PartialFunction[String, Customer => TypedExpressionNode[_]] = { case "id" => _.id case "firstName" => _.firstName case "lastName" => _.lastName case "email" => _.email case "birthday" => _.birthday } val ordering: PartialFunction[String, TypedExpressionNode[_] => OrderByExpression] = { case "asc" => _.asc case "desc" => _.desc } 

इन कार्यों का उपयोग अनुरोध के हिस्से order by बनाने के लिए किया जाएगा और, सबसे अधिक संभावना है, स्क्वेरील के आंतों में अफवाह करते हुए, उन्हें आसान लिखा जा सकता है, लेकिन इस विकल्प ने भी मेरे लिए काम किया। हैंडलर कोड ही:

 case req@Path(Seg("customer" :: Nil)) => req match { case POST(_) => transaction { readCustomer(req, nextId) ∘ DB.customer.insert ∘ ResponseJson cata(_ ~> Created, BadRequest) } case GET(_) & Params(params) => transaction { import Params._ val orderBy = (params.get("orderby") ∗ first orElse Some("id")) ∗ field.lift val order = (params.get("order") ∗ first orElse Some("asc")) ∗ ordering.lift val pageNum = params.get("pagenum") ∗ (first ~> int) val pageSize = params.get("pagesize") ∗ (first ~> int) val offset = ^(pageNum, pageSize)(_ * _) val query = from(DB.customer) { q => select(q) orderBy ^(orderBy, order)(_ andThen _ apply q).toList } val pagedQuery = ^(offset, pageSize)(query.page) getOrElse query ResponseJson(pagedQuery.toList) } case _ => Pass } 

POST अनुरोध से संबंधित हिस्सा कुछ नया नहीं करता है, लेकिन फिर हमें अनुरोध पैरामीटर को संसाधित करना होगा और दो अस्पष्ट वर्ण दिखाई देंगे: characters और ^ । पहला (ध्यान से, सामान्य तारांकन के साथ इसे भ्रमित न करें) * flatMap का एक पर्याय है और map से अलग है जिसमें उपयोग किए गए फ़ंक्शन को भी Option वापस करना चाहिए। इस प्रकार, हम क्रमिक रूप से कई ऑपरेशन कर सकते हैं, जिनमें से प्रत्येक या तो सफलतापूर्वक एक मूल्य देता है या त्रुटि के मामले में None लौटाता है। दूसरा ऑपरेटर थोड़ा अधिक जटिल है और आपको कुछ ऑपरेशन करने की अनुमति केवल तभी देता है जब उपयोग किए गए सभी चर किसी के बराबर None । यह हमें केवल तभी सॉर्ट करने की अनुमति देता है जब स्तंभ और दिशा दोनों निर्दिष्ट किए जाते हैं, और परिणाम को पृष्ठों में तब ही तोड़ते हैं जब पृष्ठ संख्या और उसका आकार दोनों निर्दिष्ट होते हैं।

यह सब है, जो सभी रहता है वह सर्वर को शुरू करना है

 Http(8080).plan(service).run() 

और आप कर्ल उठा सकते हैं यह जांचने के लिए कि सब कुछ काम करता है।

निष्कर्ष

मेरी राय में, परिणामी वेब सेवा कोड कॉम्पैक्ट और पढ़ने में काफी आसान है, और यह एक बहुत ही महत्वपूर्ण संपत्ति है। स्वाभाविक रूप से, यह आदर्श नहीं है: उदाहरण के लिए, त्रुटियों को संभालने के लिए शायद scala.Either या scalaz.Validation का उपयोग करना सार्थक था, लेकिन कोई यूनिकोड ऑपरेटरों का उपयोग करना पसंद नहीं कर सकता है। इसके अलावा, बाहरी सादगी के पीछे, कभी-कभी काफी जटिल संचालन छिपाए जा सकते हैं, और यह समझने के लिए कि "हुड के तहत" सब कुछ कैसे काम करता है "आपको गाइरस को तनाव देना होगा। फिर भी, मुझे उम्मीद है कि यह लेख किसी को स्काला पर करीब से नज़र डालने के लिए प्रोत्साहित करेगा: भले ही आप इस भाषा को अपने काम में लागू करने में विफल हों, आप निश्चित रूप से कुछ नया सीखेंगे।

कोड, जैसा कि अपेक्षित था, गिटहब पर पोस्ट किया गया है , और यह विधानसभा में केवल आयात-एस और एसबीटी-स्क्रिप्ट की उपस्थिति से लेख में दिए गए से अलग है।

मैं लगभग भूल गया था - लेख की शुरुआत में मैंने वादा किया था कि वेब सेवा में भिक्षु और अन्य बुरी आत्माएं होंगी। तो, flatMap (उर्फ ∗ ) एक मोनडिक बाइंड है, और ^ ऑपरेटर सीधे flatMap से संबंधित है।

और अंत में, यदि आप खार्कोव या सैराटोव में हैं और स्काला और अक्का का उपयोग करके दिलचस्प चीजें विकसित करना चाहते हैं, तो लिखें - हम सक्षम विशेषज्ञों की तलाश कर रहे हैं।