Comment faire plusieurs appels d'API de manière efficace dans java

Question

J'ai une liste de 100k utilisateurs. Je dois parcourir la liste et faire un appel d'API au serveur pour obtenir le résultat. Chaque fois que je crée une nouvelle connexion URL et que je fais l'appel APi, je ferme la connexion une fois que j'ai lu le flux d'entrée, mais cela prend trop de temps.

Existe-t-il une manière optimisée de le faire, comme utiliser la même instance de connexion URL plusieurs fois au lieu de la fermer? ou aller pour une autre bibliothèque tierce améliorera la vitesse d'exécution?

J'appelle la méthode ci-dessous dans ma boucle pour obtenir la sortie.

private String getOutput(String loginName) { 
    String responseStatus = null; 
    HttpURLConnection connection = null; 

    try { 
     URL url= new URL(<<https://api.junk.123.com/output>>); 

     connection = (HttpURLConnection) url.openConnection(); 
     connection.setRequestMethod("POST"); 
     connection.setRequestProperty("apikey", "authentication key"); 
     connection.setUseCaches(false); 
     connection.setDoOutput(true); 

     //Send request 
     try(DataOutputStream outputStream = new DataOutputStream(connection.getOutputStream())){ 
      JsonObject jsonParam = new JsonObject(); 
      jsonParam.putString("loginName", "loginName"); 
      outputStream.writeBytes(jsonParam.toString()); 
      outputStream.flush(); 
     } 

     //Get response 

     InputStream inputStream; 
     if(connection.getResponseCode() == HttpURLConnection.HTTP_OK){ 
      inputStream = connection.getInputStream(); 
     } else { 
      inputStream = connection.getErrorStream(); 
     } 
     if(null == inputStream){ 
      return String.valueOf(connection.getResponseCode()); 
     } 

     StringBuilder response = new StringBuilder(); 
     try (BufferedReader inputBuffer = new BufferedReader(new InputStreamReader(inputStream))) { 
      String line; 
      while (null != (line = inputBuffer.readLine())) { 
       response.append(line); 
       response.append("\r"); 
      } 
     } 

     JsonObject jsonObject = new JsonObject(response.toString()); 
     if (connection.getResponseCode() == HttpURLConnection.HTTP_OK) { 
      responseStatus = "success"; 
     } else { 
      responseStatus = String.valueOf(connection.getResponseCode()) + jsonObject.getString("errorMessage") ; 
     } 
    } catch (MalformedURLException e) { 
     logger.error("Malformed URL exception occurred while calling the API", entry.getKey(), e); 
    } catch (IOException e) { 
     logger.error("Creation of connection failed while calling the API", entry.getKey(), e); 
    } catch (Exception e) { 
     logger.error("Error occurred while calling the API", entry.getKey(), e); 
    } finally { 
     if (null != connection){ 
      connection.disconnect(); 
     } 
    } 
    return responseStatus; 
} 

Answer 1

Ce Q & A explique que les connexions HTTP persistantes sont mises en œuvre dans les coulisses par HttpURLConnection:

• Persistent HttpURLConnection in Java

Toutefois, cela peut ne pas suffire. Si vous utilisez un seul thread côté client pour effectuer la récupération, vous êtes limité par le temps aller-retour pour les demandes; c'est-à-dire que vous ne pouvez pas démarrer une deuxième requête tant que le résultat du premier n'a pas été renvoyé. Vous pouvez y remédier ... jusqu'à un certain point ... en utilisant plusieurs threads côté client.

Cependant (# 2) envoyer plusieurs demandes en parallèle a aussi ses limites. Au-delà d'un certain point, vous allez saturer le client, le serveur ou le réseau. En outre, certains serveurs ont des mécanismes de limitation pour limiter le nombre de requêtes qu'un client peut effectuer.

La manière d'obtenir un débit maximal serait de repenser l'API afin qu'une seule requête puisse obtenir des informations pour plusieurs utilisateurs.