🗳️ 👩🏾‍🤝‍👨🏽 🧘🏼 PlayFramework 2.2 और Scala के साथ RSS चलाएं 🚒 🎖️ 🏵️

शुभ दिन, प्रिय Kravravchians।

हम, ~~पोग्रोम~~ प्रोग्रामर, बहुत बार एक ही समस्या का सामना करते हैं जब एक नई भाषा एक्स या फ्रेमवर्क वाई सीखते हैं - परिचयात्मक ट्यूटोरियल के बाद क्या लिखना है फिर भी एक और हैलो वर्ल्ड? कुछ ऐसा जो एक्स / वाई के कुछ फायदे और नुकसान दिखा सकता है, लेकिन इसमें ज्यादा समय नहीं लगेगा।

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

तो, यहां बैकएंड पर प्ले फ्रेमवर्क 2.2 + स्काला + मोंगोबीडी स्टैक में एक रोमांचक यात्रा शुरू होती है और फ्रंट पर एंगुलरजेएस + कॉफीस्क्रिप्ट ।

टीएल, डॉ

पूरे प्रोजेक्ट को प्रलेखन के साथ स्काला पर ~ 250-300 लाइनों और सीएस पर 150 लाइनों में रखा गया था। खैर, कुछ एच.टी.एम.एल.
Bitbucket पर उपलब्ध कोड

और पहला पड़ाव सवाल होगा - स्कैला, जावा क्यों नहीं? और क्यों खेलते हैं, और एक ही लिफ्ट नहीं?

उत्तर बहुत ही सरल और व्यक्तिपरक हैं।
स्काला कोड के लिए उच्च स्तर की अमूर्तता और कम कोड प्रदान करता है। जब मैंने सभी अवसरों के लिए अपने 200 तरीकों के साथ मानक सूची के लिए प्रलेखन देखा ... गंभीरता से, इसे स्वयं आज़माएं।
फ्रेमवर्क की पसंद के लिए - लिफ्ट पर एक सरल उदाहरण ने मुझे ~ 150 एमएस के लिए एक स्थानीयहोस्ट पर एक पृष्ठ दिया, और यह एक डेटाबेस का उपयोग किए बिना है। उसी समय, एक ही मशीन और एक ही JVM Play पर, यह ~ 5-10 एमएस में कामयाब रहा। मुझे नहीं पता, शायद सितारे इस तरह से हैं।
और प्ले कंसोल में प्यारा है।

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

अनुरोध पथ

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

conf / मार्गों

 # रूट
 # यह फाइल सभी आवेदन मार्गों (पहले उच्च प्राथमिकता वाले मार्गों) को परिभाषित करती है।
 # ~~~~

 # जाओ
 GET / समाचार नियंत्रकों। NewsController.news (टैग: स्ट्रिंग? = "", सार्वजनिक करें: Int? = (System.currentTimeMillis () / 1000) .toInt)।

 # पार्स खबर
 GET / पार्स कंट्रोलर। NewsController.parseRSS

 # जाओ
 GET / टैग कंट्रोलर .agsController.tags

 # सार्वजनिक फ़ोल्डर से / संपत्ति URL पथ पर स्थैतिक संसाधनों को मैप करें
 GET / आस्तियों / * फ़ाइल नियंत्रकों.एसेट्स (पथ = "/ सार्वजनिक", फ़ाइल)

 # होम पेज
 प्राप्त / नियंत्रकों। आवेदन। सूचकांक

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

टिकट पेश करें!

जैसा कि आप शीर्षक से अनुमान लगा सकते हैं - कहानी नियंत्रकों के साथ जारी है। प्ले में, उपयोगकर्ता नियंत्रक controllers पैकेज में शामिल होते हैं, Controller विशेषता का उपयोग करते हैं और वे ऑब्जेक्ट होते हैं जिनके तरीके रूटिंग के अनुसार उपयोगकर्ता के अनुरोधों को स्वीकार करते हैं और प्रतिक्रिया देते हैं।
चूंकि एप्लिकेशन AJAX के माध्यम से सर्वर से डेटा प्राप्त करता है, मुख्य पृष्ठ को रेंडर करने के लिए नियंत्रक एक वर्ग के रूप में तुच्छ है और केवल HTML / CS / JS स्क्रिप्ट लोड करने के लिए आवश्यक है।

