import org.springframework.retry.backoff.FixedBackOffPolicy; //导入依赖的package包/类
private void assertProcessEnded(final ProcessInstance pi) {
    // fetch active executions
    RetryTemplate retryTemplate = new RetryTemplate();
    final SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy();
    retryPolicy.setMaxAttempts(5);
    retryTemplate.setRetryPolicy(retryPolicy);
    FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy();
    retryTemplate.setBackOffPolicy(backOffPolicy);
    retryTemplate.execute(new RetryCallback<Void, RuntimeException>() {
        @Override
        public Void doWithRetry(RetryContext retryContext) throws RuntimeException {
            List<ProcessInstance> processInstances = runtimeService.createProcessInstanceQuery().list();
            int processCount = processInstances.size();
            LOGGER.info("waiting for process to end (Still {} process running).", processCount);
            if (processCount > 0) {
                for (ProcessInstance processInstance : processInstances) {
                    LOGGER.info("Process info: {} ", dumpprocessInstance(processInstance));
                }
                throw new IllegalStateException("Some process still running. Left :" + processCount);
            }
            return null;
        }
    });
}
 

import org.springframework.retry.backoff.FixedBackOffPolicy; //导入依赖的package包/类
/**
 * Configure and return the retry template.
 */
public RetryTemplate getRetryTemplate(){
    //Create RetryTemplate
    final RetryTemplate retryTemplate = new RetryTemplate();
    
    //Create Fixed back policy
    final FixedBackOffPolicy fixedBackOffPolicy = new FixedBackOffPolicy();
    
    //Set backOffPeriod
    fixedBackOffPolicy.setBackOffPeriod(Long.valueOf(backOffPeriod));
    
    //Set the backoff policy
    retryTemplate.setBackOffPolicy(fixedBackOffPolicy);

    //Create Simple Retry Policy
    final CmsRetryPolicy retryPolicy = new CmsRetryPolicy(Integer.valueOf(maxAttempts), Collections
            .<Class<? extends Throwable>, Boolean> singletonMap(RestClientException.class, true), false);

    //Set retry policy
    retryTemplate.setRetryPolicy(retryPolicy);
    
    //Return the RetryTemplate
    return retryTemplate;
}
 

import org.springframework.retry.backoff.FixedBackOffPolicy; //导入依赖的package包/类
public ExitStatus getWithRetry(RetryCallback<ExitStatus, Exception> callback) {
	RetryTemplate retryTemplate = new RetryTemplate();
	FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy();
	Map<Class<? extends Throwable>,Boolean> retryableExceptions = new HashMap<Class<? extends Throwable>,Boolean>();
	retryableExceptions.put(ClientProtocolException.class, Boolean.TRUE);
	retryableExceptions.put(IOException.class, Boolean.TRUE);

	SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy(retryAttempts, retryableExceptions);
	backOffPolicy.setBackOffPeriod(backoffPeriod);

	retryTemplate.setListeners(retryListeners);
	retryTemplate.setBackOffPolicy(backOffPolicy);
	retryTemplate.setRetryPolicy(retryPolicy);

	try {
		return retryTemplate.execute(callback);
	} catch (Exception e) {
		logger.error("Retry processing failed " + e.getMessage());
		return ExitStatus.FAILED;
	}
}
 

import org.springframework.retry.backoff.FixedBackOffPolicy; //导入依赖的package包/类
/**
 * get a spring customized retry template
 * 
 * @param timeoutInSec
 * @return a customized retry template
 */
private static RetryTemplate getRetryTemplate(Integer timeoutInSec) {
	// we set the retry time out
	TimeoutRetryPolicy retryPolicy = new TimeoutRetryPolicy();
	retryPolicy.setTimeout(timeoutInSec * 1000 * 60);

	// we set the back off period to 60s
	FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy();
	backOffPolicy.setBackOffPeriod(60000);

	// our retry service
	RetryTemplate retryTemplate = new RetryTemplate();
	retryTemplate.setRetryPolicy(retryPolicy);
	retryTemplate.setBackOffPolicy(backOffPolicy);
	return retryTemplate;
}
 

import org.springframework.retry.backoff.FixedBackOffPolicy; //导入依赖的package包/类
private Consul getConsul() {
    // test that the client is active - the purpose of this test is to make sure that the instance of consul in the
    // cluster is alive, is it's not we'll create a new one before giving up. The assumption is that the hostname of
    // consul is really a consul service that hides multiple instances of consul servers.
    RetryTemplate retryTemplate = new RetryTemplate();
    retryTemplate.setBackOffPolicy(new FixedBackOffPolicy());
    TimeoutRetryPolicy retryPolicy = new TimeoutRetryPolicy();
    retryPolicy.setTimeout(10000);
    retryTemplate.setRetryPolicy(retryPolicy);

    return retryTemplate.execute(context -> {
        if (consul == null || consul.statusClient() == null || isEmpty(consul.statusClient().getLeader())) {
            // if we can't find a leader this means that the consul client is not usable - we'll release it
            log.warn("couldn't verify connection to Consul");
            log.info("creating a new Consul client");
            consul = newClient(consulProperties.getHostname(), consulProperties.getHttpPort());

            // throwing this exception to retry according to the policies. The last retry will throw this exception
            throw new IllegalStateException("Consul connection could not be verified");
        } else {
            log.info("Consul connection verified");
            return consul;
        }
    });
}
 

