SpringCloud失败重试源码解析

╰+攻爆jí腚メ 2022-05-19 00:57 401阅读 0赞

基于RestTemplate形式的RPC调用，要实现失败重试，首先需要添加Spring的重试组件：

<dependency>
        <groupId>org.springframework.retry</groupId>
        <artifactId>spring-retry</artifactId>
    </dependency>

在SpringCloud中添加上述依赖，引入重试组件。

当引入了上述组件后，主要是引入 “org.springframework.retry.support.RetryTemplate” 这个类，这样SpringCloud整合Ribbon的配置上就能注入如下的Bean：

@Configuration
    // 指定在负载均衡配置类之前加载，这样就能覆盖使自己定义的 LoadBalancedRetryPolicyFactory  生效
    @AutoConfigureBefore({LoadBalancerAutoConfiguration.class, AsyncLoadBalancerAutoConfiguration.class})
    public class RibbonAutoConfiguration {
    
    	@Bean
    	@ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
    	@ConditionalOnMissingBean
    	public LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory(SpringClientFactory clientFactory) {
    		return new RibbonLoadBalancedRetryPolicyFactory(clientFactory);
    	}
    
    }
    
    // 负载均衡重试策略生成工厂
    public class RibbonLoadBalancedRetryPolicyFactory implements LoadBalancedRetryPolicyFactory {
    
    	private SpringClientFactory clientFactory;
    
    	public RibbonLoadBalancedRetryPolicyFactory(SpringClientFactory clientFactory) {
    		this.clientFactory = clientFactory;
    	}
    
    	@Override
    	public LoadBalancedRetryPolicy create(String serviceId, ServiceInstanceChooser loadBalanceChooser) {
    		RibbonLoadBalancerContext lbContext = this.clientFactory
    				.getLoadBalancerContext(serviceId);
    		// 创建Ribbon的负载均衡重试策略
    		return new RibbonLoadBalancedRetryPolicy(serviceId, lbContext, loadBalanceChooser, clientFactory.getClientConfig(serviceId));
    	}
    }

RibbonAutoConfiguration 定义了一个重试策略生成器，可以使用其生成针对Ribbon的负载均衡重试策略。

SpringCloud的负载均衡组件会对RestTemplate做相应的处理，生成一个 **ClientHttpRequestInterceptor**实现了，注入所有需要负载均衡的RestTemplate的Bean中：

@Configuration
    @ConditionalOnClass(RestTemplate.class)
    public class LoadBalancerAutoConfiguration {
    
    	@LoadBalanced
    	@Autowired(required = false)
    	private List<RestTemplate> restTemplates = Collections.emptyList();
    
    	@Bean
    	// 在所有Singleton Bean 实例化后，客制化RestTemplate。将刚刚定义的负载均衡相关的Interceptor 注入到 每个需要负载均衡的RestTemplate中
    	public SmartInitializingSingleton loadBalancedRestTemplateInitializer(final List<RestTemplateCustomizer> customizers) {
    		return new SmartInitializingSingleton() {
    			@Override
    			public void afterSingletonsInstantiated() {
    				for (RestTemplate restTemplate : LoadBalancerAutoConfiguration.this.restTemplates) {
    					for (RestTemplateCustomizer customizer : customizers) {
    						customizer.customize(restTemplate);
    					}
    				}
    			}
    		};
    	}
    
    	@Configuration
    	@ConditionalOnClass(RetryTemplate.class)
    	public static class RetryAutoConfiguration {
    		......
    		@Bean
    		@ConditionalOnMissingBean
    		// 因为通过Ribbon的配置类定义了一个负载均衡策略生成器，所以这个Bean不会被注册
    		public LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory() {
    			return new LoadBalancedRetryPolicyFactory.NeverRetryFactory();
    		}
    		......
    	}
    
    	@Configuration
    	@ConditionalOnClass(RetryTemplate.class)
    	public static class RetryInterceptorAutoConfiguration {
    		@Bean
    		@ConditionalOnMissingBean
    		// 通过负载均衡相关信息，生成针对RestTemplate的重试拦截器，也就是 ClientHttpRequestInterceptor 的一个实现类
    		public RetryLoadBalancerInterceptor ribbonInterceptor(
    				LoadBalancerClient loadBalancerClient, LoadBalancerRetryProperties properties,
    				LoadBalancedRetryPolicyFactory lbRetryPolicyFactory,
    				LoadBalancerRequestFactory requestFactory,
    				LoadBalancedBackOffPolicyFactory backOffPolicyFactory,
    				LoadBalancedRetryListenerFactory retryListenerFactory) {
    			return new RetryLoadBalancerInterceptor(loadBalancerClient, properties,
    					lbRetryPolicyFactory, requestFactory, backOffPolicyFactory, retryListenerFactory);
    		}
    
    		@Bean
    		@ConditionalOnMissingBean
    		// 定义一个RestTemplate的客制化器，将负载均衡拦截器注入到相应的RestTemplate中
    		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);
    				}
    			};
    		}
    	}
    
    }

