रिएक्टिव प्रोग्रामिंग, क्या यह सबकुछ छोड़ने और सपने की ओर भागने के लिए लायक है

प्रतिक्रियाशील प्रोग्रामिंग के बारे में एक और लेख। और बस इस लाइन पर अपनी आँखें मत घुमाओ और कर्कश आवाज़ में ज़ोर से बोलो - "ठीक है, आप मुझे प्रतिक्रियात्मक प्रोग्रामिंग के बारे में और क्या बता सकते हैं ... एह?" यह दूसरों के झुंड से थोड़ा अलग है, जिसे कार्बन पेपर की तरह लिखा गया है, इसलिए इसमें कुछ चीजें लग सकती हैं ... अजीब या पूरी तरह से अनुचित, जैसे सॉर्ट किए गए हास्य।

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

यह दिलचस्प होगा।

ऊंचाई निरपेक्ष करने के लिए

और इसलिए, आइए कल्पना करें कि हम पूरी तरह से पागल हैं ... हालांकि यह शब्द राजनीतिक शुद्धता के लिए यहां अधिक प्रस्तुत किया जाएगा, क्योंकि हर कोई लेखक को जानता है कि वह एक बंद अपार्टमेंट में पूरे दिन बैठता है। यह रात में काम करता है, दिन में तीन हुक्का पीता है और सप्ताह में दो बार बाहर जाता है। यह आमतौर पर आपके चिकित्सक से मिलने के लिए होता है, लेकिन कभी-कभी इसका कारण पूरी तरह से अलग होता है - IKEA।

और इसलिए, हम पुराने तुल्यकालिक, लेकिन काम कोड लेते हैं:

int result = 1 + 2 * 4; 

और हम इसे फिर से भरने की कोशिश करते हैं, क्योंकि यह हमें लगता है ... हालांकि नहीं, यह बहुत अधिक है, कोई भी इसे अपने सही दिमाग में नहीं करेगा। कोई नहीं। अपने सही दिमाग में

 Mono<Integer> result = Flux.concat( Mono.just(1), Flux.concat(Mono.just(2), Mono.just(4)) .reduce((a, b) -> a * b)) .reduce((a, b) -> a + b); StepVerifier.create(result) .expectNext(9) .expectComplete() .verify(); 

लेकिन जैसा कि आपने देखा होगा, मैंने ऐसा किया है। और कृपया ध्यान दें! मैंने खुद को इस उदाहरण में एक से अधिक माइक्रोसर्विस के जोड़े का उपयोग करने से रोका, एक को जोड़कर और दूसरे को गुणा के लिए, जिसे मुझे rSocket और kafka माध्यम से संवाद करना होगा।

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

टिप दो। मैंने इसे लेख के अंत में छोड़ने का फैसला किया। लेकिन अगर सब कुछ देखने के बाद, आप तय करते हैं कि आपको इस d% & @ a से दूर रहना चाहिए, तो आप जानते हैं कि इसे कहाँ देखना है।

अधिक वास्तविक उदाहरण

आइए थोड़ा और यथार्थवादी उदाहरण लें। उदाहरण के लिए ... पेड़। क्यों वास्तव में उन्हें? क्योंकि हम सभी पेड़ों को वास्तविक जीवन में एक वस्तु और डेटा संरचना के रूप में पसंद करते हैं। यह हमारे आसपास के दुनिया के सबसे महत्वपूर्ण हिस्सों में से एक है। पेड़ ऑक्सीजन का उत्पादन करते हैं इसलिए हम सांस ले सकते हैं।

कई जानवर पेड़ों में रहते हैं, या इन वस्तुओं के संचय के स्थानों में (इन स्थानों को एक पार्क या वन कहा जाता है, इस पर निर्भर करता है), लेकिन जानवर, यहां तक ​​कि बेघर लोग, कार्डबोर्ड बक्से में रहते हैं जो मूल रूप से पेड़ थे।

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