टाइप्ड और 20 लाइनें नहीं

 package controllers import play.api.mvc._ /** * playRSS entry point */ object Application extends Controller { /** * Main page. So it begins... * @return */ def index = Action { Ok(views.html.index()) } }

Ok play.api.mvc.SimpleResult उदाहरण देता है, जिसमें पेज के हेडर और बॉडी होते हैं। सर्वर से प्रतिक्रिया बराबर होगी, क्योंकि सबसे चौकस अनुमान लगाया गया हो सकता है, 200 OK ।

मगर
यदि पूरे एप्लिकेशन के लिए एक पूर्ण नियंत्रक 20 लाइनों में फिट बैठता है, तो यह बहुत संभावना है कि आप रूबल में लिख रहे हैं।

तो, AJAX ग्राहक को समाचार प्राप्त करने का अनुरोध देने का सबसे अच्छा तरीका क्या है? राइट, JSON।
NewsController ऐसा करता है NewsController

ऑब्जेक्ट न्यूज़कंट्रोलर

 package controllers import play.api.mvc._ import scala.concurrent._ import models.News import play.api.libs.concurrent.Execution.Implicits.defaultContext import models.parsers.Parser import com.mongodb.casbah.Imports._ object NewsController extends Controller { /** * Get news JSON * @param tag optional tag filter * @param pubDate optional pubDate filter for loading news before this UNIX timestamp * @return */ def news(tag: String, pubDate: Int) = Action.async { val futureNews = Future { try { News asJson News.allNews(tag, pubDate) } catch { case e: MongoException => throw e } } futureNews.map { news => Ok(news).as("application/json") }.recover { case e: MongoException => InternalServerError("{error: 'DB Error: " + e.getMessage + "'}").as("application/json") } } /** * Start new RSS parsing and return first N news * @return */ def parseRSS = Action.async { val futureParse = scala.concurrent.Future { try { Parser.downloadItems(News.addNews(_)) News asJson News.allNews() } catch { case e: Exception => throw e } } futureParse.map(newsJson => Ok(newsJson).as("application/json")).recover { case e: MongoException => InternalServerError("{error: 'DB Error: " + e.getMessage + "'}").as("application/json") case e: Exception => InternalServerError("{error: 'Parse Error: " + e.getMessage + "'}").as("application/json") } } }

Future । Async । यहां पहली बार यह दिलचस्प हो जाता है।
शुरू करने के लिए, प्ले अतुल्यकालिक है और, सिद्धांत रूप में, आपको धाराओं के साथ काम करने की आवश्यकता नहीं है। लेकिन जब हमें ~~तत्काल~~ डेटाबेस का उपयोग करने के ~~लिए~~ we ~~संख्या की गणना करने की~~ आवश्यकता होती है , तो एक फ़ाइल से डेटा पढ़ें या एक और धीमी गति से I / O प्रक्रिया करें, Future बचाव में आता है, जो आपको मुख्य धारा को अवरुद्ध किए बिना अतुल्यकालिक रूप से एक ऑपरेशन करने की अनुमति देता है। Future निष्पादन के लिए एक अलग संदर्भ का उपयोग करता है, इसलिए आपको थ्रेड्स के बारे में चिंता नहीं करनी चाहिए।
चूंकि फ़ंक्शन अब Future[SimpleResult] नहीं लौटाता है, लेकिन Future[SimpleResult] , ActionBuilder विशेषता का async विधि का ActionBuilder (जो Action ऑब्जेक्ट का उपयोग करता है)

परिदृश्य

आइए इस अतुल्यकालिक दुःस्वप्न के साथ रुकें और उन टेम्पलेट्स को चालू करें जो हमारी आंख के लिए सुंदर हैं। Play नियमित HTML के साथ काम करने की क्षमता प्रदान करता है। स्काला कोड आवेषण के साथ सामान्य HTML। टेम्पलेट स्वचालित रूप से स्रोत फ़ाइलों में संकलित किया जाता है और एक नियमित फ़ंक्शन होता है, जहां आप पैरामीटर पारित कर सकते हैं या अन्य टेम्प्लेट कनेक्ट (कॉल) कर सकते हैं। वैसे, कई HTML में अपेक्षाकृत धीमी संकलन समय के कारण कोड में नए टेम्पलेट इंजन को नापसंद करते हैं। मैं ठीक हूं।

index.scala.html

 <!DOCTYPE html> <html> <head> <title> playRSS </title> <link rel="shortcut icon" href='@routes.Assets.at("images/favicon.png")' type="image/png"> <link rel="stylesheet" href="http://netdna.bootstrapcdn.com/bootstrap/3.0.0/css/bootstrap.min.css"/> <link rel="stylesheet" href='@routes.Assets.at("stylesheets/main.css")'> @helper.requireJs(core = routes.Assets.at("javascripts/require.js").url, module = routes.Assets.at("javascripts/main").url) </head> <body> <div class="container" id="container" ng-controller="MainCtrl"> <a href="/"><h1>playRSS</h1></a> @control() <div class="row"> <div class="col-lg-12"> @news() </div> </div> </div> </body> </html>

जैसा कि आप स्रोत से देख सकते हैं - थोड़ा जादू। @helper कनेक्ट @helper जोड़ता है, जिसे फ्रेमवर्क द्वारा आपूर्ति की जाती है, और मेन.जेएस के लिए पथ को इंगित करता है, जहां फ्रंटेंड को आरंभीकृत किया जाता है। @news() और @control() क्रमशः news.scala.html और control.scala.html टेम्पलेट हैं। हम फ़ंक्शन को निष्पादित करते हैं और वर्तमान टेम्पलेट के अंदर परिणाम प्रदर्शित करते हैं। मिलो।

और भी
छोरों के साथ काम कर सकते हैं, अगर / और, आदि। विस्तृत दस्तावेज है

पर्वत कसाब

डेटाबेस के साथ काम जारी रखें। मेरे मामले में, मानगो को चुना गया था। ~~चूंकि मैं टेबल बनाने के लिए बहुत आलसी हूं। :)~~
Casbah एक रोलिंग पिन में MongoDB के साथ काम करने के लिए आधिकारिक ड्राइवर है । इसका लाभ एक ही समय में सादगी और कार्यक्षमता है। और मुख्य दोष को अंत में माना जाएगा।

चालक स्पष्ट रूप से जुड़ा हुआ है:

libraryDependencies अंदर पुस्तकालय की libraryDependencies लिए लाइन जोड़ें:
"org.mongodb" %% "casbah" % "2.6.3"
हमारे कोड में जोड़ें:
import com.mongodb.casbah.Imports._
परियोजना के स्टार्टअप पर ही अपस्फीति होगी
???
लाभ

और कोड के बारे में थोड़ा। चूँकि पाठक को सरल नहीं किया जाता है, इसलिए एक ऑब्जेक्ट बनाया गया था जो कि MongoDB से जरूरतमंद संग्रह को वितरित करता है। DAO या DI को बाड़ देने का सही शब्द बस अनावश्यक है।

ऑब्जेक्ट डेटाबेस

 package models import com.mongodb.casbah.Imports._ import play.api.Play /** * Simple object for DB connection */ object Database { private val db = MongoClient( Play.current.configuration.getString("mongo.host").get, Play.current.configuration.getInt("mongo.port").get). getDB(Play.current.configuration.getString("mongo.db").get) /** * Get collection by its name * @param collectionName * @return */ def collection(collectionName:String) = db(collectionName) /** * Clear collection by its name * @param collectionName * @return */ def clearCollection(collectionName:String) = db(collectionName).remove(MongoDBObject()) }