经过上述步骤后，负载均衡策略相关的组件就能以 **ClientHttpRequestInterceptor** 的形式注入到RestTemplate中，在执行Http请求的时候起作用。

ClientHttpRequestInterceptor 在 RestTemplate中以类似FilterChain的形式其作用，下面我们就看看 **RetryLoadBalancerInterceptor** 的作用代码：

public class RetryLoadBalancerInterceptor implements ClientHttpRequestInterceptor {
    
    	private LoadBalancedRetryPolicyFactory lbRetryPolicyFactory;
    	private RetryTemplate retryTemplate;
    	private LoadBalancerClient loadBalancer;
    	private LoadBalancerRetryProperties lbProperties;
    	private LoadBalancerRequestFactory requestFactory;
    	private LoadBalancedBackOffPolicyFactory backOffPolicyFactory;
    	private LoadBalancedRetryListenerFactory retryListenerFactory;
    	......
    	
    	@Override
    	public ClientHttpResponse intercept(final HttpRequest request, final byte[] body,
    										final ClientHttpRequestExecution execution) throws IOException {
    		final URI originalUri = request.getURI();
    		final String serviceName = originalUri.getHost();
    		Assert.state(serviceName != null, "Request URI does not contain a valid hostname: " + originalUri);
    		// 通过负载均衡重试策略工厂生成重试策略实例，也就是Ribbon里定义的 RibbonLoadBalancedRetryPolicy对象
    		final LoadBalancedRetryPolicy retryPolicy = lbRetryPolicyFactory.create(serviceName,loadBalancer);
    		// 重试模板，默认情况下每次执行都实例化一个
    		RetryTemplate template = this.retryTemplate == null ? new RetryTemplate() : this.retryTemplate;
    		// 补偿策略，默认不补偿
    		BackOffPolicy backOffPolicy = backOffPolicyFactory.createBackOffPolicy(serviceName);
    		template.setBackOffPolicy(backOffPolicy == null ? new NoBackOffPolicy() : backOffPolicy);
    		// 设置当重试流程结束时，最终未成功，则抛出最后的异常
    		template.setThrowLastExceptionOnExhausted(true);
    		// 生成重试监听器，可监听重试的流程，比如开启，关闭，失败；默认无，可自定义
    		RetryListener[] retryListeners = this.retryListenerFactory.createRetryListeners(serviceName);
            if (retryListeners != null && retryListeners.length != 0) {
                template.setListeners(retryListeners);
            }
            // 设置重试策略，将 Ribbon的负载均衡策略，当前请求，负载均衡器 和 服务名称 封装进 一个 InterceptorRetryPolicy
            // 目的是将SpringCloud的重试机制适配为Spring的重试机制，将RestTemplate的重试逻辑转发给Ribbon的重试策略
    		template.setRetryPolicy(!lbProperties.isEnabled() || retryPolicy == null ? 
    				new NeverRetryPolicy(): new InterceptorRetryPolicy(request, retryPolicy, loadBalancer, serviceName));
    				
    		// RetryTemplate会根据RetryPolicy，在满足条件下不断执行RetryCallback#doWithRetry(context) 方法
    		return template.execute(
    				new RetryCallback<ClientHttpResponse, IOException>() {
    					@Override 
    					// 在可重试的机制下执行操作，也就是执行Http请求
    					public ClientHttpResponse doWithRetry(RetryContext context)throws IOException {
    						ServiceInstance serviceInstance = null;
    						if (context instanceof LoadBalancedRetryContext) {
    							LoadBalancedRetryContext lbContext = (LoadBalancedRetryContext) context;
    							serviceInstance = lbContext.getServiceInstance();
    						}
    						// 在第一次执行时，未指定调用的服务，需要通过负载均衡器选择一个；之后就都能从LoadBalancedRetryContext 里获取
    						if (serviceInstance == null) {
    							serviceInstance = loadBalancer.choose(serviceName);
    						}
    						ClientHttpResponse response = RetryLoadBalancerInterceptor.this.loadBalancer.execute(
    								serviceName, serviceInstance,requestFactory.createRequest(request, body, execution));
    						int statusCode = response.getRawStatusCode();
    						if (retryPolicy != null && retryPolicy.retryableStatusCode(statusCode)) {
    							byte[] body = StreamUtils.copyToByteArray(response.getBody());
    							response.close();
    							throw new ClientHttpResponseStatusCodeException(serviceName, response, body);
    						}
    						return response;
    					}
    				}, 
    				new RibbonRecoveryCallback<ClientHttpResponse, ClientHttpResponse>() {
    					@Override
    					protected ClientHttpResponse createResponse(ClientHttpResponse response, URI uri) {
    						return response;
    					}
    				}
    		);
    	}
    
    }

将SpringCloud的重试策略，请求信息，服务名称，负载均衡器封装成一个Spring的 RetryPolicy，注入RetryTemplate中。RetryTemplate根据RetryPolicy的重试逻辑来决定对RetryCallback\#doWithRetry(context)的重试策略。

下面看RetryTemplate执行可重试请求：

public class RetryTemplate implements RetryOperations {
    
    	private volatile RetryPolicy retryPolicy;
    	
    	public final <T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback,
    			RecoveryCallback<T> recoveryCallback) throws E {
    		return doExecute(retryCallback, recoveryCallback, null);
    	}
    	
    	// 重试模板执行重试方法
    	protected <T, E extends Throwable> T doExecute(RetryCallback<T, E> retryCallback,
    			RecoveryCallback<T> recoveryCallback, RetryState state)
    			throws E, ExhaustedRetryException {
    		......
    		/*
    		 * We allow the whole loop to be skipped if the policy or context already
    		 * forbid the first try. This is used in the case of external retry to allow a
    		 * recovery in handleRetryExhausted without the callback processing (which
    		 * would throw an exception).
    		 */
    		while (canRetry(retryPolicy, context) && !context.isExhaustedOnly()) {
    			try {
    				if (this.logger.isDebugEnabled()) {
    					this.logger.debug("Retry: count=" + context.getRetryCount());
    				}
    				// Reset the last exception, so if we are successful
    				// the close interceptors will not think we failed...
    				lastException = null;
    				// 执行Http请求，当执行失败时，肯定会抛出异常，捕获异常
    				return retryCallback.doWithRetry(context);
    			}
    			catch (Throwable e) {
    				lastException = e;
    				try {
    					// 捕获异常，注册此异常信息
    					registerThrowable(retryPolicy, state, context, e);
    				}
    				catch (Exception ex) {
    					throw new TerminatedRetryException("Could not register throwable",
    							ex);
    				}
    				finally {
    					doOnErrorInterceptors(retryCallback, context, e);
    				}
    				......
    			}
    		}
    		......
    	}
    	
    	// 由SpringCloud的重试策略来决定是否再继续
    	protected boolean canRetry(RetryPolicy retryPolicy, RetryContext context) {
    		return retryPolicy.canRetry(context);
    	}
    	
    	// 注册异常信息
    	protected void registerThrowable(RetryPolicy retryPolicy, RetryState state,
    			RetryContext context, Throwable e) {
    		retryPolicy.registerThrowable(context, e);
    		registerContext(context, state);
    	}
    	
    }

每次尝试失败，抛出异常，捕获异常，注册（处理）异常信息，然后继续循环。肯定是**在注册异常信息方法里对是否继续重试的条件做了更新**，这样下次循环时才能根据最新的重试环境做是否继续的判断。

我们先看执行失败时的异常处理：

