import org.springframework.retry.backoff.ExponentialBackOffPolicy; //导入依赖的package包/类
/**
 * Returns a retry template that always retries.  Starts with a second interval between retries and doubles that interval up
 * to a minute for each retry.
 *
 * @return A retry template.
 */
protected RetryTemplate retryTemplate() {
	RetryTemplate retry = new RetryTemplate();

	Map<Class<? extends Throwable>, Boolean> stopExceptions =
			Collections.singletonMap(InterruptedException.class, Boolean.FALSE);
	SimpleRetryPolicy retryPolicy =
			new SimpleRetryPolicy(Integer.MAX_VALUE, stopExceptions, true, true);

	retry.setRetryPolicy(retryPolicy);

	ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
	backOffPolicy.setInitialInterval(1000);
	backOffPolicy.setMultiplier(2.0);
	backOffPolicy.setMaxInterval(60000);
	retry.setBackOffPolicy(backOffPolicy);

	return retry;
}
 

import org.springframework.retry.backoff.ExponentialBackOffPolicy; //导入依赖的package包/类
@Bean
public RetryTemplate arkClientRetryTemplate() {
    RetryTemplate retryTemplate = new RetryTemplate();

    Map<Class<? extends Throwable>, Boolean> includeExceptions = new HashMap<>();
    includeExceptions.put(RuntimeException.class, true);

    ExponentialBackOffPolicy exponentialBackOffPolicy = new ExponentialBackOffPolicy();
    exponentialBackOffPolicy.setInitialInterval(10);
    exponentialBackOffPolicy.setMultiplier(2.0);
    retryTemplate.setBackOffPolicy(exponentialBackOffPolicy);

    SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy(10, includeExceptions);
    retryPolicy.setMaxAttempts(10);
    retryTemplate.setRetryPolicy(retryPolicy);

    return retryTemplate;
}
 

import org.springframework.retry.backoff.ExponentialBackOffPolicy; //导入依赖的package包/类
@Bean
public RetryTemplate arkClientRetryTemplate() {
    RetryTemplate retryTemplate = new RetryTemplate();

    Map<Class<? extends Throwable>, Boolean> includeExceptions = new HashMap<>();
    includeExceptions.put(RuntimeException.class, true);

    ExponentialBackOffPolicy exponentialBackOffPolicy = new ExponentialBackOffPolicy();
    exponentialBackOffPolicy.setInitialInterval(100);
    exponentialBackOffPolicy.setMultiplier(2.0);
    retryTemplate.setBackOffPolicy(exponentialBackOffPolicy);

    SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy(5, includeExceptions);
    retryPolicy.setMaxAttempts(5);
    retryTemplate.setRetryPolicy(retryPolicy);

    return retryTemplate;
}
 

import org.springframework.retry.backoff.ExponentialBackOffPolicy; //导入依赖的package包/类
@Bean
@Qualifier("tempo")
public RetryOperations tempoApiRetryPolicy() {
    final RetryPolicy retryPolicy = createRetryPolicy();

    final ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
    backOffPolicy.setInitialInterval(2000);
    backOffPolicy.setMultiplier(3);

    final RetryTemplate retryTemplate = new RetryTemplate();
    retryTemplate.setRetryPolicy(retryPolicy);
    retryTemplate.setBackOffPolicy(backOffPolicy);
    retryTemplate.setThrowLastExceptionOnExhausted(true);

    return retryTemplate;
}
 

import org.springframework.retry.backoff.ExponentialBackOffPolicy; //导入依赖的package包/类
@Override
public void afterPropertiesSet() throws Exception {
	if (this.metadataRetryOperations == null) {
		RetryTemplate retryTemplate = new RetryTemplate();

		SimpleRetryPolicy simpleRetryPolicy = new SimpleRetryPolicy();
		simpleRetryPolicy.setMaxAttempts(10);
		retryTemplate.setRetryPolicy(simpleRetryPolicy);

		ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
		backOffPolicy.setInitialInterval(100);
		backOffPolicy.setMultiplier(2);
		backOffPolicy.setMaxInterval(1000);
		retryTemplate.setBackOffPolicy(backOffPolicy);
		this.metadataRetryOperations = retryTemplate;
	}
}
 

