🎀 ✴️ 🕺 JAX-RS के साथ प्रतिक्रियाशील प्रोग्रामिंग 🛀🏽 ☣️ 🏆

सभी को नमस्कार!

पिछले वर्ष, जावा एंटरप्राइज डेवलपर पाठ्यक्रम सफलतापूर्वक लॉन्च किया गया है और हमारे पास इस विषय पर अंतिम सामग्री है, जिसे हम आपके साथ साझा करना चाहते हैं, जो अतुल्यकालिक दृष्टिकोण के उपयोग और उत्तरदायी उत्तरदायी अनुप्रयोगों के विकास के लिए मंचन पर चर्चा करता है।

चलो चलते हैं।

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

लगभग सभी भाषाएं और रूपरेखाएं अपने पारिस्थितिक तंत्र में इस दृष्टिकोण का उपयोग करती हैं, और जावा के नवीनतम संस्करण कोई अपवाद नहीं हैं। इस लेख में, मैं बताऊंगा कि जावा ईई 8 और जावा 8 कार्यक्षमता में जेएएक्स-आरएस के नवीनतम संस्करण का उपयोग करके कैसे प्रतिक्रियाशील प्रोग्रामिंग को लागू किया जा सकता है।

जेट मैनीफेस्टो

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

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

जावा 8 और जावा ईई 8. में रिएक्टिव प्रोग्रामिंग शुरू की गई थी। जावा ने CompletableFuture और कॉन्सेप्ट ऑफ CompletableFuture जैसी अवधारणाओं को पेश किया और जावा ने जेसीएस-आरएस में रिएक्टिव क्लाइंट एपीआई जैसे विनिर्देशों में इन सुविधाओं का उपयोग करना शुरू किया।

JAX-RS 2.1 रिएक्टिव क्लाइंट एपीआई

आइए देखें कि जावा ईई 8 अनुप्रयोगों में कैसे प्रतिक्रियाशील प्रोग्रामिंग का उपयोग किया जा सकता है। इस प्रक्रिया को समझने के लिए, आपको जावा ईई एपीआई के कुछ बुनियादी ज्ञान की आवश्यकता है।

JAX-RS 2.1 ने प्रतिक्रियात्मक प्रोग्रामिंग के समर्थन के साथ REST क्लाइंट बनाने के लिए एक नया तरीका पेश किया। JAX-RS में दिया गया डिफ़ॉल्ट इनवॉकर कार्यान्वयन समकालिक है, जिसका अर्थ है कि बनाया गया क्लाइंट सर्वर के समापन बिंदु पर एक अवरुद्ध कॉल भेजेगा। एक उदाहरण कार्यान्वयन लिस्टिंग 1 में प्रस्तुत किया गया है।

लिस्टिंग 1

 Response response = ClientBuilder.newClient() .target("http://localhost:8080/service-url") .request() .get();

संस्करण 2.0 के साथ शुरू, JAX-RS क्लाइंट सिनेम पर एक एसिंक्रोनस इनवॉकर बनाने के लिए सहायता प्रदान करता है जिसमें एसिंक्स async() विधि के लिए एक सरल कॉल है, जैसा कि लिस्टिंग 2 में दिखाया गया है।

लिस्टिंग 2

 Future<Response> response = ClientBuilder.newClient() .target("http://localhost:8080/service-url") .request() .async() .get();

क्लाइंट पर एक एसिंक्रोनस इनवॉकर का उपयोग करने से प्रकार javax.ws.rs.core.Response का एक Future उदाहरण देता है। यह प्रतिक्रिया को पोलिंग करने के लिए नेतृत्व कर सकता है, future.get() लिए एक कॉल के साथ future.get() , या एक कॉलबैक को पंजीकृत करना जिसे HTTP प्रतिक्रिया उपलब्ध होने पर कॉल किया जाएगा। दोनों कार्यान्वयन अतुल्यकालिक प्रोग्रामिंग के लिए उपयुक्त हैं, लेकिन चीजें आमतौर पर जटिल हो जाती हैं यदि आप कॉलबैक को समूह करना चाहते हैं या इन अतुल्यकालिक निष्पादन मिनीमा में सशर्त मामले जोड़ना चाहते हैं।

JAX-RS 2.1 क्लाइंट के निर्माण के लिए नए JAX-RS रिएक्टिव क्लाइंट API के साथ इन समस्याओं को दूर करने के लिए एक प्रतिक्रियाशील तरीका प्रदान करता है। यह क्लाइंट बिल्ड के दौरान rx() विधि को कॉल करने जितना आसान है। लिस्टिंग 3 में, rx() विधि क्लाइंट रनटाइम पर मौजूद रिएक्टिव इनवॉकर लौटाती है, और क्लाइंट टाइप कंप्लीशनस्टेज.आरएक्स CompletionStage.rx() की प्रतिक्रिया देता है, जो कि एक साधारण कॉल के साथ सिंक्रोनस इनवॉकर से एसिंक्रोनस इनवॉकर में संक्रमण की अनुमति देता है।