public class InterceptorRetryPolicy implements RetryPolicy {
    	private LoadBalancedRetryPolicy policy;
    	......
    	@Override
        public void registerThrowable(RetryContext context, Throwable throwable) {
            LoadBalancedRetryContext lbContext = (LoadBalancedRetryContext) context;
            //this is important as it registers the last exception in the context and also increases the retry count
            lbContext.registerThrowable(throwable);
            //let the policy know about the exception as well
            policy.registerThrowable(lbContext, throwable);
        }
    }
    
    public class RetryContextSupport extends AttributeAccessorSupport implements RetryContext {
    	// 记录最后一个异常，当最终失败时抛出此异常；同时记录重试次数，方便日志打印
    	public void registerThrowable(Throwable throwable) {
    		this.lastException = throwable;
    		if (throwable != null)
    			count++;
    	}
    }
    
    public class RibbonLoadBalancedRetryPolicy implements LoadBalancedRetryPolicy {
    
    	private int sameServerCount = 0;
    	private int nextServerCount = 0;
    	private String serviceId;
    
    	@Override
    	public void registerThrowable(LoadBalancedRetryContext context, Throwable throwable) {
    		//if this is a circuit tripping exception then notify the load balancer
    		// 如果此异常是一个回环断路异常，比如SocketException，那么需要通知下负载均衡器，尽量降低选择到此Server的几率。因为此路不通
    		if (lbContext.getRetryHandler().isCircuitTrippingException(throwable)) {
    			updateServerInstanceStats(context);
    		}
    		
    		//Check if we need to ask the load balancer for a new server.
    		//Do this before we increment the counters because the first call to this method
    		//is not a retry it is just an initial failure.
    		// 如果不能对同一个Server再重试了，但是能够尝试NextServer,那么通过负载均衡重新选择一个Server，设置到Context中
    		if(!canRetrySameServer(context)  && canRetryNextServer(context)) {
    			context.setServiceInstance(loadBalanceChooser.choose(serviceId));
    		}
    		//This method is called regardless of whether we are retrying or making the first request.
    		//Since we do not count the initial request in the retry count we don't reset the counter
    		//until we actually equal the same server count limit.  This will allow us to make the initial
    		//request plus the right number of retries.
    		// 更新对当前Server的重试次数，和总的尝试过的Server的数量
    		if(sameServerCount >= lbContext.getRetryHandler().getMaxRetriesOnSameServer() && canRetry(context)) {
    			//reset same server since we are moving to a new server
    			sameServerCount = 0;
    			nextServerCount++;
    			if(!canRetryNextServer(context)) {
    				context.setExhaustedOnly();
    			}
    		} else {
    			sameServerCount++;
    		}
    	}
    	
    }

在 RibbonLoadBalancedRetryPolicy 对失败的异常处理过程中，有一步对异常是否是回环断路异常的判断，我们先看看这个逻辑：

public class DefaultLoadBalancerRetryHandler implements RetryHandler {
    
    	private List<Class<? extends Throwable>> circuitRelated = 
                Lists.<Class<? extends Throwable>>newArrayList(SocketException.class, SocketTimeoutException.class);
    
    	/**
         * @return true if {@link SocketException} or {@link SocketTimeoutException} is a cause in the Throwable.
         */
        @Override
        // 判断异常是否是会触发回路断开的异常
        public boolean isCircuitTrippingException(Throwable e) {
            return Utils.isPresentAsCause(e, getCircuitRelatedExceptions());        
        }
    
    	protected List<Class<? extends Throwable>>  getCircuitRelatedExceptions() {
            return circuitRelated;
        }
    
    }
    
    public class Utils {
        public static boolean isPresentAsCause(Throwable throwableToSearchIn,
                Collection<Class<? extends Throwable>> throwableToSearchFor) {
            int infiniteLoopPreventionCounter = 10;
            while (throwableToSearchIn != null && infiniteLoopPreventionCounter > 0) {
                infiniteLoopPreventionCounter--;
                for (Class<? extends Throwable> c: throwableToSearchFor) {
                    if (c.isAssignableFrom(throwableToSearchIn.getClass())) {
                        return true;
                    }
                }
                throwableToSearchIn = throwableToSearchIn.getCause();
            }
            return false;
        }
    }

先判断当前失败的异常是否是断路异常，也就是判断此异常是否是SocketException 和 SocketTimeoutException的子类 ：

![这里写图片描述][70]

SocketException 的子类有上述这些，SocketTimeoutException 没有子类，也就是如果抛出的是上述异常，那么就触发了回路断开机制。**也就是说是连接Server失败而导致的异常，可能当前Server不可用，那么就需要对此Server做一些状态更新，尽量让下次负载均衡时不要选择到此Server，保证服务的可用性。**