import org.springframework.retry.backoff.ExponentialBackOffPolicy; //导入依赖的package包/类
/**
 * Ensures external dependencies are available before starting to read messages from the queue
 * @return true if startup successful, false if not
 */
public boolean isResourcesReady() {
    boolean isStartupOk = false;

    ExponentialBackOffPolicy exponentialBackOffPolicy = getExponentialBackOffPolicy();
    SimpleRetryPolicy retryPolicy = getSimpleRetryPolicy();

    RetryTemplate retryTemplate = new RetryTemplate();
    retryTemplate.setRetryPolicy(retryPolicy);
    retryTemplate.setBackOffPolicy(exponentialBackOffPolicy);
    retryTemplate.setThrowLastExceptionOnExhausted(true);

    logger.info("Waiting for Author ELB to be in healthy state");
    
    try {
        isStartupOk = retryTemplate.execute(c -> {
            boolean result = aemInstanceHelperService.isAuthorElbHealthy();
            if(!result) //Needs to be healthy
                throw new Exception("Author ELB does not appear to be in a healthy state");
            return result;
        });
    } catch (Exception e) {
        logger.error("Failed to receive healthy state from Author ELB", e);
    }
    
    return isStartupOk;
}
 

import org.springframework.retry.backoff.ExponentialBackOffPolicy; //导入依赖的package包/类
private ExponentialBackOffPolicy getExponentialBackOffPolicy() {
    ExponentialBackOffPolicy exponentialBackOffPolicy = new ExponentialBackOffPolicy();
    exponentialBackOffPolicy.setInitialInterval(waitForAuthorBackOffPeriod);
    exponentialBackOffPolicy.setMaxInterval(waitForAuthorMaxBackOffPeriod);
    exponentialBackOffPolicy.setMultiplier(waitForAuthorBackOffPeriodMultiplier);
    return exponentialBackOffPolicy;
}
 

import org.springframework.retry.backoff.ExponentialBackOffPolicy; //导入依赖的package包/类
@Bean
protected RetryTemplate getRetryTemplate(@Value("${controller.retryCount:3}") int retryCount, @Value("${controller.intial_delay:1000}") int initialDelay, @Value("${controller.maxInterval:10000}") int maxInterval) {
    RetryTemplate retryTemplate = new RetryTemplate();
    retryTemplate.setRetryPolicy(new SimpleRetryPolicy(retryCount, Collections.singletonMap(RestClientException.class, true)));
    ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
    backOffPolicy.setInitialInterval(initialDelay);
    backOffPolicy.setMaxInterval(maxInterval);
    retryTemplate.setBackOffPolicy(backOffPolicy);
    retryTemplate.setThrowLastExceptionOnExhausted(true);


    retryTemplate.registerListener(new DefaultListenerSupport());

    return retryTemplate;
}
 

import org.springframework.retry.backoff.ExponentialBackOffPolicy; //导入依赖的package包/类
@Bean
@ConditionalOnSingleCandidate(ConnectionFactory.class)
@ConditionalOnMissingBean(RabbitTemplate.class)
public RabbitTemplate rabbitTemplate() {
    RabbitTemplate template = new RabbitTemplate(connectionFactory);
    RetryTemplate retryTemplate = new RetryTemplate();
    ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
    backOffPolicy.setInitialInterval(500);
    backOffPolicy.setMultiplier(10.0);
    backOffPolicy.setMaxInterval(10000);
    retryTemplate.setBackOffPolicy(backOffPolicy);
    template.setRetryTemplate(retryTemplate);
    template.setMessageConverter(messageConverter);
    return template;
}
 

