HttpClientలో అసమకాలిక అభ్యర్థనలు

5.1 sendAsync() పద్ధతి

మీరు HttpClient ఉపయోగించి అసమకాలిక అభ్యర్థనలను కూడా పంపవచ్చు. సాధారణంగా ఇది మూడు సందర్భాలలో జరుగుతుంది.

మొదటి సందర్భం ఏమిటంటే, అభ్యర్థనకు చాలా సమయం పడుతుంది , ఉదాహరణకు, ఫైల్‌ను పంపడం / స్వీకరించడం. ఈ ఆపరేషన్ అప్పుడు ప్రారంభించబడుతుంది మరియు అసమకాలికంగా అమలు చేయబడుతుంది.

రెండవ సందర్భం ఏమిటంటే, మీరు చాలా తరచుగా అభ్యర్థనలను పంపవలసి ఉంటుంది మరియు తదుపరిది పంపే ముందు మునుపటి అభ్యర్థన నుండి ప్రతిస్పందన కోసం మీరు వేచి ఉండకూడదు.

చివరకు, మూడవ సందర్భంలో - మీ అభ్యర్థన యొక్క ఫలితం మీకు ముఖ్యమైనది కాదు . ఉదాహరణకు, మీరు మీ స్క్రీన్‌ని నిమిషానికి ఒకసారి స్క్రీన్‌షాట్ తీసి సర్వర్‌కి పంపండి. అంటే, మీ అప్లికేషన్ యొక్క తర్కం చాలా అభ్యర్థనలు ఉన్నాయని మరియు అన్ని వాటిని చేరుకోలేదని ఊహిస్తుంది. అప్పుడు సూత్రం ప్రకారం పని చేయడం సౌకర్యంగా ఉంటుంది - పంపండి మరియు మరచిపోండి.

అసమకాలిక అభ్యర్థనను పంపడానికి, మీరు sendAsync()HttpClient క్లాస్ యొక్క వస్తువుపై ఒక పద్ధతిని కాల్ చేయాలి. ఈ పద్ధతి వెంటనే నిష్క్రమిస్తుంది మరియు a CompletableFuture<HttpResponse>. దానితో, అభ్యర్థన వాస్తవానికి ఎప్పుడు అమలు చేయబడుతుందో మీరు ట్రాక్ చేయవచ్చు, అలాగే అభ్యర్థన పూర్తయిన తర్వాత నిర్దిష్ట కోడ్‌ను అమలు చేయవచ్చు. ఉదాహరణ:

HttpClient client = HttpClient.newBuilder().build();
 
CompletableFuture<HttpResponse<String>> response = client.sendAsync(
        request,
        HttpResponse.BodyHandlers.ofString()
);

ఈ పద్ధతి లోపల HttpResponseని కలిగి ఉన్న sendAsync()ఆబ్జెక్ట్‌ను అందిస్తుంది CompletableFuture, ఇందులో సర్వర్ తిరిగి వచ్చే స్ట్రింగ్ ఉంటుంది.

5.2 ఎగ్జిక్యూటర్() పద్ధతి, ఎగ్జిక్యూటర్ సర్వీస్

అలాగే, HttpClient మీరు దానికి ExecutorService(థ్రెడ్‌ల పూల్) పాస్ చేయడానికి అనుమతిస్తుంది, అది అసమకాలిక అభ్యర్థనలను నిర్వహించడానికి ఉపయోగించబడుతుంది. వాస్తవానికి, సర్వర్-సైడ్ జావా అప్లికేషన్‌లలో, ఇది ఎల్లప్పుడూ జరుగుతుంది.

అన్నింటికంటే, మీ APIకి వచ్చే ప్రతి అభ్యర్థన కోసం, మీరు వేరే చోట అనేక అసమకాలిక అభ్యర్థనలను ప్రారంభిస్తే, మీకు తగినంత థ్రెడ్‌లు ఉండవు. ఉదాహరణ:

ExecutorService executorService = Executors.newFixedThreadPool(2);
 
CompletableFuture<HttpResponse<String>> response1 = HttpClient.newBuilder()
  .executor(executorService)
  .build()
  .sendAsync(request, HttpResponse.BodyHandlers.ofString());
 
CompletableFuture<HttpResponse<String>> response2 = HttpClient.newBuilder()
  .executor(executorService)
  .build()
  .sendAsync(request, HttpResponse.BodyHandlers.ofString());

థ్రెడ్ పూల్ సెట్ చేయకపోతే, డిఫాల్ట్ .java.util.concurrent.Executors.newCachedThreadPool()