How to use

org.springframework.retry.support.RetryTemplate

constructor

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

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

@Before
public void onSetUpInTransaction() throws Exception {
  retryTemplate = new 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;
}

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

@Before
public void onSetUp() throws Exception {
  getMessages(); // drain queue
  jdbcTemplate.execute("delete from T_BARS");
  jmsTemplate.convertAndSend("queue", "foo");
  provider = new ItemReader<String>() {
    @Override
    public String read() {
      String text = (String) jmsTemplate.receiveAndConvert("queue");
      list.add(text);
      return text;
    }
  };
  retryTemplate = new RetryTemplate();
}

@Before
public void onSetUp() throws Exception {
  getMessages(); // drain queue
  jdbcTemplate.execute("delete from T_BARS");
  jmsTemplate.convertAndSend("queue", "foo");
  jmsTemplate.convertAndSend("queue", "bar");
  provider = new ItemReader<String>() {
    @Override
    public String read() {
      String text = (String) jmsTemplate.receiveAndConvert("queue");
      list.add(text);
      return text;
    }
  };
  retryTemplate = new RetryTemplate();
}

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

@Test
public void testRecoveryCallbackSimple() {
  final AtomicReference<RetryContext> context = new AtomicReference<>();
  RetryingMessageListenerAdapter<String, String> adapter = new RetryingMessageListenerAdapter<>(
      r -> {
        throw new RuntimeException();
      }, new RetryTemplate(), c -> {
        context.set(c);
        return null;
      });
  @SuppressWarnings("unchecked")
  ConsumerRecord<String, String> record = mock(ConsumerRecord.class);
  adapter.onMessage(record, mock(Acknowledgment.class), mock(Consumer.class));
  assertThat(context.get()).isNotNull();
  assertThat(context.get().getAttribute(RetryingMessageListenerAdapter.CONTEXT_ACKNOWLEDGMENT)).isNull();
  assertThat(context.get().getAttribute(RetryingMessageListenerAdapter.CONTEXT_RECORD)).isSameAs(record);
  assertThat(context.get().getAttribute(RetryingMessageListenerAdapter.CONTEXT_CONSUMER)).isNull();
}

@Test
public void testRecoveryCallbackAckOnly() {
  final AtomicReference<RetryContext> context = new AtomicReference<>();
  RetryingMessageListenerAdapter<String, String> adapter = new RetryingMessageListenerAdapter<>(
      (AcknowledgingMessageListener<String, String>) (r, a) -> {
        throw new RuntimeException();
      }, new RetryTemplate(), c -> {
        context.set(c);
        return null;
      });
  @SuppressWarnings("unchecked")
  ConsumerRecord<String, String> record = mock(ConsumerRecord.class);
  Acknowledgment ack = mock(Acknowledgment.class);
  adapter.onMessage(record, ack, mock(Consumer.class));
  assertThat(context.get()).isNotNull();
  assertThat(context.get().getAttribute(RetryingMessageListenerAdapter.CONTEXT_ACKNOWLEDGMENT)).isSameAs(ack);
  assertThat(context.get().getAttribute(RetryingMessageListenerAdapter.CONTEXT_RECORD)).isSameAs(record);
  assertThat(context.get().getAttribute(RetryingMessageListenerAdapter.CONTEXT_CONSUMER)).isNull();
}

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

@Test
public void testRecoveryCallbackConsumerOnly() {
  final AtomicReference<RetryContext> context = new AtomicReference<>();
  RetryingMessageListenerAdapter<String, String> adapter = new RetryingMessageListenerAdapter<>(
      (ConsumerAwareMessageListener<String, String>) (r, c) -> {
        throw new RuntimeException();
      }, new RetryTemplate(), c -> {
        context.set(c);
        return null;
      });
  @SuppressWarnings("unchecked")
  ConsumerRecord<String, String> record = mock(ConsumerRecord.class);
  Consumer<?, ?> consumer = mock(Consumer.class);
  adapter.onMessage(record, mock(Acknowledgment.class), consumer);
  assertThat(context.get()).isNotNull();
  assertThat(context.get().getAttribute(RetryingMessageListenerAdapter.CONTEXT_ACKNOWLEDGMENT)).isNull();
  assertThat(context.get().getAttribute(RetryingMessageListenerAdapter.CONTEXT_RECORD)).isSameAs(record);
  assertThat(context.get().getAttribute(RetryingMessageListenerAdapter.CONTEXT_CONSUMER)).isSameAs(consumer);
}

@Test
public void testRecoveryCallbackAckAndConsumer() {
  final AtomicReference<RetryContext> context = new AtomicReference<>();
  RetryingMessageListenerAdapter<String, String> adapter = new RetryingMessageListenerAdapter<>(
      (AcknowledgingConsumerAwareMessageListener<String, String>) (r, a, c) -> {
        throw new RuntimeException();
      }, new RetryTemplate(), c -> {
        context.set(c);
        return null;
      });
  @SuppressWarnings("unchecked")
  ConsumerRecord<String, String> record = mock(ConsumerRecord.class);
  Acknowledgment ack = mock(Acknowledgment.class);
  Consumer<?, ?> consumer = mock(Consumer.class);
  adapter.onMessage(record, ack, consumer);
  assertThat(context.get()).isNotNull();
  assertThat(context.get().getAttribute(RetryingMessageListenerAdapter.CONTEXT_ACKNOWLEDGMENT)).isSameAs(ack);
  assertThat(context.get().getAttribute(RetryingMessageListenerAdapter.CONTEXT_RECORD)).isSameAs(record);
  assertThat(context.get().getAttribute(RetryingMessageListenerAdapter.CONTEXT_CONSUMER)).isSameAs(consumer);
}