लिस्टिंग 3

 CompletionStage<Response> response = ClientBuilder.newClient() .target("http://localhost:8080/service-url") .request() .rx() .get();

CompletionStage<> जावा 8 में शुरू किया गया एक नया इंटरफ़ेस है। यह एक गणना का प्रतिनिधित्व करता है, जो कि बड़े गणना के ढांचे में एक कदम हो सकता है, जैसा कि नाम से पता चलता है। JAX-RS को हिट करने वाला यह एकमात्र जावा 8 रिएक्टिविटी प्रतिनिधि है।
प्रतिक्रिया उदाहरण प्राप्त करने के बाद, मैं AcceptAsync() को कॉल कर सकता हूं, जहां मैं कोड का एक टुकड़ा प्रदान कर सकता हूं जो प्रतिक्रिया उपलब्ध होने पर एसिंक्रोनस रूप से निष्पादित करेगा, जैसा कि लिस्टिंग 4 में दिखाया गया है।

लिस्टिंग 4

 response.thenAcceptAsync(res -> { Temperature t = res.readEntity(Temperature.class); //do stuff with t });

एक समापन बिंदु REST के लिए प्रतिक्रियाशीलता जोड़ना

प्रतिक्रियात्मक दृष्टिकोण JAX-RS में ग्राहक पक्ष तक सीमित नहीं है; इसका उपयोग सर्वर की तरफ भी किया जा सकता है। एक उदाहरण के लिए, पहले मैं एक सरल स्क्रिप्ट बनाऊंगा जहां मैं एक गंतव्य के स्थानों की सूची का अनुरोध कर सकता हूं। प्रत्येक स्थिति के लिए, मैं तापमान मान प्राप्त करने के लिए किसी अन्य बिंदु पर स्थान डेटा के साथ एक अलग कॉल करूंगा। गंतव्यों का इंटरैक्शन चित्र 1 में दिखाया जाएगा।

चित्रा 1. गंतव्य बिंदुओं के बीच बातचीत

सबसे पहले, मैं बस डोमेन मॉडल को परिभाषित करता हूं, और फिर प्रत्येक मॉडल के लिए सेवाएं। 5 को सूचीबद्ध करने से पता चलता है कि Forecast वर्ग कैसे परिभाषित किया जाता है, जो Location और Temperature वर्गों को लपेटता है।

लिस्टिंग 5

 public class Temperature { private Double temperature; private String scale; // getters & setters } public class Location { String name; public Location() {} public Location(String name) { this.name = name; } // getters & setters } public class Forecast { private Location location; private Temperature temperature; public Forecast(Location location) { this.location = location; } public Forecast setTemperature( final Temperature temperature) { this.temperature = temperature; return this; } // getters }

पूर्वानुमान सूची को लपेटने के लिए, ServiceResponse वर्ग ServiceResponse लिस्टिंग 6 में लागू किया गया है।

लिस्टिंग 6

 public class ServiceResponse { private long processingTime; private List<Forecast> forecasts = new ArrayList<>(); public void setProcessingTime(long processingTime) { this.processingTime = processingTime; } public ServiceResponse forecasts(List<Forecast> forecasts) { this.forecasts = forecasts; return this; } // getters }

ListRes 7 में दिखाए गए LocationResource /location नमूना पथ के साथ लौटे तीन नमूना स्थानों को परिभाषित करता है।

लिस्टिंग 7

 @Path("/location") public class LocationResource { @GET @Produces(MediaType.APPLICATION_JSON) public Response getLocations() { List<Location> locations = new ArrayList<>(); locations.add(new Location("London")); locations.add(new Location("Istanbul")); locations.add(new Location("Prague")); return Response.ok(new GenericEntity<List<Location>>(locations){}).build(); } }

ListResource 8 में दिखाया गया है एक दिए गए स्थान के लिए 30 और 50 के बीच एक यादृच्छिक रूप से उत्पन्न तापमान मान देता है। एक सेंसर रीड को अनुकरण करने के लिए 500 एमएस विलंब को कार्यान्वयन में जोड़ा गया है।

लिस्टिंग 8

 @Path("/temperature") public class TemperatureResource { @GET @Path("/{city}") @Produces(MediaType.APPLICATION_JSON) public Response getAverageTemperature(@PathParam("city") String cityName) { Temperature temperature = new Temperature(); temperature.setTemperature((double) (new Random().nextInt(20) + 30)); temperature.setScale("Celsius"); try { Thread.sleep(500); } catch (InterruptedException ignored) { ignored.printStackTrace(); } return Response.ok(temperature).build(); } }

सबसे पहले, मैं तुल्यकालिक ForecastResource के कार्यान्वयन को दिखाऊंगा। स्रोत (सूची 9 देखें), जो सभी स्थानों को लौटाता है। फिर, प्रत्येक स्थिति के लिए, वह डिग्री सेल्सियस में मान प्राप्त करने के लिए तापमान सेवा को कॉल करता है।

लिस्टिंग 9

 @Path("/forecast") public class ForecastResource { @Uri("location") private WebTarget locationTarget; @Uri("temperature/{city}") private WebTarget temperatureTarget; @GET @Produces(MediaType.APPLICATION_JSON) public Response getLocationsWithTemperature() { long startTime = System.currentTimeMillis(); ServiceResponse response = new ServiceResponse(); List<Location> locations = locationTarget .request() .get(new GenericType<List<Location>>(){}); locations.forEach(location -> { Temperature temperature = temperatureTarget .resolveTemplate("city", location.getName()) .request() .get(Temperature.class); response.getForecasts().add( new Forecast(location).setTemperature(temperature)); }); long endTime = System.currentTimeMillis(); response.setProcessingTime(endTime - startTime); return Response.ok(response).build(); } }

जब पूर्वानुमान गंतव्य के रूप में /forecast का अनुरोध किया जाता है, तो आपको लिस्टिंग 10. में दिखाए गए एक के समान आउटपुट मिलेगा। ध्यान दें कि अनुरोध प्रसंस्करण समय 1.533 एमएस लिया गया, जो तार्किक है, क्योंकि तीन अलग-अलग स्थानों से तापमान मूल्यों के लिए एक तुल्यकालिक अनुरोध 1.5 तक जोड़ता है। एमएस।

लिस्टिंग 10

 { "forecasts": [ { "location": { "name": "London" }, "temperature": { "scale": "Celsius", "temperature": 33 } }, { "location": { "name": "Istanbul" }, "temperature": { "scale": "Celsius", "temperature": 38 } }, { "location": { "name": "Prague" }, "temperature": { "scale": "Celsius", "temperature": 46 } } ], "processingTime": 1533 }

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

लिस्टिंग 11

 @Path("/reactiveForecast") public class ForecastReactiveResource { @Uri("location") private WebTarget locationTarget; @Uri("temperature/{city}") private WebTarget temperatureTarget; @GET @Produces(MediaType.APPLICATION_JSON) public void getLocationsWithTemperature(@Suspended final AsyncResponse async) { long startTime = System.currentTimeMillis(); //   (stage)    CompletionStage<List<Location>> locationCS = locationTarget.request() .rx() .get(new GenericType<List<Location>>() {}); //      , //  ,   , //    CompletionStage final CompletionStage<List<Forecast>> forecastCS = locationCS.thenCompose(locations -> { //      //   ompletionStage List<CompletionStage<Forecast>> forecastList = //      //     locations.stream().map(location -> { //     //      //    final CompletionStage<Temperature> tempCS = temperatureTarget .resolveTemplate("city", location.getName()) .request() .rx() .get(Temperature.class); //   CompletableFuture,   //    //      return CompletableFuture.completedFuture( new Forecast(location)) .thenCombine(tempCS, Forecast::setTemperature); }).collect(Collectors.toList()); //    CompletableFuture, //     completable future //  return CompletableFuture.allOf( forecastList.toArray( new CompletableFuture[forecastList.size()])) .thenApply(v -> forecastList.stream() .map(CompletionStage::toCompletableFuture) .map(CompletableFuture::join) .collect(Collectors.toList())); }); //   ServiceResponse, //       //    . //   future    // forecastCS,    //      CompletableFuture.completedFuture( new ServiceResponse()) .thenCombine(forecastCS, ServiceResponse::forecasts) .whenCompleteAsync((response, throwable) -> { response.setProcessingTime( System.currentTimeMillis() - startTime); async.resume(response); }); } }

प्रतिक्रियात्मक कार्यान्वयन पहली नज़र में जटिल लग सकता है, लेकिन अधिक सावधानीपूर्वक अध्ययन के बाद, आप देखेंगे कि यह काफी सरल है। ForecastReactiveResource के क्रियान्वयन में ForecastReactiveResource मैं पहले JAX-RS रिएक्टिव क्लाइंट API का उपयोग करके लोकेशन सेवाओं के लिए एक ग्राहक कॉल बनाता हूं। जैसा कि मैंने ऊपर उल्लेख किया है, यह जावा ईई 8 के लिए एक ऐड-ऑन है, और यह केवल rx() पद्धति का उपयोग करके एक प्रतिक्रियाशील कॉल बनाने में मदद करता है।

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

और अब, चलो पूर्वानुमान के पूर्वानुमान सूची में परिभाषित चरणों को पूरा करने के चरणों के रूप में इकट्ठा करते हैं। प्रत्येक पूर्वानुमान के लिए एक पूरा होने का चरण बनाने के लिए, मैं स्थान के आधार पर डेटा पास करता हूं, और फिर tempCS वैरिएबल tempCS , फिर से JAX-RS रिएक्टिव क्लाइंट एपीआई का उपयोग करके, जो शहर के नाम के साथ तापमान सेवा को कॉल करता है। यहाँ, मैं क्लाइंट बनाने के लिए resolveTemplate() विधि का उपयोग करता resolveTemplate() , और यह मुझे एक पैरामीटर के रूप में कलेक्टर को शहर का नाम देने की अनुमति देता है।

स्ट्रीमिंग में अंतिम चरण के रूप में, मैं एक पैरामीटर के रूप में नए Forecast उदाहरण को पूरा करते हुए CompletableFuture.completedFuture() को कॉल करता हूँ। मैं इस भविष्य को tempCS चरण के साथ tempCS हूं ताकि मेरे पास निगरानी स्थानों के लिए एक तापमान मूल्य हो।

पूरा करने योग्य CompletableFuture.allOf() 11 लिस्टिंग में विधि forecastCS चरण के लिए पूर्ण चरण सूची में कनवर्ट करता है। इस चरण को पूरा करने पर एक बड़ा पूर्ण भविष्य का उदाहरण मिलता है जब सभी उपलब्ध पूर्ण भविष्य की वस्तुएं पूर्ण होती हैं।

सेवा प्रतिक्रिया ServiceResponse वर्ग का एक उदाहरण है, इसलिए मैं एक पूर्ण भविष्य बनाता हूं, और फिर forecastCS सूची के साथ forecastCS पूरा करने के चरण को संयोजित करता हूं और सेवा प्रतिक्रिया समय की गणना करता हूं।

बेशक, प्रतिक्रियाशील प्रोग्रामिंग केवल सर्वर पक्ष को अतुल्यकालिक रूप से चलाने के लिए मजबूर करता है; क्लाइंट पक्ष को तब तक ब्लॉक किया जाएगा जब तक कि सर्वर अनुरोधकर्ता को प्रतिक्रिया नहीं भेजता। इस समस्या को दूर करने के लिए, सर्वर सेंटेड इवेंट्स (SSE) का उपयोग आंशिक रूप से उपलब्ध होने पर प्रतिक्रिया भेजने के लिए किया जा सकता है ताकि प्रत्येक स्थान के लिए तापमान मान एक-एक करके क्लाइंट को प्रेषित हो। ForecastReactiveResource उत्पादन का संकेत। स्रोत एक सूची लिस्टिंग 12 में प्रस्तुत एक के समान होगा। जैसा कि आउटपुट में दिखाया गया है, प्रसंस्करण समय 515 एमएस है, जो एक स्थान से तापमान मान प्राप्त करने के लिए एक आदर्श रनटाइम है।

लिस्टिंग 12

 { "forecasts": [ { "location": { "name": "London" }, "temperature": { "scale": "Celsius", "temperature": 49 } }, { "location": { "name": "Istanbul" }, "temperature": { "scale": "Celsius", "temperature": 32 } }, { "location": { "name": "Prague" }, "temperature": { "scale": "Celsius", "temperature": 45 } } ], "processingTime": 515 }

निष्कर्ष

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

प्रतिक्रियाशील प्रोग्रामिंग केवल एक सिंक्रोनस से एक अतुल्यकालिक मॉडल को लागू करने से अधिक है; यह नेस्टिंग स्टेज जैसी अवधारणाओं के साथ काम करना भी आसान करता है। जितना अधिक इसका उपयोग किया जाता है, समानांतर प्रोग्रामिंग में जटिल लिपियों का प्रबंधन करना उतना ही आसान होगा।

अंत

आपका ध्यान के लिए धन्यवाद। हमेशा की तरह, हम आपकी टिप्पणियों और प्रश्नों की प्रतीक्षा कर रहे हैं।

JAX-RS के साथ प्रतिक्रियाशील प्रोग्रामिंग

More articles: