HttpClient இல் ஒத்திசைவற்ற கோரிக்கைகள்

5.1 sendAsync() முறை

நீங்கள் HttpClient ஐப் பயன்படுத்தி ஒத்திசைவற்ற கோரிக்கைகளையும் அனுப்பலாம். பொதுவாக இது மூன்று சந்தர்ப்பங்களில் செய்யப்படுகிறது.

முதல் வழக்கு, கோரிக்கை மிக நீண்ட நேரம் எடுக்கும் , எடுத்துக்காட்டாக, ஒரு கோப்பை அனுப்புதல் / பெறுதல். இந்த செயல்பாடு பின்னர் ஒத்திசைவற்ற முறையில் தொடங்கப்பட்டு செயல்படுத்தப்படுகிறது.

இரண்டாவது வழக்கு, நீங்கள் அடிக்கடி கோரிக்கைகளை அனுப்ப வேண்டும் மற்றும் அடுத்த கோரிக்கையை அனுப்பும் முன் முந்தைய கோரிக்கையின் பதிலுக்காக நீங்கள் காத்திருக்க விரும்பவில்லை.

இறுதியாக, மூன்றாவது வழக்கு - உங்கள் கோரிக்கையின் முடிவு உங்களுக்கு முக்கியமல்ல . எடுத்துக்காட்டாக, உங்கள் திரையின் ஸ்கிரீன்ஷாட்டை நிமிடத்திற்கு ஒருமுறை எடுத்து சர்வருக்கு அனுப்புங்கள். அதாவது, உங்கள் விண்ணப்பத்தின் தர்க்கம் பல கோரிக்கைகள் இருப்பதாகவும், அவை அனைத்தும் அடையவில்லை என்றும் கருதுகிறது. பின்னர் கொள்கையின்படி வேலை செய்வது வசதியானது - அனுப்பவும் மறந்துவிடவும்.

ஒத்திசைவற்ற கோரிக்கையை அனுப்ப, நீங்கள் sendAsync()HttpClient வகுப்பின் பொருளின் ஒரு முறையை அழைக்க வேண்டும். இந்த முறை உடனடியாக வெளியேறி ஒரு CompletableFuture<HttpResponse>. இதன் மூலம், கோரிக்கை எப்போது செயல்படுத்தப்படுகிறது என்பதை நீங்கள் கண்காணிக்கலாம், அத்துடன் கோரிக்கை முடிந்ததும் குறிப்பிட்ட குறியீட்டை இயக்கலாம். உதாரணமாக:

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

இந்த முறையானது ஒரு HttpResponse உள்ளே இருக்கும் sendAsync()ஒரு பொருளை வழங்குகிறது CompletableFuture, அதில் சர்வர் திரும்பும் சரம் உள்ளது.

5.2 எக்ஸிகியூட்டர்() முறை, எக்ஸிகியூட்டர் சர்வீஸ்

ExecutorServiceமேலும், HttpClient ஆனது , ஒத்திசைவற்ற கோரிக்கைகளைச் செய்யப் பயன்படுத்தப்படும் (இழைகளின் தொகுப்பு) அதை அனுப்ப அனுமதிக்கிறது . உண்மையில், சர்வர் பக்க ஜாவா பயன்பாடுகளில், இது எப்போதும் செய்யப்படுகிறது.

எல்லாவற்றிற்கும் மேலாக, உங்கள் 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()