RestTemplate doit être statique déclarés globalement?

Je suis à l'aide de Java Appelable Avenir dans mon code. Ci-dessous mon code principal qui utilise l'avenir et callables -

public class TimeoutThread {

    public static void main(String[] args) throws Exception {

        ExecutorService executor = Executors.newFixedThreadPool(5);
        Future<String> future = executor.submit(new Task());

        try {
            System.out.println("Started..");
            System.out.println(future.get(3, TimeUnit.SECONDS));
            System.out.println("Finished!");
        } catch (TimeoutException e) {
            System.out.println("Terminated!");
        }

        executor.shutdownNow();
    }
}

Ci-dessous est mon Task classe qui implémente l'Appelable de l'interface et j'ai besoin de générer l'URL en fonction du nom d'hôte que nous avons, et puis faire un appel à des SERVEURS à l'aide de RestTemplate. Si il n'y a aucune exception dans le premier domaine, je vais générer l'URL pour un autre nom d'hôte et je vais essayer de faire un appel.

class Task implements Callable<String> {
    private static RestTemplate restTemplate = new RestTemplate();

    @Override
    public String call() throws Exception {

    //.. some code

    for(String hostname : hostnames)  {
            if(hostname == null) {
                continue;
            }
            try {
                String url = generateURL(hostname);         
                response = restTemplate.getForObject(url, String.class);

                //make a response and then break
                break;

            } catch (Exception ex) {
                ex.printStackTrace(); //use logger
            }
        }
    }
}

Donc ma question dois-je déclarer RestTemplate comme statique de la variable globale? Ou il ne devrait pas être statique dans ce scénario?

OriginalL'auteur AKIWEB | 2014-01-15

12

Il n'a pas d'importance de toute façon, static ou de l'instance.

RestTemplate's méthodes pour effectuer les requêtes HTTP sont thread-safe, donc si vous avez un RestTemplate instance par Task instance ou d'une instance partagée pour tous les Task cas n'est pas pertinent (sauf pour la collecte des ordures).

Personnellement, je voudrais créer le RestTemplate à l'extérieur de la Task classe et la passer en argument à une Task constructeur. (Utilisation de l'Inversion de Contrôle chaque fois que possible.)

"Personnellement, je voudrais créer le ..." ou utiliser l'injection de dépendance 😉 +1
Bon, c'est ce que je voulais dire, l'Inversion de contrôle dans la mesure du possible. L'utilisation d'un conteneur d'injection de dépendances, si cela est possible.
Merci pour vos suggestions.. Pouvez-vous fournir un exemple de la façon dont vous créez RestTemplate en dehors de la classe et de le passer en argument à la Tâche constructeur?
Créer un Task constructeur qui accepte un RestTemplate paramètre. Alors ne new Task(restTemplate) où restTemplate est un RestTemplate de référence géré par l'appelant.
Je Vous remercie.. Mais quel sera l'avantage de cette? Juste essayer de comprendre quelle est la différence avec la façon dont je suis en train de faire et vous le suggérez?

OriginalL'auteur Sotirios Delimanolis
3

À partir d'une simultanéité point de vue, il n'a pas d'importance. RestTemplate est thread-safe, donc une seule instance ou de plusieurs instances est sans importance pour le bon fonctionnement du programme.

Mais vous pouvez envisager d' AsyncRestTemplate au lieu de cela, comme indiqué ici.

Aussi, comme d'autres, mentionner, vous devriez envisager un Cio approche pour séparer la création de votre client RESTE de son utilisation. Cette article de Martin Fowler est de la séminal de discussion sur le sujet.

+1 pour Martin Fowler.
J'ai aussi la même question here liées à RestTemplate qui vous m'avez aidé la dernière fois. Si possible, pouvez-vous m'aider ici? Toute aide est grandement appréciée.
Je ne vois pas synchronisés utilisé n'importe où dans le RestTemplate ou les classes de la mise en œuvre de l'exécution de la demande de la logique. Comment est-il "thread-safe"?

OriginalL'auteur Vidya
2

Dans mon cas particulier, j'ai trouvé quelques raisons pour lesquelles on peut vouloir avoir plus d'une instance de RestTemplate.

Le RestTemplate est une manière d'invoquer un point de terminaison distant, mais l'intégration HTTP semble trompeusement simple et quand vous commencer à trouver des scénarios spéciaux qui ne s'appliquent pas à l'ensemble de vos appels d'API, c'est quand vous réalisez que vous avez besoin d'un moyen de définir certains paramètres dans une base de cas par cas.

Exemples de tels scénarios sont les suivants:
- Nous avons des équipes différentes, dans la société, et, par erreur, nous n'étions pas d'accord sur le format de l'heure que nous voulions utiliser dans nos modèles. Maintenant, Api différentes de différentes équipes utilisent différents formats de temps qui nous oblige à définir les différents JSON mapper les paramètres pour ces cas. Ceci peut également se produire si vous avez d'invoquer services de tiers.
- Pas toutes les Api que nous appelons ont le même niveau de service accords ou se comportent de la même toute l'année. En haute saison, certaines Api peut avoir pour support plus de trafic, etc. Cela signifie que le délai d'attente de connexion paramètres peuvent être différents pour les différentes Api et parfois même, selon les besoins. Ainsi, des paramètres comme le délai d'attente de connexion, timeout en lecture et en écriture délai d'attente peut être configuré différemment selon le service que vous êtes en invoquant.
- Peut-être disjoncteur réglage, à l'instar de ceux de Hytrix, peuvent être configurés par le service, et ainsi d'avoir un RestTemplate instance par service permet plus de possibilité de configurer les paramètres dans une base de cas par cas.
Un autre cas d'utilisation pour avoir plus d'une RestTemplate est que j'ai une application qui interagit avec plusieurs serveurs HTTP, chacun avec différentes informations d'identification et les types d'authentification. Pour chaque serveur, j'ai un autre RestTemplate.
Concernant le point n ° 2, vous ne pouvez modifier le délai d'expiration de la requestFactory même après votre RestTemplate est initialisé? Donc ServiceA.methodA() peut définir dynamiquement le délai d'attente juste avant de faire la demande, et même pour ServiceB.methodA(). Corrigez-moi si je me trompe parce que je suis en train de parvenir à une bonne conception de mon projet. Merci
D'accord, nous aussi, ayant une situation similaire. Dans notre application, nous avons besoin de vous connecter à 3/de plus en plus différents, HTTP/HTTPS serveur et pour chacun nous avons à définir des délais d'attente et une personnalisation de l'HTTPClient. Ainsi, pour certains, nous devons utiliser un restTemplate de HttpComponentsClientHttpRequestFactory qui ont une fonction de l'utilisation de ses propres configurable client et pour quelques SimpleClientHttpRequestFactory. Et donc à la séparation des RestTemplate (si minimuim de même type peut être utilisé). Encore, si quelqu'un a des goodway en dehors de cela merci de faire partager.

OriginalL'auteur Edwin Dalorzo
1

Comme déjà dit, RestTemplate est thread-safe.

Mais, pour les tests unitaires, l'utilisation d'une variable statique va vous apporter quelques problèmes pour se moquer de ses appels. Donc, pensez à injecter le RestTemplate en utilisant le constructeur de la classe:
```
@Service
class LoginService {

    private final RestTemplate restTemplate;

    public LoginService(final RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }
}
```
OriginalL'auteur Dherik

Vous devez vous connecter pour publier un commentaire.