How to use

RetryTemplate

in

org.springframework.retry.support

/**
 * 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();
}

public void registerListener(RetryListener listener) {
  delegate.registerListener(listener);
  regular.registerListener(listener);
}

private RetryTemplate createTemplate(String[] listenersBeanNames) {
  RetryTemplate template = new RetryTemplate();
  if (listenersBeanNames.length > 0) {
    template.setListeners(getListenersBeans(listenersBeanNames));
  } else if (globalListeners !=null) {
    template.setListeners(globalListeners);
  }
  return template;
}

public StatefulRetryOperationsInterceptor() {
  RetryTemplate retryTemplate = new RetryTemplate();
  retryTemplate.setRetryPolicy(new NeverRetryPolicy());
  this.retryOperations = retryTemplate;
}

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

  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 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();
}

@Override
public final <T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback, RecoveryCallback<T> recoveryCallback,
    RetryState retryState) throws E {
  return regular.execute(retryCallback, recoveryCallback, retryState);
}

@Before
public void onSetUpInTransaction() throws Exception {
  retryTemplate = new RetryTemplate();
}

private MethodInterceptor getStatefulInterceptor(Object target, Method method, Retryable retryable) {
  RetryTemplate template = createTemplate(retryable.listeners());
  template.setRetryContextCache(this.retryContextCache);
    breaker.setOpenTimeout(getOpenTimeout(circuit));
    breaker.setResetTimeout(getResetTimeout(circuit));
    template.setRetryPolicy(breaker);
    template.setBackOffPolicy(new NoBackOffPolicy());
    String label = circuit.label();
    if (!StringUtils.hasText(label))  {
  template.setRetryPolicy(policy);
  template.setBackOffPolicy(getBackoffPolicy(retryable.backoff()));
  String label = retryable.label();
  return RetryInterceptorBuilder.stateful()

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();
}

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

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

public void setRetryPolicy(RetryPolicy retryPolicy) {
  this.retryPolicy = retryPolicy;
  delegate.setRetryPolicy(retryPolicy);
  regular.setRetryPolicy(retryPolicy);
}

public void setListeners(RetryListener[] listeners) {
  delegate.setListeners(listeners);
  regular.setListeners(listeners);
}

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

@Test
public void testFailureAndRecovery() throws Exception {
  final RetryTemplate retryTemplate = new RetryTemplate();
  retryTemplate.setRetryPolicy(new NeverRetryPolicy());
  container.setMessageListener(new MessageListener() {
    @Override

  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 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();
}

@Override
public final <T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback, RetryState retryState) throws E,
ExhaustedRetryException {
  return regular.execute(retryCallback, retryState);
}