मार्जिन में मार्जिन:
स्काला में, वस्तुएं वास्तव में सिंगलटन हैं। यदि आप उबाऊ मोड को सक्षम करते हैं, तो स्थिर विधियों के साथ एक अनाम वर्ग बनाया जाता है और तात्कालिक (जावा / जेवीएम दृश्य में)। तो हमारा कनेक्शन तब बढ़ेगा जब ऑब्जेक्ट बनाया जाएगा और पूरे एप्लिकेशन काम करने वाले चक्र में उपलब्ध होगा।

यह स्काला और कैसबाह के आधार के साथ काम करने का प्रदर्शन करने का समय है:

वस्तु समाचार

 /** * Default news container * @param id MongoID * @param title * @param link * @param content * @param tags Sequence of tags. Since categories could be joined into one * @param pubDate */ case class News(val id: String = "0", val title: String, val link: String, val content: String, val tags: Seq[String], val pubDate: Long) /** * News object allows to operate with news in database. Companion object for News class */ object News { .... /** * Method to add news to database * @param news filled News object * @return */ def addNews(news: News) = { val toInsert = MongoDBObject("title" -> news.title, "content" -> news.content, "link" -> news.link, "tags" -> news.tags, "pubDate" -> news.pubDate) try { col.insert(toInsert) } catch { case e: Exception => } } .... /** * Get news from DB * @param filter filter for find() method * @param sort object for sorting. by default sorts by pubDate * @param limit limit for news select. by default equals to newsLimit * @return */ def getNews(filter: MongoDBObject, sort: MongoDBObject = MongoDBObject("pubDate" -> -1), limit: Int = newsLimit): Array[News] = { try { col.find(filter). sort(sort). limit(limit). map((o: DBObject) => { new News( id = o.as[ObjectId]("_id").toString, title = o.as[String]("title"), link = o.as[String]("link"), content = o.as[String]("content"), tags = o.as[MongoDBList]("tags").map(_.toString), pubDate = o.as[Long]("pubDate")) }).toArray } catch { case e: MongoException => throw e } } }

MongoDB, एपीआई और केस क्लास न्यूज़ इंस्टेंस के उदाहरण की तुच्छ फिलिंग के साथ काम करने वाले सभी के लिए परिचित। अब तक, सब कुछ प्राथमिक है। बहुत अधिक।
कुछ और दिलचस्प चाहिए। एकत्रीकरण के बारे में कैसे?

टैग निकाल रहे हैं

 /** * News tag container * @param name * @param total */ case class Tags(name: String, total: Int) /** * Tags object allows to operate with tags in DB */ object Tags { /** * News collection contains all tag info */ private val col: MongoCollection = Database.collection("news") /** * Get all tags as [{name: "", total: 0}] array of objects * @return */ def allTags: Array[Tags] = { val group = MongoDBObject("$group" -> MongoDBObject( "_id" -> "$tags", "total" -> MongoDBObject("$sum" -> 1) )) val sort = MongoDBObject("$sort" -> MongoDBObject("total"-> -1)) try { col.aggregate(group,sort).results.map((o: DBObject) => { val name = o.as[MongoDBList]("_id").toSeq.mkString(", ") val total = o.as[Int]("total") Tags(name, total) }).toArray } catch { case e: MongoException => throw e } } }

.aggregate आपको बिना मानचित्र के चमत्कार करने की सुविधा देता है। और स्काला में काम का सिद्धांत कंसोल से ही है। एक तरह का पाइपलाइन-रास्ता, केवल कॉमा द्वारा अलग किया गया। टैग द्वारा समूहीकृत, कुल मिलाकर समान और संपूर्ण चीज़ को क्रमबद्ध करता है। बहुत बढ़िया।

वैसे, केसबाह एक गढ़ है

आप JSON-XMLed हैं

आपको कभी हार नहीं माननी चाहिए
आपको कभी निराश नहीं होने देंगे

