How to use

setBackOffPolicy

method

in

org.springframework.retry.support.RetryTemplate

public void setBackOffPolicy(BackOffPolicy backOffPolicy) {
  delegate.setBackOffPolicy(backOffPolicy);
  regular.setBackOffPolicy(backOffPolicy);
}

/**
 * Apply the back off policy. Cannot be used if a custom retry operations, or back off
 * policy has been applied.
 * @param policy The policy.
 * @return this.
 */
public RetryInterceptorBuilder<T> backOffPolicy(BackOffPolicy policy) {
  Assert.isNull(this.retryOperations,
      "cannot set the back off policy when a custom retryOperations has been set");
  Assert.isTrue(!this.backOffOptionsSet,
      "cannot set the back off policy when the back off policy options have been set");
  this.retryTemplate.setBackOffPolicy(policy);
  this.templateAltered = true;
  this.backOffPolicySet = true;
  return this;
}

@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(
      this.statsProperties.getElastic().getMaxAttempts(),
      Collections.singletonMap(Exception.class, true));
  retryTemplate.setBackOffPolicy(backOffPolicy);
  retryTemplate.setRetryPolicy(retryPolicy);
  return retryTemplate;
}

/**
 * Apply the backoff options. Cannot be used if a custom retry operations, or back off
 * policy has been set.
 * @param initialInterval The initial interval.
 * @param multiplier The multiplier.
 * @param maxInterval The max interval.
 * @return this.
 */
public RetryInterceptorBuilder<T> backOffOptions(long initialInterval,
    double multiplier, long maxInterval) {
  Assert.isNull(this.retryOperations,
      "cannot set the back off policy when a custom retryOperations has been set");
  Assert.isTrue(!this.backOffPolicySet,
      "cannot set the back off options when a back off policy has been set");
  ExponentialBackOffPolicy policy = new ExponentialBackOffPolicy();
  policy.setInitialInterval(initialInterval);
  policy.setMultiplier(multiplier);
  policy.setMaxInterval(maxInterval);
  this.retryTemplate.setBackOffPolicy(policy);
  this.backOffOptionsSet = true;
  this.templateAltered = true;
  return this;
}

/**
 * Execute a single simulation
 * @return The sleeps which occurred within the single simulation.
 */
public List<Long> executeSingleSimulation() {
  StealingSleeper stealingSleeper = new StealingSleeper();
  SleepingBackOffPolicy<?> stealingBackoff = backOffPolicy.withSleeper(stealingSleeper);
  RetryTemplate template = new RetryTemplate();
  template.setBackOffPolicy(stealingBackoff);
  template.setRetryPolicy(retryPolicy);
  try {
    template.execute(new FailingRetryCallback());
  } catch(FailingRetryException e) {
  } catch(Throwable e) {
    throw new RuntimeException("Unexpected exception", e);
  }
  return stealingSleeper.getSleeps();
}

private MethodInterceptor getStatelessInterceptor(Object target, Method method, Retryable retryable) {
  RetryTemplate template = createTemplate(retryable.listeners());
  template.setRetryPolicy(getRetryPolicy(retryable));
  template.setBackOffPolicy(getBackoffPolicy(retryable.backoff()));
  return RetryInterceptorBuilder.stateless()
      .retryOperations(template)
      .label(retryable.label())
      .recoverer(getRecoverer(target, method))
      .build();
}

  breaker.setResetTimeout(getResetTimeout(circuit));
  template.setRetryPolicy(breaker);
  template.setBackOffPolicy(new NoBackOffPolicy());
  String label = circuit.label();
  if (!StringUtils.hasText(label))  {
template.setBackOffPolicy(getBackoffPolicy(retryable.backoff()));
String label = retryable.label();
return RetryInterceptorBuilder.stateful()

public void restart(final int index) throws Exception { //NOSONAR
  // retry restarting repeatedly, first attempts may fail
  SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy(10, // NOSONAR magic #
      Collections.singletonMap(Exception.class, true));
  ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
  backOffPolicy.setInitialInterval(100); // NOSONAR magic #
  backOffPolicy.setMaxInterval(1000); // NOSONAR magic #
  backOffPolicy.setMultiplier(2); // NOSONAR magic #
  RetryTemplate retryTemplate = new RetryTemplate();
  retryTemplate.setRetryPolicy(retryPolicy);
  retryTemplate.setBackOffPolicy(backOffPolicy);
  retryTemplate.execute(context -> {
    this.kafkaServers.get(index).startup();
    return null;
  });
}

  private RetryTemplate createRetryTemplate(String serviceName, HttpRequest request, LoadBalancedRetryPolicy retryPolicy) {
    RetryTemplate template = new RetryTemplate();
    BackOffPolicy backOffPolicy = lbRetryFactory.createBackOffPolicy(serviceName);
    template.setBackOffPolicy(backOffPolicy == null ? new NoBackOffPolicy() : backOffPolicy);
    template.setThrowLastExceptionOnExhausted(true);
    RetryListener[] retryListeners = lbRetryFactory.createRetryListeners(serviceName);
    if (retryListeners != null && retryListeners.length != 0) {
      template.setListeners(retryListeners);
    }
    template.setRetryPolicy(
        !lbProperties.isEnabled() || retryPolicy == null ? new NeverRetryPolicy()
            : new InterceptorRetryPolicy(request, retryPolicy, loadBalancer,
            serviceName));
    return template;
  }
}

