Explication détaillée du ruban intégré par RestTemplate des composants springcloud

Cet article explique comment Springcloud intègre le ruban. Différents composants Springcloud (feign, zuul, RestTemplate) intègrent le ruban différemment. Cet article examine d'abord RestTemplate.

Le diagramme de classes de RestTemplate est le suivant

• HttpAccessor Principalement créé sur la base de ClientHttpRequestFactoryClientHttpRequest

• InterceptingHttpAccessor étend HttpAccessor pour créer un InterceptingClientHttpRequest intercepté. L'intercepteur ClientHttpRequestInterceptor sera défini ici. C'est le cœur du ruban intégré lorsque RestTemplate initie un http. demande d'appel, il passera d'abord par l'intercepteur, puis lancera la requête http.

Comment est mis en place l'intercepteur ClientHttpRequestInterceptor ? Dans la classe LoadBalancerAutoConfiguration, il y a le code suivant :

@LoadBalanced
@Autowired(required = false)
private List<RestTemplate> restTemplates = Collections.emptyList();

Tant que l'annotation @LoadBalanced est ajoutée, le RestTemplate sera injecté Lorsque le composant spring retry n'est pas introduit, la configuration suivante est chargée :

@Configuration
@ConditionalOnMissingClass("org.springframework.retry.support.RetryTemplate")
static class LoadBalancerInterceptorConfig {
    @Bean
    public LoadBalancerInterceptor ribbonInterceptor(
        LoadBalancerClient loadBalancerClient,
        LoadBalancerRequestFactory requestFactory) {
        return new LoadBalancerInterceptor(loadBalancerClient, requestFactory);
    }

    @Bean
    @ConditionalOnMissingBean
    public RestTemplateCustomizer restTemplateCustomizer(
        final LoadBalancerInterceptor loadBalancerInterceptor) {
        return new RestTemplateCustomizer() {
            @Override
            public void customize(RestTemplate restTemplate) {
                List<ClientHttpRequestInterceptor> list = new ArrayList<>(
                    restTemplate.getInterceptors());
                list.add(loadBalancerInterceptor);
                restTemplate.setInterceptors(list);
            }
        };
    }
}

De cette façon, RestTemplate est configuré avec LoadBalancerInterceptor. Jetons un coup d'œil à l'ensemble du processus d'appel

<. 🎜>L'ensemble du processus est un peu compliqué. L'essentiel est de passer par l'intercepteur LoadBalancerInterceptor et de lancer un appel d'équilibrage de charge via RibbonLoadBalancerClient. RibbonLoadBalancerClientI combine LoadBalancer, il a donc la capacité d'équilibrer la charge, ce qui est le principe du ruban que nous avons expliqué dans l'article précédent.

Nous n'avons pas dessiné le processus réel de lancement d'une requête http dans la figure. La valeur par défaut est créée par

Le diagramme de classes de SimpleClientHttpRequestFactory est le suivant : ClientHttpRequestFactory

<🎜. >

À partir du diagramme de séquence d'appels, nous pouvons voir que nous appelons d'abord

pour obtenir

Ils intègrent InterceptingClientHttpRequestFactory et les intercepteurs par combinaison InterceptingClientHttpRequest initient le. appel. À ce moment-là, il confie à sa classe interne ClientHttpRequestFactory le soin de le gérer. La logique de base : InterceptingClientHttpRequestInterceptingRequestExecution

effectuera d'abord la première exécution de la collection d'intercepteurs. il rappellera et exécutera else. Le code lance en fait une requête http. Il existe deux manières principales d'implémenter l'interface

@Override
public ClientHttpResponse execute(HttpRequest request, byte[] body) throws IOException {
    if (this.iterator.hasNext()) {
        ClientHttpRequestInterceptor nextInterceptor = this.iterator.next();
        return nextInterceptor.intercept(request, body, this);
    }else {
        ClientHttpRequest delegate = requestFactory.createRequest(request.getURI(), request.getMethod());
        for (Map.Entry<String, List<String>> entry : request.getHeaders().entrySet()) {
            List<String> values = entry.getValue();
            for (String value : values) {
                delegate.getHeaders().add(entry.getKey(), value);
            }
        }
        if (body.length > 0) {
            StreamUtils.copy(body, delegate.getBody());
        }
        return delegate.execute();
    }
}

 :

ClientHttpRequestFactory

L'une est
• , en utilisant la méthode. fourni par J2SE (tous deux fournis par la méthode du package java.net) pour créer la connexion de requête HTTP sous-jacente

  SimpleClientHttpRequestFactory

