import org.springframework.retry.RetryListener; //导入依赖的package包/类
/**
 * Utility method for building new {@link ApiCommand}s with most
 * of the boiler plate already setup. This method <em>MAY</em> do
 * command caching, but only if both cacheKey and commandCache
 * are not null.
 * @param uriProvider Provider getting service URIs.
 * @param callback The callback to execute.
 * @param listener Optional spring retry listener to intercept retries.
 * @param cacheKey Optional key to use for the CommandCache.
 * @param commandCache Optional CommandCache to use if desired.
 * @param commandName Name to use for the hystrix command.
 * @return Result of remote method call.
 */
public <T> ApiCommand.Builder<T> restCommand(
      UriProvider<T> uriProvider,
      RemoteServiceCallback<T> callback,
      RetryListener listener,
      Object cacheKey,
      CommandCache<?,?,?> commandCache,
      String commandName
)
{
   if (callback instanceof RestTemplateAware)
   {
      ((RestTemplateAware)callback).setRestTemplate(getRestTemplate(commandName));
   }
   return ApiCommand.<T>builder()
         .withHystrixCommandProperties(getConfiguration().getHystrixCommandProperties(commandName))
         .withHystrixThreadProperties(getConfiguration().getHystrixThreadPoolProperties(commandName))
         .withNumberOfRetries(getConfiguration().getNumRetries(commandName))
         .withUriProvider(uriProvider)
         .withCommandGroup(capitalizeName(getServiceName()) + "." + commandName)
         .withRetryListener(listener)
         .withRemoteServiceCallback(callback)
         .withCommandCache(commandCache, cacheKey);
}
 

import org.springframework.retry.RetryListener; //导入依赖的package包/类
/**
 *
    @throws IOException
 *             if a temporary file cannot be created or if there is a http
 *             protocol error.
 */
@Test
@Ignore
public final void testGetDocumentAnyOtherStatus() throws IOException {
	AttemptCountingRetryListener retryListener = new AttemptCountingRetryListener();
	File tempFile = File.createTempFile("test", "zip");
	tempFile.deleteOnExit();
	getResourceClient.setRetryListeners(new RetryListener[] { retryListener });

	ExitStatus exitStatus = getResourceClient.getResource("http://not.a.domain.invalid/test.zip",
					tempFile.getAbsolutePath(),
					Long.toString(new Date().getTime()));

	assertNotNull("ExitStatus should not be null.", exitStatus);
	assertEquals("ExitStatus should be FAILED.", ExitStatus.FAILED, exitStatus);
	assertEquals("There should be three retry attempts.", 3, retryListener.getErrors());
}
 

import org.springframework.retry.RetryListener; //导入依赖的package包/类
protected RetryOperations createRetryOperations(RetryListener listener, int maxAttempts, List<Class<? extends Throwable>> retryableErrors) {
    Map<Class<? extends Throwable>, Boolean> retryableExceptions = new HashMap<>(retryableErrors.size());
    retryableErrors.forEach(error -> retryableExceptions.put(error, true));
    SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy(maxAttempts, retryableExceptions);
    RetryTemplate retryTemplate = new RetryTemplate();
    retryTemplate.setRetryPolicy(retryPolicy);
    retryTemplate.registerListener(listener);
    return retryTemplate;
}
 

import org.springframework.retry.RetryListener; //导入依赖的package包/类
/**
 * <i>Optional.</i> Adds the given {@link RetryListener} to the Spring
 * retry template. This allows you to intercept failures to do things
 * like custom logging, persistence, etc. By default no listeners are
 * registered. Can be called as many times as needed. The order of
 * execution of listeners is up to Spring.
 * @param listener
 * @return
 */
public Builder<T> withRetryListener(RetryListener listener)
{
   if(listener != null)
   {
      retryTemplate.registerListener(listener);
   }

   return this;
}
 

import org.springframework.retry.RetryListener; //导入依赖的package包/类
private OkHttpRibbonResponse executeWithRetry(OkHttpRibbonRequest request, LoadBalancedRetryPolicy retryPolicy,
											  RetryCallback<OkHttpRibbonResponse, Exception> callback) throws Exception {
	RetryTemplate retryTemplate = new RetryTemplate();
	BackOffPolicy backOffPolicy = loadBalancedBackOffPolicyFactory.createBackOffPolicy(this.getClientName());
	retryTemplate.setBackOffPolicy(backOffPolicy == null ? new NoBackOffPolicy() : backOffPolicy);
	RetryListener[] retryListeners = this.loadBalancedRetryListenerFactory.createRetryListeners(this.getClientName());
	if (retryListeners != null && retryListeners.length != 0) {
		retryTemplate.setListeners(retryListeners);
	}
	boolean retryable = request.getContext() == null ? true :
			BooleanUtils.toBooleanDefaultIfNull(request.getContext().getRetryable(), true);
	retryTemplate.setRetryPolicy(retryPolicy == null || !retryable ? new NeverRetryPolicy()
			: new RetryPolicy(request, retryPolicy, this, this.getClientName()));
	return retryTemplate.execute(callback);
}
 

import org.springframework.retry.RetryListener; //导入依赖的package包/类
private RibbonApacheHttpResponse executeWithRetry(RibbonApacheHttpRequest request, LoadBalancedRetryPolicy retryPolicy, RetryCallback<RibbonApacheHttpResponse, IOException> callback) throws Exception {
	RetryTemplate retryTemplate = new RetryTemplate();
	boolean retryable = request.getContext() == null ? true :
			BooleanUtils.toBooleanDefaultIfNull(request.getContext().getRetryable(), true);
	retryTemplate.setRetryPolicy(retryPolicy == null || !retryable ? new NeverRetryPolicy()
			: new RetryPolicy(request, retryPolicy, this, this.getClientName()));
	BackOffPolicy backOffPolicy = loadBalancedBackOffPolicyFactory.createBackOffPolicy(this.getClientName());
	retryTemplate.setBackOffPolicy(backOffPolicy == null ? new NoBackOffPolicy() : backOffPolicy);
	RetryListener[] retryListeners = this.loadBalancedRetryListenerFactory.createRetryListeners(this.getClientName());
	if (retryListeners != null && retryListeners.length != 0) {
		retryTemplate.setListeners(retryListeners);
	}
	return retryTemplate.execute(callback);
}
 

import org.springframework.retry.RetryListener; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean(name = "charonRetryOperations")
public RetryOperations charonRetryOperations(@Qualifier("charonRetryListener") RetryListener listener) {
    return createRetryOperations(listener, charon.getRetrying().getMaxAttempts(), charon.getRetrying().getRetryOn().getExceptions());
}
 

import org.springframework.retry.RetryListener; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean(name = "charonDefaultRetryOperations")
public RetryOperations charonDefaultRetryOperations(@Qualifier("charonRetryListener") RetryListener listener) {
    return createRetryOperations(listener, 1, emptyList());
}
 

import org.springframework.retry.RetryListener; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean
public RetryListener charonRetryListener() {
    return new LoggingListener(charon);
}
 

import org.springframework.retry.RetryListener; //导入依赖的package包/类
public void setRetryListeners(RetryListener[] retryListeners) {
	this.retryListeners = retryListeners;
}
 

import org.springframework.retry.RetryListener; //导入依赖的package包/类
@Override
public RetryListener[] createRetryListeners(String service) {
    return new RetryListener[0];
}
 

import org.springframework.retry.RetryListener; //导入依赖的package包/类
@Override
public RibbonResponse execute(final RibbonRequest request, IClientConfig configOverride)
		throws IOException {
	final Request.Options options;
	if (configOverride != null) {
		RibbonProperties ribbon = RibbonProperties.from(configOverride);
		options = new Request.Options(
				ribbon.connectTimeout(this.connectTimeout),
				ribbon.readTimeout(this.readTimeout));
	}
	else {
		options = new Request.Options(this.connectTimeout, this.readTimeout);
	}
	final LoadBalancedRetryPolicy retryPolicy = loadBalancedRetryPolicyFactory.create(this.getClientName(), this);
	RetryTemplate retryTemplate = new RetryTemplate();
	BackOffPolicy backOffPolicy = loadBalancedBackOffPolicyFactory.createBackOffPolicy(this.getClientName());
	retryTemplate.setBackOffPolicy(backOffPolicy == null ? new NoBackOffPolicy() : backOffPolicy);
	RetryListener[] retryListeners = this.loadBalancedRetryListenerFactory.createRetryListeners(this.getClientName());
	if (retryListeners != null && retryListeners.length != 0) {
		retryTemplate.setListeners(retryListeners);
	}
	retryTemplate.setRetryPolicy(retryPolicy == null ? new NeverRetryPolicy()
			: new FeignRetryPolicy(request.toHttpRequest(), retryPolicy, this, this.getClientName()));
	return retryTemplate.execute(new RetryCallback<RibbonResponse, IOException>() {
		@Override
		public RibbonResponse doWithRetry(RetryContext retryContext) throws IOException {
			Request feignRequest = null;
			//on retries the policy will choose the server and set it in the context
			//extract the server and update the request being made
			if(retryContext instanceof LoadBalancedRetryContext) {
				ServiceInstance service = ((LoadBalancedRetryContext)retryContext).getServiceInstance();
				if(service != null) {
					feignRequest = ((RibbonRequest)request.replaceUri(reconstructURIWithServer(new Server(service.getHost(), service.getPort()), request.getUri()))).toRequest();
				}
			}
			if(feignRequest == null) {
				feignRequest = request.toRequest();
			}
			Response response = request.client().execute(feignRequest, options);
			if(retryPolicy.retryableStatusCode(response.status())) {
				response.close();
				throw new RetryableStatusCodeException(RetryableFeignLoadBalancer.this.getClientName(), response.status());
			}
			return new RibbonResponse(request.getUri(), response);
		}
	});
}
 

import org.springframework.retry.RetryListener; //导入依赖的package包/类
@Bean
public RetryListener mockRetryListener() {
	return Mockito.mock(RetryListener.class);
}