public void setBackOffPolicy(BackOffPolicy backOffPolicy) {
  delegate.setBackOffPolicy(backOffPolicy);
  regular.setBackOffPolicy(backOffPolicy);
}

@Override
public void afterPropertiesSet() throws Exception {
  // Validate all job parameters
  Assert.notNull(parser, "The 'parser' property must have a value");
  Assert.notNull(request, "The 'request' property must have a value");
  Assert.notNull(streamer, "The 'streamer' property must have a value");
  Assert.notNull(retryPolicy, "The 'retryPolicy' property must have a value");
  Assert.notNull(backOffPolicy, "The 'backOffPolicy' property must have a value");
  retryTemplate = new RetryTemplate();
  retryTemplate.setRetryPolicy(retryPolicy);
  retryTemplate.setBackOffPolicy(backOffPolicy);
}

/**
 * Apply the back off policy. Cannot be used if a custom retry operations, or back off policy has been applied.
 * @param policy The policy.
 * @return this.
 */
public B backOffPolicy(BackOffPolicy policy) {
  Assert.isNull(this.retryOperations, "cannot set the back off policy when a custom retryOperations has been set");
  Assert.isTrue(!this.backOffOptionsSet, "cannot set the back off policy when the back off policy options have been set");
  this.retryTemplate.setBackOffPolicy(policy);
  this.templateAltered = true;
  this.backOffPolicySet = true;
  return _this();
}

@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;
}

private RetryTemplate retryTemplate() {
  RetryTemplate template = new RetryTemplate();
  template.setBackOffPolicy(exponentialBackOffPolicy());
  template.setRetryPolicy(retryPolicy());
  return template;
}

@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;
}

private void waitFor(BiConsumer<String, CouchbaseBuildDefinition> function, String host, CouchbaseBuildDefinition buildDefinition) {
  TimeoutRetryPolicy retryPolicy = new TimeoutRetryPolicy();
  retryPolicy.setTimeout(THIRTY_SECONDS);
  FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy();
  backOffPolicy.setBackOffPeriod(ONE_SECOND);
  RetryTemplate retryTemplate = new RetryTemplate();
  retryTemplate.setRetryPolicy(retryPolicy);
  retryTemplate.setThrowLastExceptionOnExhausted(true);
  retryTemplate.setBackOffPolicy(backOffPolicy);
  retryTemplate.execute(rc -> { function.accept(host, buildDefinition); return null; });
}

private void waitFor(BiConsumer<Bucket, CouchbaseBuildDefinition> function, Bucket bucket, CouchbaseBuildDefinition buildDefinition) {
  TimeoutRetryPolicy retryPolicy = new TimeoutRetryPolicy();
  retryPolicy.setTimeout(THIRTY_SECONDS);
  FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy();
  backOffPolicy.setBackOffPeriod(ONE_SECOND);
  RetryTemplate retryTemplate = new RetryTemplate();
  retryTemplate.setRetryPolicy(retryPolicy);
  retryTemplate.setThrowLastExceptionOnExhausted(true);
  retryTemplate.setBackOffPolicy(backOffPolicy);
  retryTemplate.execute(rc -> { function.accept(bucket, buildDefinition); return null; });
}

private void waitForContainerToStart() {
  TimeoutRetryPolicy retryPolicy = new TimeoutRetryPolicy();
  retryPolicy.setTimeout(THIRTY_SECONDS);
  FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy();
  backOffPolicy.setBackOffPeriod(ONE_SECOND);
  RetryTemplate retryTemplate = new RetryTemplate();
  retryTemplate.setRetryPolicy(retryPolicy);
  retryTemplate.setThrowLastExceptionOnExhausted(true);
  retryTemplate.setBackOffPolicy(backOffPolicy);
  retryTemplate.execute(rc -> portInUse(dockerHostname, firstExternalPort()));
}

public DefaultRetryPolicyAdvice(MessageRecoverer messageRecoverer, RetryPolicy retryPolicy)
{
  RetryTemplate retryTemplate = new RetryTemplate();
  retryTemplate.setBackOffPolicy(createBackOffPolicy());
  retryTemplate.setRetryPolicy(retryPolicy);
  retryTemplate.registerListener(new RetryErrorListener());
  StatefulRetryOperationsInterceptorFactoryBean factory = new StatefulRetryOperationsInterceptorFactoryBean();
  factory.setRetryOperations(retryTemplate);
  factory.setMessageKeyGenerator(new DefaultMessageKeyGenerator());
  factory.setMessageRecoverer(messageRecoverer);
  this.delegate = factory.getObject();
}

private MethodInterceptor getStatelessInterceptor(Object target, Method method, Retryable retryable) {
  RetryTemplate template = createTemplate(retryable.listeners());
  template.setRetryPolicy(getRetryPolicy(retryable));
  template.setBackOffPolicy(getBackoffPolicy(retryable.backoff()));
  return RetryInterceptorBuilder.stateless()
      .retryOperations(template)
      .label(retryable.label())
      .recoverer(getRecoverer(target, method))
      .build();
}