Comment utiliser RestTemplate efficacement dans l'environnement Multithread?
Je suis en train de travailler sur un projet dans lequel j'ai besoin de faire une URL HTTP appel à mon serveur qui est en cours d'exécution Restful Service
qui retourne la réponse comme une Chaîne JSON.
Ci-dessous mon code principal qui est à l'aide de la future
et callables
-
public class TimeoutThreadExample {
private ExecutorService executor = Executors.newFixedThreadPool(10);
public String getData() {
Future<String> future = executor.submit(new Task());
String response = null;
try {
response = future.get(100, TimeUnit.MILLISECONDS);
} catch (TimeoutException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
return response;
}
}
Ci-dessous est mon Task
classe qui implémente l' Callable
interface et utilise le RestTemplate
...
class Task implements Callable<String> {
private RestTemplate restTemplate = new RestTemplate();
public String call() throws Exception {
String url = "some_url";
String response = restTemplate.getForObject(url, String.class);
return response;
}
}
Et maintenant j'ai le code ci-dessous dans une autre classe DemoTest
qui appelle à la getData
méthode dans TimeoutThreadExample
classe 5000 times
de façon séquentielle -
public class DemoTest {
public static void main(String[] args) {
TimeoutThreadExample bc = new TimeoutThreadExample();
for (int i = 0; i <= 5000; i++) {
// TimerTest timer = TimerTest.getInstance(); //line 1
bc.getData();
// timer.getDuration(); //line 2
}
}
}
Donc ma question est doit RestTemplate
être statique ici dans mon Task class
comme si je le vois bien, je suis à recréer l'ensemble du pool de connexion pour chaque demande dans RestTemplate
qui n'est pas la bonne façon, je suppose..
REMARQUE: Si je fais RestTemplate statique, alors que je vois mieux les performances de bout en bout par rapport aux non statique RestTemplate
après commentant ligne1 et ligne2 dans DemoTest
classe qui mesure la performance.
En général, quelle est la bonne façon de l'utiliser RestTemplate
dans le Multithreading environnement? Actuellement, je suis en appelant de manière séquentielle getData
méthode de 5000 fois une par une, mais certains clients de les appeler dans un multithread façon donc besoin de savoir quel est le meilleur moyen d'avoir des RestTemplate dans un environnement multithread..
Peut-être d'utiliser ConnectionFactory dans le RestTemplate constructeur? Toutes les pensées?
Mise à JOUR:-
public class TimeoutThreadExample {
private ExecutorService executor = Executors.newFixedThreadPool(10);
private RestTemplate restTemplate = new RestTemplate();
public String getData() {
Future<String> future = executor.submit(new Task(restTemplate));
String response = null;
try {
response = future.get(100, TimeUnit.MILLISECONDS);
} catch (TimeoutException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
return response;
}
}
Et en dessous de mon TaskClass
-
class Task implements Callable<String> {
private RestTemplate restTemplate;
public Task(RestTemplate restTemplate) {
this.restTemplate = restTemplate;
}
public String call() throws Exception {
String url = "some_url";
String response = restTemplate.getForObject(url, String.class);
return response;
}
}
OriginalL'auteur AKIWEB | 2014-01-20
Vous devez vous connecter pour publier un commentaire.
Corrigez-moi si je n'ai pas compris votre question. Il semble très similaire à la précédente ici.
Là, nous avons déterminé que
RestTemplate
est thread-safe. Il n'y a donc aucune raison de ne pas les partager où que cela a du sens, c'est à dire. où que vous soyez avec elle de la même manière.Votre exemple semble être l'endroit parfait pour le faire.
Comme vous l'avez indiqué, en recréant une nouvelle instance de
RestTemplate
pour chaqueTask
exemple, c'est du gaspillage.Je voudrais créer le
RestTemplate
dansTimeoutThreadExample
et le passer à laTask
comme un argument du constructeur.De cette façon, vous partagez le
RestTemplate
exemple entre tous vosTask
objets.Noter que
RestTemplate
utiliseSimpleClientHttpRequestFactory
pour créer ses connexions.RestTemplate est thread-safe, mais vous devez également être sûr que le sous-fifre http gestionnaire de connexion est thread-safe, pour, par exemple, à l'aide de
org.apache.commons.httpclient.MultiThreadedHttpConnectionManager
(veuillez noter que je suis en utilisant commons-httpclient 3.1, si cela peut ne pas s'appliquer à d'autres versions)Un autre proche en double: stackoverflow.com/a/21241233/1103872. Apparemment, l'OP a deux identités ici.
Dans ce sens, oui.
Voici un pointeur. BTW, j'ai vraiment vous conseiller de regarder dans la mise en œuvre de URLConnection---je pense que vous allez changer votre esprit au sujet de "plus difficile à travailler" 🙂
OriginalL'auteur Sotirios Delimanolis
J'ai mon multi-thread-safe singleton RESTE modèle câblé comme ça au printemps:
Veuillez noter que je suis en utilisant un
OAuthRestTemplate
, etmyResource
se réfère à la oauth ressources des trucs que j'ai omis car il n'est pas pertinent. Au lieu d'uneOAuthRestTemplate
vous pourriez tout aussi bien utiliser unorg.springframework.web.client.RestTemplate
http://docs.spring.io/spring/docs/3.2.4.RELEASE/javadoc-api/org/springframework/web/client/RestTemplate.htmlOriginalL'auteur Taylor
Un
RestTemplate
est thread-safe, une fois construite, de sorte que vous pouvez construire une instance et qui ont toutes vos tâches de la partager. Qui sera beaucoup plus efficace, car vous éliminez le coût de construction de chaque tâche, et de réduire la charge sur le garbage collector.OriginalL'auteur Raedwald