Une solution consiste à utiliser la méthode
• La couche inférieure utilise HttpClient pour. accéder au service HTTP distant Vous pouvez utiliser HttpClient pour configurer des informations telles que le pool de connexions et le certificat.

  HttpComponentsClientHttpRequestFactory

RestTemplate utilise SimpleClientHttpRequestFactory par défaut, qui appelle en interne HttpConnection de jdk. Le délai d'expiration par défaut est -1. Vous pouvez définir le délai d'attente comme ceci :

Utiliser.

@Bean
@LoadBalanced
public RestTemplate restTemplate() {
    SimpleClientHttpRequestFactory factory  = new SimpleClientHttpRequestFactory();
    factory.setConnectTimeout(1000 * 2);//连接超时时间
    factory.setReadTimeout(1000 * 1);//读超时时间
    return new RestTemplate(factory);
}

Vous pouvez utiliser un pool de connexions (recommandé), et vous pouvez également définir une stratégie de nouvelle tentative (non étudiée spécifiquement)

HttpComponentsClientHttpRequestFactorySi vous souhaitez activer le mécanisme de nouvelle tentative, nous pouvons introduire le composant de nouvelle tentative de Spring

De cette façon, springcloud-ribbon ajoutera la configuration suivante :

<dependency>
    <groupId>org.springframework.retry</groupId>
    <artifactId>spring-retry</artifactId>
    <version>版本号</version>
</dependency>

@Configuration
@ConditionalOnClass(RetryTemplate.class)
public static class RetryAutoConfiguration {
    @Bean
    public RetryTemplate retryTemplate() {
        RetryTemplate template =  new RetryTemplate();
        template.setThrowLastExceptionOnExhausted(true);
        return template;
    }

    @Bean
    @ConditionalOnMissingBean
    public LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory() {
        return new LoadBalancedRetryPolicyFactory.NeverRetryFactory();
    }
}

@Configuration
@ConditionalOnClass(RetryTemplate.class)
public static class RetryInterceptorAutoConfiguration {
    @Bean
    @ConditionalOnMissingBean
    public RetryLoadBalancerInterceptor ribbonInterceptor(
        LoadBalancerClient loadBalancerClient, LoadBalancerRetryProperties properties,
        LoadBalancedRetryPolicyFactory lbRetryPolicyFactory,
        LoadBalancerRequestFactory requestFactory) {
        return new RetryLoadBalancerInterceptor(loadBalancerClient, properties,
                                                lbRetryPolicyFactory, requestFactory);
    }

    @Bean
    @ConditionalOnMissingBean
    public RestTemplateCustomizer restTemplateCustomizer(
        final RetryLoadBalancerInterceptor loadBalancerInterceptor) {
        return new RestTemplateCustomizer() {
            @Override
            public void customize(RestTemplate restTemplate) {
                List<ClientHttpRequestInterceptor> list = new ArrayList<>(
                    restTemplate.getInterceptors());
                list.add(loadBalancerInterceptor);
                restTemplate.setInterceptors(list);
            }
        };
    }
}

L'intercepteur est remplacé par

@Bean
@ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
@ConditionalOnMissingBean
    public LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory(SpringClientFactory clientFactory) {
    return new RibbonLoadBalancedRetryPolicyFactory(clientFactory);
}

, où le composant retry retryTemplate est intégré. La stratégie de nouvelle tentative est configurée par l'interface

et la classe d'implémentation par défaut est RetryLoadBalancerInterceptor Voici les paramètres de configuration par défaut RetryHandlerDefaultLoadBalancerRetryHandler

Ce qui précède est efficace globalement. , cela ne sera efficace que pour une certaine personne. Un client ruban prend effet. MaxAutoRetries et MaxAutoRetriesNextServer sont utilisés ensemble. Le nombre maximum de tentatives est pour chaque serveur. Si MaxAutoRetries=1 et MaxAutoRetriesNextServer=1 sont définis, le nombre maximum de tentatives déclenchées est de 4 fois.

#最大的重试次数
ribbon.MaxAutoRetries=0
#最大重试server的个数
ribbon.MaxAutoRetriesNextServer=1
#是否开启任何异常都重试（默认在get请求下会重试，其他情况不会重试，除非设置为true）
ribbon.OkToRetryOnAllOperations=false
#指定重试的http状态码
ribbon.retryableStatusCodes=500,501

Articles connexes : xxx.ribbon.MaxAutoRetries=1

Exemple Java - Tableau vers collection

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!