如果是，那么需要更新Server实例的状态：

public class RibbonLoadBalancedRetryPolicy implements LoadBalancedRetryPolicy {
    
    	private void updateServerInstanceStats(LoadBalancedRetryContext context) {
    		ServiceInstance serviceInstance = context.getServiceInstance();
    		if (serviceInstance instanceof RibbonServer) {
    			Server lbServer = ((RibbonServer)serviceInstance).getServer();
    			ServerStats serverStats = lbContext.getServerStats(lbServer);
    			// 更新服务状态里的持续性的连接失败次数
    			serverStats.incrementSuccessiveConnectionFailureCount();
    			// 更新总的失败次数
    			serverStats.addToFailureCount();    				
    			LOGGER.debug(lbServer.getHostPort() + " RetryCount: " + context.getRetryCount() 
    				+ " Successive Failures: " + serverStats.getSuccessiveConnectionFailureCount() 
    				+ " CircuitBreakerTripped:" + serverStats.isCircuitBreakerTripped());
    		}
    	}
    
    }
    
    // Eureka的Server状态类
    public class ServerStats {
    
    	private final DynamicIntProperty connectionFailureThreshold;      // 连接失败阈值，默认 3
        private final DynamicIntProperty circuitTrippedTimeoutFactor;     // 触发回环断路超时因子， 默认 10
        private final DynamicIntProperty maxCircuitTrippedTimeout;        // 最大回环断路时间， 默认 30S
    
    	public ServerStats() {
            connectionFailureThreshold = DynamicPropertyFactory.getInstance().getIntProperty(
                    "niws.loadbalancer.default.connectionFailureCountThreshold", 3);        
            circuitTrippedTimeoutFactor = DynamicPropertyFactory.getInstance().getIntProperty(
                    "niws.loadbalancer.default.circuitTripTimeoutFactorSeconds", 10);
            maxCircuitTrippedTimeout = DynamicPropertyFactory.getInstance().getIntProperty(
                    "niws.loadbalancer.default.circuitTripMaxTimeoutSeconds", 30);
        }
    
    	// 更新持续性的连接失败次数
    	public void incrementSuccessiveConnectionFailureCount() {
            lastConnectionFailedTimestamp = System.currentTimeMillis();
            successiveConnectionFailureCount.incrementAndGet();
            // 更新总的被禁止的时间
            totalCircuitBreakerBlackOutPeriod.addAndGet(getCircuitBreakerBlackoutPeriod());
        }
    
    	private long getCircuitBreakerBlackoutPeriod() {
    		// 持续性的连接失败次数
            int failureCount = successiveConnectionFailureCount.get();
            // 连接失败阈值
            int threshold = connectionFailureThreshold.get();
            if (failureCount < threshold) {
                return 0;
            }
            // 计算连接失败次数和阈值的差值，差值不能超过16
            int diff = (failureCount - threshold) > 16 ? 16 : (failureCount - threshold);
            // 关闭时间，失败次数差值 * 2 * 触发回环断路超时因子(10); 也就是这个Server被ban(禁止)的时间
            int blackOutSeconds = (1 << diff) * circuitTrippedTimeoutFactor.get();
            // 禁止时间不能超过30S
            if (blackOutSeconds > maxCircuitTrippedTimeout.get()) {
                blackOutSeconds = maxCircuitTrippedTimeout.get();
            }
            return blackOutSeconds * 1000L;
        }
    	
    	// 验证当前Server是否被禁止
    	public boolean isCircuitBreakerTripped(long currentTime) {
            long circuitBreakerTimeout = getCircuitBreakerTimeout();
            if (circuitBreakerTimeout <= 0) {
                return false;
            }
            // 当前时间是否已经超过了禁止的截止时间
            return circuitBreakerTimeout > currentTime;
        }
    
        // 获取当前Server被禁止的截止时间
        private long getCircuitBreakerTimeout() {
            long blackOutPeriod = getCircuitBreakerBlackoutPeriod();
            if (blackOutPeriod <= 0) {
                return 0;
            }
            return lastConnectionFailedTimestamp + blackOutPeriod;
        }
    
    }

**重试异常的处理关联到Ribbon对Server的负载均衡策略，对于持续连接失败超过3次时，将当前Server禁闭一段时间，在下次负载均衡时忽略选择此Server；禁闭时间结束后，执行请求成功才会清空累积的持续失败次数；若一直未成功，那么每失败一次就会被关禁闭一段时间**

**Ribbon的默认负载均衡策略是一个Composite类型的，优先选择那些同一个Zone且是可用的Server，可用就是指Server未被关禁闭。**

在对抛出的异常做处理后，接下来就需要判断是否可继续重试，是重试当前Server还是重试下一个Server：

public class RibbonLoadBalancedRetryPolicy implements LoadBalancedRetryPolicy {
    
    	public void registerThrowable(LoadBalancedRetryContext context, Throwable throwable) {
    		......
    		//Check if we need to ask the load balancer for a new server.
    		//Do this before we increment the counters because the first call to this method
    		//is not a retry it is just an initial failure.
    		// 如果不能能重试当前Server，但能重试另一个Server，那么需要通过负载均衡器重新选择一个Server。不保证选择的肯定是另一个，可能还是当前
    		if(!canRetrySameServer(context)  && canRetryNextServer(context)) {
    			context.setServiceInstance(loadBalanceChooser.choose(serviceId));
    		}
    		......
    	}
    
    	// 是否能重试当前Server
    	public boolean canRetrySameServer(LoadBalancedRetryContext context) {
    		return sameServerCount < lbContext.getRetryHandler().getMaxRetriesOnSameServer() && canRetry(context);
    	}
    
    	// 是否能重试下一个Server
    	public boolean canRetryNextServer(LoadBalancedRetryContext context) {
    		//this will be called after a failure occurs and we increment the counter
    		//so we check that the count is less than or equals to too make sure
    		//we try the next server the right number of times
    		return nextServerCount <= lbContext.getRetryHandler().getMaxRetriesOnNextServer() && canRetry(context);
    	}
    
    	public boolean canRetry(LoadBalancedRetryContext context) {
    		HttpMethod method = context.getRequest().getMethod();
    		return HttpMethod.GET == method || lbContext.isOkToRetryOnAllOperations();
    	}
    
    }

上述判断是否能重试基本都依据 LoadBalancedRetryContext 里的数据，我们看看 LoadBalancedRetryContext 内 这几个关键参数的值怎么来：

public class LoadBalancerContext implements IClientConfigAware {
    	// 最多可重试几个Server
    	protected int maxAutoRetriesNextServer = DefaultClientConfigImpl.DEFAULT_MAX_AUTO_RETRIES_NEXT_SERVER;
    	// 每个Server的最大重试次数
        protected int maxAutoRetries = DefaultClientConfigImpl.DEFAULT_MAX_AUTO_RETRIES;
        protected RetryHandler defaultRetryHandler = new DefaultLoadBalancerRetryHandler();
    
    	/**
         * Set necessary parameters from client configuration and register with Servo monitors.
         */
        @Override
        public void initWithNiwsConfig(IClientConfig clientConfig) {
            ......
            maxAutoRetries = clientConfig.getPropertyAsInteger(CommonClientConfigKey.MaxAutoRetries, DefaultClientConfigImpl.DEFAULT_MAX_AUTO_RETRIES);
            maxAutoRetriesNextServer = clientConfig.getPropertyAsInteger(CommonClientConfigKey.MaxAutoRetriesNextServer,maxAutoRetriesNextServer);
            okToRetryOnAllOperations = clientConfig.getPropertyAsBoolean(CommonClientConfigKey.OkToRetryOnAllOperations, okToRetryOnAllOperations);
            defaultRetryHandler = new DefaultLoadBalancerRetryHandler(clientConfig);
            ......
        }
    
    }
    
    public class DefaultLoadBalancerRetryHandler implements RetryHandler {
    	......
    	public DefaultLoadBalancerRetryHandler(IClientConfig clientConfig) {
            this.retrySameServer = clientConfig.get(CommonClientConfigKey.MaxAutoRetries, DefaultClientConfigImpl.DEFAULT_MAX_AUTO_RETRIES);
            this.retryNextServer = clientConfig.get(CommonClientConfigKey.MaxAutoRetriesNextServer, DefaultClientConfigImpl.DEFAULT_MAX_AUTO_RETRIES_NEXT_SERVER);
            this.retryEnabled = clientConfig.get(CommonClientConfigKey.OkToRetryOnAllOperations, false);
        }
    
    	@Override
        public int getMaxRetriesOnSameServer() {
            return retrySameServer;
        }
    
        @Override
        public int getMaxRetriesOnNextServer() {
            return retryNextServer;
        }
    
    }

从上述代码上看到，这几个重试参数都是来自于**IClientConfig** ，这个类是Ribbon的负载均衡配置接口，他提供了很多负载均衡和失败重试以及Server连接的参数配置，默认实现是 **DefaultClientConfigImpl**，我们看看SpringCloud对 DefaultClientConfigImpl 的定义 ：

@Configuration
    public class RibbonClientConfiguration {
    
    	@Value("${ribbon.client.name}")
    	private String name = "client";  // 实际注入 'ribbon'
    
    	@Bean
    	@ConditionalOnMissingBean
    	public IClientConfig ribbonClientConfig() {
    		DefaultClientConfigImpl config = new DefaultClientConfigImpl();
    		// 从环境变量加载 ribbon 的负载均衡配置
    		config.loadProperties(this.name);
    		config.set(CommonClientConfigKey.ConnectTimeout, DEFAULT_CONNECT_TIMEOUT);
    		config.set(CommonClientConfigKey.ReadTimeout, DEFAULT_READ_TIMEOUT);
    		return config;
    	}
    
    }

SpringCloud在加载时实例化一个DefaultClientConfigImpl 作为Ribbon的负载均衡配置Bean，同时加载环境里所有**以 “ribbon” 开头的，结尾为 CommonClientConfigKey 里常量字符串**的变量信息：

public class DefaultClientConfigImpl implements IClientConfig {
    
    	public static final int DEFAULT_MAX_AUTO_RETRIES = 0;
        public static final int DEFAULT_BACKOFF_INTERVAL = 0;
    
    	/**
         * Load properties for a given client. It first loads the default values for all properties,
         * and any properties already defined with Archaius ConfigurationManager.
         */
        @Override
    	public void loadProperties(String restClientName){
            enableDynamicProperties = true;
            setClientName(restClientName);
            loadDefaultValues();
            ......
        }
    
    	public void loadDefaultValues() {
            ......
            // 加载单个Server最大重试次数，环境变量的key为：ribbon.MaxAutoRetries
            putDefaultIntegerProperty(CommonClientConfigKey.MaxAutoRetries, getDefaultMaxAutoRetries());
            // 加载最多可重试的Server个数, 环境变量的key为：ribbon.MaxAutoRetriesNextServer
            putDefaultIntegerProperty(CommonClientConfigKey.MaxAutoRetriesNextServer, getDefaultMaxAutoRetriesNextServer());
            // 加载是否对所有请求类型都重试， 环境变量的key为：ribbon.OkToRetryOnAllOperations
            putDefaultBooleanProperty(CommonClientConfigKey.OkToRetryOnAllOperations, getDefaultOkToRetryOnAllOperations());
            ......
        }
    
    }

这些数据都有默认值，若未在配置文件中定义，则一律使用默认形式。比如单个Server重试次数默认为0；重试Server个数默认为0。

DefaultClientConfigImpl 里可配置的参数有很多，每个参数都有其各自的含义，感兴趣的可自行查看，这里就不再继续说明。

以上就是基于RestTemplate的失败重试机制的源码解析，基于Ribbon的原生的失败重试机制也类似。Ribbon框架也有集成HttpClient的组件，所以可以不走Spring的RestTemplate，参数的配置形式和RestTemplate一样，也是环境变量里配置 DefaultClientConfigImpl 的那些参数，其代码的逻辑大部分在 ： **AbstractLoadBalancerAwareClient\#executeWithLoadBalancer（…）**，感兴趣的可以自行查看，这里就不再复述了。

总结：

1.  **失败重试伴随着异常的处理，Ribbon对Socket相关异常做相应的断路处理，连续3次失败会禁闭对应Server一段时间，尽量下次重试时不选择到此Server，以保证服务的高可用性**
2.  **失败重试包含对单个Server的多次重试以及可重试多个Server**

[70]: /images/20220519/92c1ffddc08c4a5bbf6715a7cc1b1bbb.png