क्योंकि सांख्यिकीय रूप से टाइप की गई भाषा के लिए, इस मामले में XML / JSON के साथ काम करना एक धोखा जैसा लगता है। संदेह से संक्षिप्त।
और वास्तव में, स्काला में XML पार्सिंग मेरी आंखों के लिए एक खुशी है (जावा में बड़े पैमाने पर कारखानों के बाद)।

XML पार्सर

 package models.parsers import scala.xml._ import models.News import java.util.Locale import java.text.{SimpleDateFormat, ParseException} import java.text._ import play.api.Play import collection.JavaConversions._ /** * Simple XML parser */ object Parser { /** * RSS urls from application.conf */ val urls = try { Play.current.configuration.getStringList("rss.urls").map(_.toList).getOrElse(List()) } catch { case e: Throwable => List() } /** * Download and parse XML, fill News object and pass it to callback * @param cb */ def downloadItems(cb: (News) => Unit) = { urls.foreach { (url: String) => try { parseItem(XML.load(url)).foreach(cb(_)) } catch { case e: Exception => throw e } } } /** * Parse standart RSS time * @param s * @return */ def parseDateTime(s: String): Long = { try { new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.ENGLISH).parse(s).getTime / 1000 } catch { case e: ParseException => 0 } } /** * For all items in RSS parse its content and return list of News objects * @param xml * @return */ def parseItem(xml: Elem): List[News] = (xml \\ "item").map(buildNews(_)).toList /** * Fill and return News object * @param node * @return */ def buildNews(node: Node) = new News( title = (node \\ "title").text, link = (node \\ "link").text, content = (node \\ "description").text, pubDate = parseDateTime((node \\ "pubDate").text), tags = Seq((node \\ "category").text)) }

मैं सहमत हूं
सबसे पहले, फॉर्म \ या \\ के नाम वाली विधियां एक स्टूपर में संचालित होती हैं। हालाँकि, यह कुछ समझ में आता है जब आप जावा से BigInteger को याद करते हैं।

JSON के बारे में क्या? स्काला में देशी JSON अब तक कोई भी व्यक्तिपरक नहीं है। धीमा और डरावना।
मुश्किल समय में, Play and its Writes / Reads from play.api.libs.json पैकेज play.api.libs.json । क्या किसी को PHP 5.4 से JsonSerializable इंटरफ़ेस पता है? तो प्ले में अभी भी आसान है!

JSON लिखते हैं

 case class News(val id: String = "0", val title: String, val link: String, val content: String, val tags: Seq[String], val pubDate: Long) /** * News object allows to operate with news in database. Companion object for News class */ object News { /** * Play Magic * @return */ implicit def newsWrites = Json.writes[News] /** * Converts array of news to json * @param src Array of News instances * @return JSON string */ def asJson(src: Array[News]) = { Json.stringify(Json.toJson(src)) } }

एक-लाइन पद्धति someObjectWrites सरल क्रमांकन मामलों में सभी मुद्दों को हटा देती है। स्काला में निहित परिवर्तन व्यवहार में उपयोग किया जाने वाला एक शक्तिशाली और सुविधाजनक उपकरण है।
लेकिन यह बहुत ही संगीन मामला है। जब आप कुछ विशेष या जटिल चाहते हैं, तो फंक्शनलिज्म और कॉम्बिनेटर बचाव में आते हैं।

तारों के माध्यम से कांटों के माध्यम से

जबकि उपयोगकर्ता ऊब रहा है और एक स्क्रिप्ट द्वारा सर्वर को भेजे गए अनुरोध के जवाब की प्रतीक्षा कर रहा है ... प्रतीक्षा करें। एक और दृश्य।
जैसा कि वादा किया गया था, CoffeeScript और AngularJS का उपयोग किया गया था। उत्पादन में इस बंडल का उपयोग शुरू करने के बाद, उपयोगकर्ता इंटरफ़ेस विकसित करते समय पीठ के ठीक नीचे दर्द की संख्या 78.5% कम हो गई। कोड की राशि की तरह।
यह इस कारण से है कि मैंने पाठक में इन स्टाइलिश, फैशनेबल और युवा प्रौद्योगिकियों का उपयोग करने का निर्णय लिया। और इसलिए भी कि मेरी पसंद के ढांचे में बोर्ड पर कॉफीस्क्रिप्ट और लेस कंपाइलर हैं।
वास्तव में, अनुभवी डेवलपर्स कुछ नया और दिलचस्प नहीं सीखेंगे, इसलिए मैं केवल कुछ दिलचस्प ट्रिक्स दिखाऊंगा।