हमारे पास एक पेड़ है, एक साधारण, निहत्था पेड़ जो हमारे कोड के लॉन में उगता है और किसी दिन बड़ा होने पर सपने देखता है, BST में बदल जाता है:

 public class TreeNode { public int val; public TreeNode left, right; public TreeNode(int val, TreeNode left, TreeNode right) { this.val = val; this.left = left; this.right = right; } public TreeNode(int val) { this(val, null, null); } //       TreeNode invert() { // ... } int sumOfLeftLeaves() { // ... } TreeNode searchBST(int val) { // .. } public List<Integer> toList() { List<Integer> list = new ArrayList<>(); if (left != null) list.addAll(left.toList()); list.add(val); if (right != null) list.addAll(right.toList()); return list; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; TreeNode treeNode = (TreeNode) o; return val == treeNode.val; } @Override public int hashCode() { return val; } @Override public String toString() { return toList().toString(); } } 

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

 public class TreeNode { public final Mono<Integer> value; public final Mono<TreeNode> left; public final Mono<TreeNode> right; public TreeNode(Mono<Integer> value, Mono<TreeNode> left, Mono<TreeNode> right) { this.value = value; this.left = left; this.right = right; } public TreeNode(int value, TreeNode left, TreeNode right) { this(Mono.just(value), Mono.justOrEmpty(left), Mono.justOrEmpty(right)); } public TreeNode(int value) { this(Mono.just(value), Mono.empty(), Mono.empty()); } public Flux<TreeNode> flux() { return Flux.concat( left.flatMapMany(TreeNode::flux), Mono.just(this), right.flatMapMany(TreeNode::flux) ); } @Override public String toString() { return flux() .flatMap(n -> n.value) .collectList() .map(Object::toString) .block(); } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; TreeNode treeNode = (TreeNode) o; return Objects.equals(value.block(), treeNode.value.block()); } @Override public int hashCode() { return value.block(); } 

आप हवा में लटका सवाल महसूस करते हैं - "क्यों?"। सबसे पहले, यह सुंदर है, और दूसरा यह बहुत ही स्केलेबल है, क्योंकि यह अतुल्यकालिक है, यह पर्यावरण के अनुकूल भी है और ग्रेटा ट्यूनबर्ग एक बार एक विशाल स्ट्रैप-ऑन के साथ ट्रेन में हमारे पास नहीं आएगा ... आप जानते हैं कि मेरा क्या मतलब है। और यह मत भूलो कि अब हमारे पास बैक-प्रेस है। और वैसे, मैं आपको याद दिलाता हूं कि परीक्षण कवरेज के बिना कोई भी रिफैक्टिंग नहीं किया जा सकता है।

 public class TreeNodeTest { @Test public void testFlux() { TreeNode tree = new TreeNode(4, new TreeNode(2, new TreeNode(1), new TreeNode(3)), new TreeNode(7, new TreeNode(6), new TreeNode(9))); StepVerifier.create(tree.flux().flatMap(n -> n.value)) .expectNext(1, 2, 3, 4, 6, 7, 9) .expectComplete() .verify(); } } 

बहुत बढ़िया। शुरुआत की गई है, अब हमें सिर्फ पुराने, उबाऊ, तुल्यकालिक पेड़ में तीन सरल तरीकों invert , sumOfLeftLeaves और searchBST को searchBST है।

पलटना

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

  public TreeNode invert() { return invert(this); } private TreeNode invert(TreeNode root) { if (root == null) return null; TreeNode swap = new TreeNode(root.val); swap.right = invert(root.left); swap.left = invert(root.right); return swap; } 

देखो कि क्या हुआ जब हमने इसे फिर से लिखा, यह नए रंगों के साथ खेला, और एक बोनस के रूप में, हमें मुफ्त में अशक्त सुरक्षा मिली।

 public Mono<TreeNode> invert() { return Mono.just(this) .map(n -> new TreeNode(n.value, n.right.flatMap(TreeNode::invert), n.left.flatMap(TreeNode::invert) )); } @Test public void testInvert() { TreeNode tree = new TreeNode(4, new TreeNode(2, new TreeNode(1), new TreeNode(3)), new TreeNode(7, new TreeNode(6), new TreeNode(9))); Flux<Integer> inverted = tree.invert() .flatMapMany(TreeNode::flux) .flatMap(n -> n.value); StepVerifier.create(inverted) .expectNext(9, 7, 6, 4, 3, 2, 1) .expectComplete() .verify(); } 

sumOfLeftLeaves

आमतौर पर लोगों को दो प्रकारों में विभाजित किया जाता है, पहला प्रकार वे हैं जो समझते हैं कि यह विधि इसके नाम से क्या करेगी, और अन्य सभी लोग जिन्होंने वर्षों से अपना कमरा नहीं छोड़ा है और कभी पेड़ नहीं देखे हैं।

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

लेकिन क्यों शब्द, चलो व्यापार के लिए नीचे उतरो, देखें कि यह कैसा था ...

  public int sumOfLeftLeaves() { return sumOfLeftLeaves(false, this); } public int sumOfLeftLeaves(boolean left, TreeNode root) { if (root == null) return 0; if (root.left == null && root.right == null && left) return root.val; return sumOfLeftLeaves(true, root.left) + sumOfLeftLeaves(false, root.right); } 

... और यह कैसे बन गया

  public Mono<Integer> sumOfLeftLeaves() { return sumOfLeftLeaves(Mono.just(this), false) .flatMap(n -> n.value) .reduce(Integer::sum); } private Flux<TreeNode> sumOfLeftLeaves(Mono<TreeNode> node, boolean left) { return node .flux() .concatMap(n -> Flux.concat( sumOfLeftLeaves(n.left, true), Flux.first(n.left, n.right) .map(x -> new TreeNode(0)) .switchIfEmpty( Mono.just(n) ) .filter(x -> left), sumOfLeftLeaves(n.right, false) )); } @Test public void testSumOfLeftLeaves() { TreeNode tree = new TreeNode(3, new TreeNode(9, new TreeNode(11), null), new TreeNode(20, new TreeNode(15), new TreeNode(7)) ); StepVerifier.create(tree.sumOfLeftLeaves()) .expectNext(26) .expectComplete() .verify(); } 

वाह! तो प्रतिक्रियाशील। बहुत कुछ। बहुत भयानक। इतनी अशक्त सुरक्षा। बहुत पीछे। इसलिए स्केलेबल ...

वैसे, हमारे पास अभी भी एक और तरीका है, जिसमें, मैं आपसे वादा करता हूं, हम इस सारी शक्ति को सही दिशा में निर्देशित करेंगे।

searchBST

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

  public TreeNode searchBST(int val) { return searchBST(this, val); } public TreeNode searchBST(TreeNode root, int val) { if (root == null) return null; if (val < root.val) return searchBST(root.left, val); else if (val > root.val) return searchBST(root.right, val); else return root; } 

बस इसे महसूस करो:

  public Mono<TreeNode> testSearchBST(int val) { return searchBST(Mono.just(this), val); } private Mono<TreeNode> searchBST(Mono<TreeNode> root, int val) { return root.flatMap(node -> node.value .filter(v -> v > val) .flatMap(v -> searchBST(node.left, val)) .switchIfEmpty(node.value .filter(v -> v < val) .flatMap(v -> searchBST(node.right, val)) .switchIfEmpty(node.value .filter(v -> v == val) .flatMap(v -> root) ) )); } @Test public void searchBST() { TreeNode tree = new TreeNode(4, new TreeNode(2, new TreeNode(1), new TreeNode(3)), new TreeNode(7)); StepVerifier.create(tree.searchBST(3).flatMap(n -> n.value)) .expectNext(3) .expectComplete() .verify(); } 

जोड़ने के लिए और कुछ नहीं। यह रिएक्टिव प्रोग्रामिंग है, यह सबसे अधिक है।

अभी खत्म नहीं हुआ है

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

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

 public class ListNode { public int val; public ListNode next; public ListNode(int val) { this.val = val; } public ListNode(int val, ListNode next) { this.val = val; this.next = next; } public static ListNode of(int... array) { if (array.length < 1) return null; ListNode head = new ListNode(array[0]); ListNode tail = head; for (int i = 1; i < array.length; i++) { ListNode next = new ListNode(array[i]); tail.next = next; tail = next; } return head; } public ListNode last() { if (next != null) return next.last(); return this; } } public class ListTestNode { public Mono<Boolean> hasCycle(ListNode head) { return Mono.justOrEmpty(head) .flatMapMany(node -> { Flux<ListNode> flux = Flux.generate(() -> head, (n, sink) -> { if (n == null) { sink.complete(); return null; } sink.next(n); return n.next; }); Flux<ListNode> fast = flux.skip(1); Flux<ListNode> slow = flux.flatMap(n -> Flux.just(n, n)); return fast.zipWith(slow); }) .any(objects -> objects.getT1() == objects.getT2()) .defaultIfEmpty(false); } @Test public void hasCycle() { StepVerifier.create(hasCycle(null)) .expectNext(false) .expectComplete() .verify(); ListNode withoutCycle = ListNode.of(1, 2, 3, 4, 5, 6); StepVerifier.create(hasCycle(withoutCycle)) .expectNext(false) .expectComplete() .verify(); ListNode withCycle = ListNode.of(1, 2, 3, 4, 5, 6); withCycle.last().next = withCycle.next.next; StepVerifier.create(hasCycle(withCycle)) .expectNext(true) .expectComplete() .verify(); } 

चूंकि हमने तकनीकी साक्षात्कार के विषय को छुआ है, इसलिए हमें कोष्ठक के बाड़े की जांच के प्रिय कार्य के बारे में नहीं भूलना चाहिए। शो तो चलना ही चाहिए!

  public Mono<Boolean> isValidParentheses(String s) { return Flux.range(0, s.length()) .map(s::charAt) .reduceWith(() -> "", (str, c) -> { if (c == '{' || c == '[' || c == '(') return str + c; char last = str.charAt(str.length() - 1); if (c == '}' && last != '{') return str; if (c == ']' && last != '[') return str; if (c == ')' && last != '(') return str; return str.substring(0, str.length() - 1); }) .map(String::isEmpty); } @Test public void testIsValidParentheses() { StepVerifier.create(isValidParentheses("()")) .expectNext(true) .expectComplete() .verify(); StepVerifier.create(isValidParentheses("()[]{}")) .expectNext(true) .expectComplete() .verify(); StepVerifier.create(isValidParentheses("{()[]()}")) .expectNext(true) .expectComplete() .verify(); StepVerifier.create(isValidParentheses("()")) .expectNext(true) .expectComplete() .verify(); StepVerifier.create(isValidParentheses("(]")) .expectNext(false) .expectComplete() .verify(); StepVerifier.create(isValidParentheses("([)]")) .expectNext(false) .expectComplete() .verify(); } 

वाह। इतना अपरिवर्तनीय ... बहुत प्रतिक्रियाशील।

टिप नंबर दो

वैसे, जैसा कि मैंने वादा किया था, लेख के अंत में सलाह नंबर दो है: . कभी-कभी यह कम से कम मूर्खतापूर्ण और अव्यवहारिक लगेगा।