import org.springframework.retry.backoff.ExponentialBackOffPolicy; //导入依赖的package包/类
private RetryTemplate createRetryTemplate(RabbitProperties.Retry properties) {
	RetryTemplate template = new RetryTemplate();
	SimpleRetryPolicy policy = new SimpleRetryPolicy();
	policy.setMaxAttempts(properties.getMaxAttempts());
	template.setRetryPolicy(policy);
	ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
	backOffPolicy.setInitialInterval(properties.getInitialInterval());
	backOffPolicy.setMultiplier(properties.getMultiplier());
	backOffPolicy.setMaxInterval(properties.getMaxInterval());
	template.setBackOffPolicy(backOffPolicy);
	return template;
}
 

import org.springframework.retry.backoff.ExponentialBackOffPolicy; //导入依赖的package包/类
@Override
public void onMessage(Message message) {
    Event event = eventService.findOne((String) message.getMessageProperties().getHeaders().get("id"));
    if (event != null) {
        EventLog eventLog = null;
        if (event.isValid()) {
            eventLog = new EventLog(subscriptionId, event.getId(), EventStatus.PENDING,
                                    LocalDateTime.now(ZoneId.of("UTC")));
        } else {
            eventLog = new EventLog(subscriptionId, event.getId(), EventStatus.INVALID,
                                    LocalDateTime.now(ZoneId.of("UTC")));
        }
        eventLogRepository.save(eventLog);

        if (event.isValid()) {
            Subscription subscription = subscriptionRepository.findOne(subscriptionId);
            if (subscription != null) {
                ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
                backOffPolicy.setInitialInterval(subscription.getInitialInterval());
                backOffPolicy.setMaxInterval(subscription.getMaximunInterval());
                backOffPolicy.setMultiplier(subscription.getMultiplier());
                template.setBackOffPolicy(backOffPolicy);
                template.execute(context->{
                    Link payload = new Link("", "");
                    ResponseEntity response = restTemplate
                        .postForEntity(subscription.getCallbackUrl(), payload, String.class);
                    EventLog requestLog = new EventLog(subscriptionId, event.getId(), EventStatus.ACKNOWLEDGED,
                                                       LocalDateTime.now(ZoneId.of("UTC")));
                    eventLogRepository.save(requestLog);
                    return response;
                });
            }
        }
    }
}
 

import org.springframework.retry.backoff.ExponentialBackOffPolicy; //导入依赖的package包/类
@Bean
AmqpTemplate amqpTemplate() {
    ExponentialBackOffPolicy policy = new ExponentialBackOffPolicy();
    policy.setInitialInterval(500);
    policy.setMaxInterval(10000);
    policy.setMultiplier(10);

    RetryTemplate retryTemplate = new RetryTemplate();
    retryTemplate.setBackOffPolicy(policy);

    RabbitTemplate template = new RabbitTemplate(getAmqpConnectionFactory());
    template.setRetryTemplate(retryTemplate);

    return template;
}
 

import org.springframework.retry.backoff.ExponentialBackOffPolicy; //导入依赖的package包/类
@Bean
public RetryOperations retryOperations() {
	RetryTemplate retryTemplate = new RetryTemplate();
	retryTemplate.setRetryPolicy(new SimpleRetryPolicy(3, Collections.<Class<? extends Throwable>, Boolean>singletonMap(RedisConnectionFailureException.class, true)));
	ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
	backOffPolicy.setInitialInterval(1000L);
	backOffPolicy.setMaxInterval(1000L);
	backOffPolicy.setMultiplier(2);
	retryTemplate.setBackOffPolicy(backOffPolicy);
	return retryTemplate;
}
 

import org.springframework.retry.backoff.ExponentialBackOffPolicy; //导入依赖的package包/类
@Bean
public RetryOperations retryOperations() {
	RetryTemplate retryTemplate = new RetryTemplate();
	retryTemplate.setRetryPolicy(new SimpleRetryPolicy(3,
			Collections.<Class<? extends Throwable>, Boolean>singletonMap(RedisConnectionFailureException.class, true)));
	ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
	backOffPolicy.setInitialInterval(1000L);
	backOffPolicy.setMaxInterval(1000L);
	backOffPolicy.setMultiplier(2);
	retryTemplate.setBackOffPolicy(backOffPolicy);
	return retryTemplate;
}
 