import org.springframework.retry.backoff.FixedBackOffPolicy; //导入依赖的package包/类
@Override
protected RetryTemplate retryTemplate() {
	RetryTemplate retry = super.retryTemplate();

	FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy();
	backOffPolicy.setBackOffPeriod(0);
	retry.setBackOffPolicy(backOffPolicy);

	return retry;
}
 

import org.springframework.retry.backoff.FixedBackOffPolicy; //导入依赖的package包/类
/**
 * Create a {@link FixedBackOffPolicy} of 1 second. The default is
 * already 1 second in that class, but want to protect against that
 * changing in future iterations.
 * @return New FixedBackOffPolicy with 1 second backoff.
 */
public FixedBackOffPolicy createOneSecondBackoffPolicy()
{
   FixedBackOffPolicy policy = new FixedBackOffPolicy();
   policy.setBackOffPeriod(1000);
   return policy;
}
 

import org.springframework.retry.backoff.FixedBackOffPolicy; //导入依赖的package包/类
private static RetryTemplate getRetryTemplate(Integer timeoutInMin) {
	// we set the retry time out
	TimeoutRetryPolicy retryPolicy = new TimeoutRetryPolicy();
	retryPolicy.setTimeout(timeoutInMin * 1000 * 60);

	// we set the back off period to 60s
	FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy();
	backOffPolicy.setBackOffPeriod(60000);

	// our retry service
	RetryTemplate retryTemplate = new RetryTemplate();
	retryTemplate.setRetryPolicy(retryPolicy);
	retryTemplate.setBackOffPolicy(backOffPolicy);
	return retryTemplate;
}
 

import org.springframework.retry.backoff.FixedBackOffPolicy; //导入依赖的package包/类
@PostConstruct
public void start() throws Exception
{
   try
   {
      kafkaVersion = new Version(properties.getKafkaVersion());
   }
   catch (Exception ex)
   {
      throw new IllegalStateException("Invalid kafka version: " + properties.getKafkaVersion(), ex);
   }

   threadPool = new ForkJoinPool(properties.getThreadPoolSize());

   FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy();
   backOffPolicy.setBackOffPeriod(properties.getRetry().getBackoffMillis());

   final SimpleRetryPolicy retryPolicy =
      new SimpleRetryPolicy(properties.getRetry().getMaxAttempts(),
                            ImmutableMap.of(InterruptedException.class, false,
                                            Exception.class, true));

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

   cacheInitCounter.set(4);

   brokerPathCache = new PathChildrenCache(curatorFramework, ZkUtils.BrokerIdsPath(), true);
   brokerPathCache.getListenable().addListener(new BrokerListener());
   brokerPathCache.getListenable().addListener((f, e) -> {
      if (e.getType() == PathChildrenCacheEvent.Type.INITIALIZED)
      {
         cacheInitCounter.decrementAndGet();
         LOG.info("Broker cache initialized");
      }
   });
   brokerPathCache.start(StartMode.POST_INITIALIZED_EVENT);

   topicConfigPathCache = new PathChildrenCache(curatorFramework, ZkUtils.TopicConfigPath(), true);
   topicConfigPathCache.getListenable().addListener((f, e) -> {
      if (e.getType() == PathChildrenCacheEvent.Type.INITIALIZED)
      {
         cacheInitCounter.decrementAndGet();
         LOG.info("Topic configuration cache initialized");
      }
   });
   topicConfigPathCache.start(StartMode.POST_INITIALIZED_EVENT);

   topicTreeCache = new TreeCache(curatorFramework, ZkUtils.BrokerTopicsPath());
   topicTreeCache.getListenable().addListener((client, event) -> {
      if (event.getType() == TreeCacheEvent.Type.INITIALIZED)
      {
         cacheInitCounter.decrementAndGet();
         LOG.info("Topic tree cache initialized");
      }
   });
   topicTreeCache.start();

   consumerTreeCache = new TreeCache(curatorFramework, ZkUtils.ConsumersPath());
   consumerTreeCache.getListenable().addListener((client, event) -> {
      if (event.getType() == TreeCacheEvent.Type.INITIALIZED)
      {
         cacheInitCounter.decrementAndGet();
         LOG.info("Consumer tree cache initialized");
      }
   });
   consumerTreeCache.start();

   controllerNodeCache = new NodeCache(curatorFramework, ZkUtils.ControllerPath());
   controllerNodeCache.getListenable().addListener(this::updateController);
   controllerNodeCache.start(true);
   updateController();
}
 

import org.springframework.retry.backoff.FixedBackOffPolicy; //导入依赖的package包/类
private FixedBackOffPolicy retryEvery60s() {
    //retry every 60s
    FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy();
    backOffPolicy.setBackOffPeriod(60000);
    return backOffPolicy;
}
 

import org.springframework.retry.backoff.FixedBackOffPolicy; //导入依赖的package包/类
/**
 * リトライ間隔を設定し、{@link SleepingBackOffPolicy}のインスタンスを生成します。
 * @return {@link FixedBackOffPolicy}のインスタンス
 */
protected SleepingBackOffPolicy<FixedBackOffPolicy> backOffPolicy() {
    FixedBackOffPolicy policy = new FixedBackOffPolicy();
    policy.setBackOffPeriod(backOffPeriod);
    return policy;
}