web-dev-qa-db-fra.com

Spring Boot Application (Application de démarrage Spring): délai d'expiration par défaut pour tout point de terminaison d'API repos ou configuration facile pour contrôler le délai

J'utilise la version actuelle du démarrage de Spring (1.4.x) et je me demande s'il existe un délai d'attente par défaut pour les appels api. Je l’ai testé en mettant des points d’arrêt, mais c’est resté en attente et sans délai. J'essayais également de configurer le délai d'attente par défaut pour toutes mes applications Spring-Boot en utilisant des paramètres d'annotation ou yml. 

J'ai trouvé quelques alternatives (l'une d'entre elles ici ), mais en utilisant callable, nous avons ajouté du code de logique non professionnelle supplémentaire dans lequel définir quelque chose dans un bean xml n'était plus à la mode dans les dernières applications de démarrage printanier.

javaspringrestspring-bootmicroservices
3
Gunjan Kumar

Je suis d'accord avec toutes les options ci-dessus et j'ai essayé l'option ci-dessous dans mon application de démarrage de printemps. Cela fonctionne parfaitement bien maintenant. Voici l'exemple de code sous forme de haricot. Maintenant, il suffit de @AutowireRestTemplate où (Java class) j'en ai besoin. 

   @Bean
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplate();
        ((SimpleClientHttpRequestFactory) restTemplate.getRequestFactory()).setConnectTimeout(15000);
        ((SimpleClientHttpRequestFactory) restTemplate.getRequestFactory()).setReadTimeout(15000);

        return restTemplate;
    }
3
Gunjan Kumar

Vous pouvez essayer server.connection-timeout=5000 dans votre application.properties.À partir de documentation officielle :

server.connection-timeout = # Délai, en millisecondes, pendant lequel les connecteurs attendent une autre requête HTTP avant de fermer la connexion. S'il n'est pas défini, la valeur par défaut spécifique au conteneur du connecteur sera utilisée. Utilisez une valeur de -1 pour ne pas indiquer de délai d’expiration (infini).

UPDATE: Je viens de remarquer que vous utilisez une architecture microservice, donc si vous devez gérer les délais d'attente lors de la communication entre microservices, je vous suggère de le gérer du côté client au lieu du côté serveur. Si le microservice que vous essayez d'appeler est surchargé et que ses performances se dégradent à un point tel qu'elle affecte considérablement l'expérience utilisateur, il est parfois préférable de renvoyer des données de secours plutôt que de simplement supprimer la demande. 

Imaginons que nous ayons un site Web de commerce électronique doté d'une architecture de microservice et que l'un de ses microservices qui donne des recommandations à l'utilisateur devienne extrêmement lent. Dans ce cas, la solution préférée serait de renvoyer des données de secours qui pourraient figurer parmi les 10 produits les plus populaires ce mois-ci plutôt que d'afficher la page d'erreur 5xx au client. De plus, en cas d’échec du délai des demandes suivantes, nous pouvons prendre la décision d’éviter d’envoyer des demandes au «service de recommandation» et renvoyer immédiatement les données de secours. Après un certain temps, nous pouvons essayer d'envoyer à nouveau une demande au 'service de recommandation', et si elle redevient saine, utilisez-la au lieu des données de secours. 

Ceci s’appelle modèle Circuit Breaker et il existe déjà une implémentation de ce modèle dans un cadre appelé Hystrix. Voici un article de Nice qui l'explique en profondeur: http://www.baeldung.com/spring-cloud-netflix-hystrix . Spring Cloud Feign + Spring Cloud Hystrix a vraiment l’air sympa, compte tenu du fait qu’ils fonctionnent immédiatement avec des services Discovery (par exemple, Spring Cloud Eureka).

3
Danylo Zatorsky

Il y a plusieurs façons de faire ça:

1) Utiliser ClientHttpRequestFactory avec RestTemplate:

public RestTemplate restTemplate() {
    return new RestTemplate(clientHttpRequestFactory());
}

private ClientHttpRequestFactory clientHttpRequestFactory() {
    HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
    factory.setReadTimeout(timeinMillis);
    factory.setConnectTimeout(timeinMillis);
    return factory;
}

2) La deuxième méthode consiste à utiliser callable, mais je suppose que vous avez déjà exploré cette solution.

2
tryingToLearn

Le délai peut être défini à l'aide de la propriété connectionTimeout de Tomcat. 

Veuillez vous référer à cette réponse pour savoir comment la définir pour Tomcat.

Configuration de maxKeepAliveRequests dans Tomcat intégré à Spring Boot

0
zeagord