@Bean
public KafkaListenerContainerFactory<?> kafkaListenerContainerFactory() {
  ConcurrentKafkaListenerContainerFactory<Integer, String> factory =
      new ConcurrentKafkaListenerContainerFactory<>();
  factory.setConsumerFactory(consumerFactory());
  factory.setErrorHandler(new SeekToCurrentErrorHandler() {
    @Override
    public void handle(Exception thrownException, List<ConsumerRecord<?, ?>> records,
        Consumer<?, ?> consumer, MessageListenerContainer container) {
      Config.this.seekPerformed = true;
      super.handle(thrownException, records, consumer, container);
    }
  });
  factory.setStatefulRetry(true);
  factory.setRetryTemplate(new RetryTemplate());
  factory.setRecoveryCallback(c -> {
    this.latch2.countDown();
    return null;
  });
  return factory;
}

RequestHandlerRetryAdvice advice = new RequestHandlerRetryAdvice();
RetryTemplate retryTemplate = new 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;
  }
}

@Test
public void testRetryWithinOnMessageGateway() throws Exception {
  ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
  AbstractMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory);
  AmqpInboundGateway adapter = new AmqpInboundGateway(container);
  adapter.setRequestChannel(new DirectChannel());
  adapter.setRetryTemplate(new RetryTemplate());
  QueueChannel errors = new QueueChannel();
  ErrorMessageSendingRecoverer recoveryCallback = new ErrorMessageSendingRecoverer(errors);
  recoveryCallback.setErrorMessageStrategy(new AmqpMessageHeaderErrorMessageStrategy());
  adapter.setRecoveryCallback(recoveryCallback);
  adapter.afterPropertiesSet();
  ChannelAwareMessageListener listener = (ChannelAwareMessageListener) container.getMessageListener();
  listener.onMessage(org.springframework.amqp.core.MessageBuilder.withBody("foo".getBytes())
      .andProperties(new MessageProperties()).build(), null);
  Message<?> errorMessage = errors.receive(0);
  assertNotNull(errorMessage);
  assertThat(errorMessage.getPayload(), instanceOf(MessagingException.class));
  MessagingException payload = (MessagingException) errorMessage.getPayload();
  assertThat(payload.getMessage(), containsString("Dispatcher has no"));
  assertThat(StaticMessageHeaderAccessor.getDeliveryAttempt(payload.getFailedMessage()).get(), equalTo(3));
  org.springframework.amqp.core.Message amqpMessage = errorMessage.getHeaders()
    .get(AmqpMessageHeaderErrorMessageStrategy.AMQP_RAW_MESSAGE, org.springframework.amqp.core.Message.class);
  assertThat(amqpMessage, notNullValue());
  assertNull(errors.receive(0));
}

@Test
public void testRetryWithinOnMessageAdapter() throws Exception {
  ConnectionFactory connectionFactory = mock(ConnectionFactory.class);
  AbstractMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory);
  AmqpInboundChannelAdapter adapter = new AmqpInboundChannelAdapter(container);
  adapter.setOutputChannel(new DirectChannel());
  adapter.setRetryTemplate(new RetryTemplate());
  QueueChannel errors = new QueueChannel();
  ErrorMessageSendingRecoverer recoveryCallback = new ErrorMessageSendingRecoverer(errors);
  recoveryCallback.setErrorMessageStrategy(new AmqpMessageHeaderErrorMessageStrategy());
  adapter.setRecoveryCallback(recoveryCallback);
  adapter.afterPropertiesSet();
  ChannelAwareMessageListener listener = (ChannelAwareMessageListener) container.getMessageListener();
  listener.onMessage(org.springframework.amqp.core.MessageBuilder.withBody("foo".getBytes())
      .andProperties(new MessageProperties()).build(), null);
  Message<?> errorMessage = errors.receive(0);
  assertNotNull(errorMessage);
  assertThat(errorMessage.getPayload(), instanceOf(MessagingException.class));
  MessagingException payload = (MessagingException) errorMessage.getPayload();
  assertThat(payload.getMessage(), containsString("Dispatcher has no"));
  assertThat(StaticMessageHeaderAccessor.getDeliveryAttempt(payload.getFailedMessage()).get(), equalTo(3));
  org.springframework.amqp.core.Message amqpMessage = errorMessage.getHeaders()
    .get(AmqpMessageHeaderErrorMessageStrategy.AMQP_RAW_MESSAGE, org.springframework.amqp.core.Message.class);
  assertThat(amqpMessage, notNullValue());
  assertNull(errors.receive(0));
}

@Bean
public KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<Integer, String>>
    kafkaManualAckListenerContainerFactory() {
  ConcurrentKafkaListenerContainerFactory<Integer, String> factory =
      new ConcurrentKafkaListenerContainerFactory<>();
  factory.setConsumerFactory(configuredConsumerFactory("clientIdViaProps3"));
  ContainerProperties props = factory.getContainerProperties();
  props.setAckMode(AckMode.MANUAL_IMMEDIATE);
  props.setIdleEventInterval(100L);
  factory.setRecordFilterStrategy(manualFilter());
  factory.setAckDiscarded(true);
  factory.setRetryTemplate(new RetryTemplate());
  factory.setRecoveryCallback(c -> null);
  return factory;
}

ErrorMessageSendingRecoverer recoverer = new ErrorMessageSendingRecoverer(errors);
advice.setRecoveryCallback(recoverer);
RetryTemplate retryTemplate = new RetryTemplate();
retryTemplate.setRetryPolicy(new SimpleRetryPolicy() {