अक्सर कोणीय नियंत्रकों के बीच डेटा का आदान-प्रदान करना आवश्यक होता है। और केवल परिष्कार करने वाले सज्जन ही नहीं जाते (जैसे कि लोकलस्टोरेज को लिखना) ...
और कास्केट बस खुल जाता है।

सेवा को बनाना और आवश्यक नियंत्रकों में इसे लागू करना पर्याप्त है

प्रचार

 define ["angular","ngInfinite"],(angular,infiniteScroll) -> newsModule = angular.module("News", ['infinite-scroll']) newsModule.factory 'broadcastService', ["$rootScope", ($rootScope) -> broadcastService = message: {}, broadcast: (sub, msg)-> if typeof msg == "number" then msg = {} this.message[sub] = angular.copy msg $rootScope.$broadcast(sub) ] newsModule

हम भेजते हैं

 define ["app/NewsModule"], (newsModule)-> newsModule.controller "PanelCtrl", ["$scope", "$http", "broadcastService", ($scope, $http, broadcastService)-> $scope.loadByTag = (tag) -> if tag.active tag.active = false broadcastService.broadcast("loadAll",0) else broadcastService.broadcast("loadByTag",tag.name) ]

हमें मिलता है

 define ["app/NewsModule","url"], (newsModule,urlParser)-> newsModule.controller "NewsCtrl", ["$scope", "$http", "broadcastService", ($scope, $http, broadcastService)-> #recieving message $scope.$on "loadAll", ()-> $scope.after = 0 $scope.tag = false $scope.busy = false $scope.loadByTag() ]

कोणीय में
सेवाएँ सिंगलटन हैं। इसलिए, हम इंस्टेंस बनाए बिना संदेशों को आगे और पीछे चला सकते हैं।

सभी आते हैं

आंत्र और पीठ में इस तरह की अराजक यात्रा के बाद, यह योग्‍य है।
फायदे और नुकसान, घातक और बहुत ज्यादा नहीं, हर किसी को अपने लिए चुनना चाहिए। हम अभी भी उस उपकरण का उपयोग करते हैं जहां यह कार्गो की खेती के बजाय, सही बैठता है?

मुझे पसंद आया:

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

पसंद नहीं आया:

फिर भी, संशोधित ताज़ा वर्कफ़्लो संशोधित स्रोतों के लगातार पुनर्संयोजन के कारण तंग काम करता है। घातक नहीं, लेकिन विचार की उड़ान को धीमा कर देता है
जेवीएम के साथ मिलकर फ्रेमवर्क की हवा की समस्याएं (\\ बनाम /) विन सिस्टम के तहत पूरी तरह से संकलित और चलने वाले एप्लिकेशन को चलाने की अनुमति नहीं देती हैं। केवल देव विधा में। और यहाँ विशेष रूप से प्रदर्शन को मापा नहीं गया है। सौभाग्य से, हाथ में कई निक्स सर्वर हैं
परीक्षण में कोई लॉगिंग नहीं। लकड़हारे में जंगली स्मृति लीक के कारण कथित रूप से। खैर, मैं पहले से ही उस पर उठा रहा हूँ।

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

आपका ध्यान देने के लिए धन्यवाद।

पुनश्च
यदि यह स्क्रिबबल थोड़ा सा लग रहा था - तो यहां बिटबकेट पर भंडार है ।

PlayFramework 2.2 और Scala के साथ RSS चलाएं