👩🏻‍🚀 🐢 🧛 कोटलिन / स्काला के साथ काम करने के बाद मुझे जावा में क्या याद आता है 🐋 👨🏻‍🏭 🚦

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

मौजूदा कक्षाओं का विस्तार

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

आइए देखें कि विज़िटर पैटर्न का उपयोग करके यह जावा में कैसे दिख सकता है

public class DotDemo { public static class Dot { private final int x; private final int y; public Dot(int x, int y) { this.x = x; this.y = y; } public String accept(Visitor visitor) { return visitor.visit(this); } public int getX() { return x; } public int getY() { return y; } } public interface Visitor { String visit(Dot dot); } public static class JsonVisitor implements Visitor { @Override public String visit(Dot dot) { return String .format("" + "{" + "\"x\"=%d, " + "\"y\"=%d " + "}", dot.getX(), dot.getY()); } } public static class XMLVisitor implements Visitor { @Override public String visit(Dot dot) { return "<dot>" + "\n" + " <x>" + dot.getX() + "</x>" + "\n" + " <y>" + dot.getY() + "</y>" + "\n" + "</dot>"; } } public static void main(String[] args) { Dot dot = new Dot(1, 2); System.out.println("-------- JSON -----------"); System.out.println(dot.accept(new JsonVisitor())); System.out.println("-------- XML ------------"); System.out.println(dot.accept(new XMLVisitor())); } }

पैटर्न और इसके उपयोग के बारे में अधिक

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

कोटलिन में एक्सटेंशन

 data class Dot (val x: Int, val y: Int) //      fun Dot.convertToJson(): String = "{\"x\"=$x, \"y\"=$y}" fun Dot.convertToXml(): String = """<dot> <x>$x</x> <y>$y</y> </dot>""" fun main() { val dot = Dot(1, 2) println("-------- JSON -----------") println(dot.convertToJson()) println("-------- XML -----------") println(dot.convertToXml()) }