import org.springframework.retry.backoff.ExponentialBackOffPolicy; //导入依赖的package包/类
/**
 * Internal API to configure RestTemplate
 *
 * @param apiKey - API key to configure authorization header
 */
private void configureRestTemplate(String apiKey) {
    ClientHttpRequestFactory requestFactory = HTTPConfig.createRequestFactory(apiKey);
    restTemplate = new RestTemplate(requestFactory);
    retryTemplate = new RetryTemplate();
    retryTemplate.setBackOffPolicy(new ExponentialBackOffPolicy());
}
 

import org.springframework.retry.backoff.ExponentialBackOffPolicy; //导入依赖的package包/类
/**
 * Create and configure a retry template.
 *
 * @param properties The properties.
 * @return The retry template
 */
public RetryTemplate buildRetryTemplate(ConsumerProperties properties) {
	RetryTemplate template = new RetryTemplate();
	SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy();
	retryPolicy.setMaxAttempts(properties.getMaxAttempts());
	ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
	backOffPolicy.setInitialInterval(properties.getBackOffInitialInterval());
	backOffPolicy.setMultiplier(properties.getBackOffMultiplier());
	backOffPolicy.setMaxInterval(properties.getBackOffMaxInterval());
	template.setRetryPolicy(retryPolicy);
	template.setBackOffPolicy(backOffPolicy);
	return template;
}
 

import org.springframework.retry.backoff.ExponentialBackOffPolicy; //导入依赖的package包/类
@Bean
RabbitTemplate rabbitTemplate(org.springframework.amqp.rabbit.connection.ConnectionFactory  cf,
                              ObjectMapper mapper) {
    RabbitTemplate template = new RabbitTemplate(cf);
    template.setExchange(EXCHANGE_NAME);
    RetryTemplate retry = new RetryTemplate();
    ExponentialBackOffPolicy backOff = new ExponentialBackOffPolicy();
    backOff.setInitialInterval(1000);
    backOff.setMultiplier(1.5);
    backOff.setMaxInterval(60000);
    retry.setBackOffPolicy(backOff);
    template.setRetryTemplate(retry);
    template.setMessageConverter(new Jackson2JsonMessageConverter(mapper));
    return template;
}
 

import org.springframework.retry.backoff.ExponentialBackOffPolicy; //导入依赖的package包/类
public RetryTemplate createRetryTemplate() {
    Map<Class<? extends Throwable>, Boolean> exceptions = new HashMap<>();
    exceptions.put(TaxWebServiceNonFatalException.class, true);

    RetryTemplate template = new RetryTemplate();
    SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy(maxAttempts, exceptions);
    template.setRetryPolicy(retryPolicy);

    ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
    backOffPolicy.setInitialInterval(initialInterval);
    template.setBackOffPolicy(backOffPolicy);

    return template;
}
 

import org.springframework.retry.backoff.ExponentialBackOffPolicy; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean(name = "statsRetryTemplate")
public RetryTemplate statsRetryTemplate() {
	RetryTemplate retryTemplate = new RetryTemplate();
	ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
	backOffPolicy.setInitialInterval(3000L);
	backOffPolicy.setMultiplier(3);
	SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy(
			statsProperties.getElastic().getMaxAttempts(),
			Collections.singletonMap(Exception.class, true));
	retryTemplate.setBackOffPolicy(backOffPolicy);
	retryTemplate.setRetryPolicy(retryPolicy);
	return retryTemplate;
}
 

import org.springframework.retry.backoff.ExponentialBackOffPolicy; //导入依赖的package包/类
@Test
public void testBackOffPolicyIsExponential()
{
	List<Long> sleeps = newArrayList();
	ExponentialBackOffPolicy fakeBackOff = this.backOffPolicy.withSleeper(sleeps::add);
	BackOffContext context = fakeBackOff.start(null);
	for (int i = 0; i < 11; i++)
	{
		fakeBackOff.backOff(context);
	}
	assertEquals(sleeps,
			Arrays.asList(1000L, 2000L, 4000L, 8000L, 16000L, 32000L, 64000L, 128000L, 256000L, 300000L, 300000L));
}