स्काला में एक्सटेंशन

 object DotDemo extends App { // val is default case class Dot(x: Int, y: Int) implicit class DotConverters(dot: Dot) { def convertToJson(): String = s"""{"x"=${dot.x}, "y"=${dot.y}}""" def convertToXml(): String = s"""<dot> <x>${dot.x}</x> <y>${dot.y}</y> </dot>""" } val dot = Dot(1, 2) println("-------- JSON -----------") println(dot.convertToJson()) println("-------- XML -----------") println(dot.convertToXml()) }

यह बहुत बेहतर लग रहा है। कभी-कभी यह बहुतायत से मानचित्रण और अन्य परिवर्तनों के साथ वास्तव में पर्याप्त नहीं है।

मल्टी-थ्रेडेड कंप्यूटिंग चेन

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

योजनाबद्ध रूप से, इसे निम्नानुसार दर्शाया जा सकता है

आइए पहले जावा में समस्या को हल करने का प्रयास करें

जावा उदाहरण

  private static CompletableFuture<Optional<String>> calcResultOfTwoServices ( Supplier<Optional<Integer>> getResultFromFirstService, Function<Integer, Optional<Integer>> getResultFromSecondService ) { return CompletableFuture .supplyAsync(getResultFromFirstService) .thenApplyAsync(firstResultOptional -> firstResultOptional.flatMap(first -> getResultFromSecondService.apply(first).map(second -> first + " " + second ) ) ); }

इस उदाहरण में, परिणाम को नियंत्रित करने के लिए हमारी संख्या वैकल्पिक में लिपटी हुई है। इसके अलावा, थ्रेड्स के साथ सुविधाजनक काम के लिए कंप्लीटेबलफ्यूवन के अंदर सभी क्रियाएं की जाती हैं। मुख्य क्रिया तत्कालीनApplyAsync विधि में होती है। इस पद्धति में, हम एक तर्क के रूप में वैकल्पिक प्राप्त करते हैं। अगला, संदर्भ को नियंत्रित करने के लिए फ्लैटपाइप को कहा जाता है। यदि प्राप्त वैकल्पिक Optional.empty के रूप में लौटा है, तो हम दूसरी सेवा में नहीं जाएंगे।

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

क्या भाषा किसी तरह समस्या को हल करने में हमारी मदद कर सकती है। और फिर, स्काला की ओर मुड़ें। यहां बताया गया है कि आप इसे स्कैला टूल्स से कैसे हल कर सकते हैं।

स्काला उदाहरण

 def calcResultOfTwoServices(getResultFromFirstService: Unit => Option[Int], getResultFromSecondService: Int => Option[Int]) = Future { getResultFromFirstService() }.flatMap { firsResultOption => Future { firsResultOption.flatMap(first => getResultFromSecondService(first).map(second => s"$first $second" ) )} }

यह परिचित लग रहा है। और यह कोई संयोग नहीं है। यह scala.concurrent पुस्तकालय का उपयोग करता है, जो मुख्य रूप से java.concurrent पर एक आवरण है। खैर, स्काला हमारी और क्या मदद कर सकती है? तथ्य यह है कि फॉर्म फ्लैटपैन, ..., की श्रृंखला को मानचित्र के लिए अनुक्रम के रूप में दर्शाया जा सकता है।

स्काला पर दूसरा संस्करण उदाहरण

  def calcResultOfTwoServices(getResultFromFirstService: Unit => Option[Int], getResultFromSecondService: Int => Option[Int]) = Future { getResultFromFirstService() }.flatMap { firstResultOption => Future { for { first <- firstResultOption second <- getResultFromSecondService(first) } yield s"$first $second" } }

यह बेहतर हो गया है, लेकिन आइए अपने कोड को फिर से बदलने का प्रयास करें। बिल्लियों पुस्तकालय से कनेक्ट करें।

स्काला उदाहरण का तीसरा संस्करण

 import cats.instances.future._ def calcResultOfTwoServices(getResultFromFirstService: Unit => Option[Int], getResultFromSecondService: Int => Option[Int]): Future[Option[String]] = (for { first <- OptionT(Future { getResultFromFirstService() }) second <- OptionT(Future { getResultFromSecondService(first) }) } yield s"$first $second").value

अब यह इतना महत्वपूर्ण नहीं है कि OptionT का अर्थ क्या है। मैं सिर्फ यह दिखाना चाहता हूं कि यह ऑपरेशन कितना सरल और छोटा हो सकता है।

लेकिन कोटलिन के बारे में क्या? आइए कोरटाइन पर कुछ ऐसा ही करने की कोशिश करते हैं।

कोटलिन का उदाहरण

 val result = async { withContext(Dispatchers.Default) { getResultFromFirstService() }?.let { first -> withContext(Dispatchers.Default) { getResultFromSecondService(first) }?.let { second -> "$first $second" } } }

इस कोड की अपनी ख़ासियतें हैं। सबसे पहले, यह कॉरटिन के कोटलिन तंत्र का उपयोग करता है। Async के अंदर कार्य एक विशेष थ्रेड पूल में किया जाता है (फोर्कजॉइन नहीं) एक काम चोरी तंत्र के साथ। दूसरे, इस कोड के लिए एक विशेष संदर्भ की आवश्यकता होती है, जिसमें से async और withContext जैसे कीवर्ड लिए जाते हैं।

यदि आपको स्काला फ्यूचर पसंद है, लेकिन आप कोटलिन पर लिखते हैं, तो आप इसी तरह के स्कैल रैपर पर ध्यान दे सकते हैं। ऐसे टाइप करें।

धाराओं के साथ काम करें

समस्या को ऊपर और अधिक विस्तार से दिखाने के लिए, आइए पिछले उदाहरण का विस्तार करने का प्रयास करें: हम सबसे लोकप्रिय जावा प्रोग्रामिंग टूल्स - रिएक्टर , स्काला - एफएस 2 पर जाते हैं ।

एक स्ट्रीम में 3 फ़ाइलों के लाइन-बाय-लाइन रीडिंग पर विचार करें और वहां मैच खोजने का प्रयास करें।
यहाँ जावा में रिएक्टर के साथ ऐसा करने का सबसे आसान तरीका है।

जावा में रिएक्टर उदाहरण

  private static Flux<String> glueFiles(String filename1, String filename2, String filename3) { return getLinesOfFile(filename1).flatMap(lineFromFirstFile -> getLinesOfFile(filename2) .filter(line -> line.equals(lineFromFirstFile)) .flatMap(lineFromSecondFile -> getLinesOfFile(filename3) .filter(line -> line.equals(lineFromSecondFile)) .map(lineFromThirdFile -> lineFromThirdFile ) ) ); }

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

Scala पर fs2 से उदाहरण

  def findUniqueLines(filename1: String, filename2: String, filename3: String): Stream[IO, String] = for { lineFromFirstFile <- readFile(filename1) lineFromSecondFile <- readFile(filename2).filter(_.equals(lineFromFirstFile)) result <- readFile(filename3).filter(_.equals(lineFromSecondFile)) } yield result

ऐसा लगता है कि बहुत सारे बदलाव नहीं हैं, लेकिन यह बहुत बेहतर दिखता है।

उच्च तर्क और निहित के साथ व्यापार तर्क को अलग करना

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

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

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

एक जगह, हम इस तरह के तर्क का वर्णन कर सकते हैं

  def makeCatHappy[F[_]: Monad: CatClinicClient](): F[Unit] = for { catId <- CatClinicClient[F].getHungryCat memberId <- CatClinicClient[F].getFreeMember _ <- CatClinicClient[F].feedCatByFreeMember(catId, memberId) } yield ()

यहां एफ [_] ("एफ़ विद ए होल" के रूप में पढ़ा जाता है) का अर्थ है एक प्रकार पर एक प्रकार (कभी-कभी इसे रूसी साहित्य में प्रजाति कहा जाता है)। यह सूची, सेट, विकल्प, भविष्य, आदि हो सकते हैं। वह सब एक अलग प्रकार का एक कंटेनर है।

अगला, हम सिर्फ कोड निष्पादन के संदर्भ को बदलते हैं। उदाहरण के लिए, ठेस के माहौल के लिए हम कुछ ऐसा कर सकते हैं।

मुकाबला कोड कैसा दिख सकता है?

 class RealCatClinicClient extends CatClinicClient[Future] { override def getHungryCat: Future[Int] = Future { Thread.sleep(1000) // doing some calls to db (waiting 1 second) 40 } override def getFreeMember: Future[Int] = Future { Thread.sleep(1000) // doing some calls to db (waiting 1 second) 2 } override def feedCatByFreeMember(catId: Int, memberId: Int): Future[Unit] = Future { Thread.sleep(1000) // happy cat (waiting 1 second) println("so testy!") // Don't do like that. It is just for debug } }

परीक्षण कोड कैसा दिख सकता है

 class MockCatClinicClient extends CatClinicClient[Id] { override def getHungryCat: Id[Int] = 40 override def getFreeMember: Id[Int] = 2 override def feedCatByFreeMember(catId: Int, memberId: Int): Id[Unit] = { println("so testy!") // Don't do like that. It is just for debug } }

हमारा व्यावसायिक तर्क अब इस बात पर निर्भर नहीं करता है कि हमने किन फ्रेमवर्क, http-क्लाइंट और सर्वर का उपयोग किया है। किसी भी समय, हम संदर्भ बदल सकते हैं, और उपकरण बदल जाएगा।

इसे हायरकिंड और इंपैक्ट जैसे फीचर्स से हासिल किया जाता है। आइए पहले विचार करें, और इसके लिए हम जावा पर लौटेंगे।

कोड को देखते हैं

 public class Calcer { private CompletableFuture<Integer> getCalc(int x, int y) { } }

परिणाम वापस करने के कितने तरीके हैं? काफी कुछ। हम जोड़ सकते हैं, जोड़ सकते हैं, स्वैप कर सकते हैं और बहुत कुछ कर सकते हैं। अब कल्पना करें कि हमें स्पष्ट आवश्यकताएं दी गई हैं। हमें पहले नंबर को दूसरे में जोड़ना होगा। हम इसे कितने तरीकों से कर सकते हैं? ~~यदि आप कड़ी मेहनत करते हैं और अपने आप को बहुत परिष्कृत करते हैं ...~~ सामान्य तौर पर, केवल एक।

यहाँ वह है

 public class Calcer { private CompletableFuture<Integer> getCalc(int x, int y) { return CompletableFuture.supplyAsync(() -> x + y); } }

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

विशेषता पर विचार करें

 trait Calcer[F[_]] { def getCulc(x: Int, y: Int): F[Int] }

हम अपने पूर्णांक मान के कंटेनर प्रकार को निर्दिष्ट किए बिना लक्षण (निकटतम एनालॉग जावा में इंटरफ़ेस है) बनाते हैं।

इसके अलावा, यदि आवश्यक हो तो हम बस विभिन्न कार्यान्वयन बना सकते हैं।

ऐसे ही

  val futureCalcer: Calcer[Future] = (x, y) => Future {x + y} val optionCalcer: Calcer[Option] = (x, y) => Option(x + y)

इसके अलावा, Implicit जैसी एक दिलचस्प बात है। यह आपको हमारे पर्यावरण के संदर्भ को बनाने और इसके आधार पर विशेषता के कार्यान्वयन का चयन करने की अनुमति देता है।

ऐसे ही

  def userCalcer[F[_]](implicit calcer: Calcer[F]): F[Int] = calcer.getCulc(1, 2) def doItInFutureContext(): Unit = { implicit val futureCalcer: Calcer[Future] = (x, y) => Future {x + y} println(userCalcer) } doItInFutureContext() def doItInOptionContext(): Unit = { implicit val optionCalcer: Calcer[Option] = (x, y) => Option(x + y) println(userCalcer) } doItInOptionContext()

वैल से पहले सरलीकृत निहितार्थ - वर्तमान परिवेश के लिए एक चर जोड़ना, और फ़ंक्शन के तर्क के रूप में निहित का मतलब है कि पर्यावरण से चर लेना। यह कुछ हद तक एक अंतर्निहित बंद की याद दिलाता है।

कुल मिलाकर, यह पता चला है कि हम तीसरे पक्ष के पुस्तकालयों का उपयोग किए बिना एक मुकाबला और परीक्षण वातावरण बना सकते हैं।

लेकिन कोटलिन का क्या

वास्तव में इसी तरह से हम कोटलिन में कर सकते हैं:

 interface Calculator<T> { fun eval(x: Int, y: Int): T } object FutureCalculator : Calculator<CompletableFuture<Int>> { override fun eval(x: Int, y: Int) = CompletableFuture.supplyAsync { x + y } } object OptionalCalculator : Calculator<Optional<Int>> { override fun eval(x: Int, y: Int) = Optional.of(x + y) } fun <T> Calculator<T>.useCalculator(y: Int) = eval(1, y) fun main() { with (FutureCalculator) { println(useCalculator(2)) } with (OptionalCalculator) { println(useCalculator(2)) } }

यहां हम अपने कोड का निष्पादन संदर्भ भी निर्धारित करते हैं, लेकिन स्काला के विपरीत, हम इसे स्पष्ट रूप से चिह्नित करते हैं।
उदाहरण के लिए देखने वाले का धन्यवाद।

निष्कर्ष

सामान्य तौर पर, ये मेरे सारे दर्द नहीं हैं। और भी हैं। मुझे लगता है कि प्रत्येक डेवलपर का अपना है। अपने लिए, मैंने महसूस किया कि मुख्य बात यह समझना है कि परियोजना के लाभ के लिए वास्तव में क्या आवश्यक है। उदाहरण के लिए, मेरी राय में, यदि हमारे पास एक आराम सेवा है जो मानचित्रण और सरल तर्क के गुच्छा के साथ एक प्रकार के एडाप्टर के रूप में कार्य करती है, तो उपरोक्त सभी कार्यक्षमता बहुत उपयोगी नहीं है। स्प्रिंग बूट + जावा / कोटलिन ऐसे कार्यों के लिए एकदम सही है। बड़ी संख्या में एकीकरण और कुछ जानकारी एकत्र करने के साथ अन्य मामले हैं। ऐसे कार्यों के लिए, मेरी राय में, अंतिम विकल्प बहुत अच्छा लग रहा है। सामान्य तौर पर, यदि आप किसी कार्य के आधार पर उपकरण का चयन कर सकते हैं तो यह अच्छा है।

उपयोगी संसाधन:

कोटलिन / स्काला के साथ काम करने के बाद मुझे जावा में क्या याद आता है

मौजूदा कक्षाओं का विस्तार

मल्टी-थ्रेडेड कंप्यूटिंग चेन

धाराओं के साथ काम करें

उच्च तर्क और निहित के साथ व्यापार तर्क को अलग करना

निष्कर्ष

More articles: