org.springframework.retry.support.RetryTemplate.<init> java code examples

Common ways to obtain RetryTemplate

private void myMethod () {
 RetryTemplate r =new RetryTemplate()
DefaultRetryPolicyFactory.makeRabbitTemplateRetry()
Smart code suggestions by Tabnine
}

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() {

Popular methods of RetryTemplate

setRetryPolicy
Setter for RetryPolicy.
setBackOffPolicy
Setter for BackOffPolicy.
execute
Execute the callback once if the policy dictates that we can, re-throwing any exception encountered
registerListener
Register an additional listener.
setListeners
Setter for listeners. The listeners are executed before and after a retry block (i.e. before and aft
setRetryContextCache
Public setter for the RetryContextCache.
canRetry
Decide whether to proceed with the ongoing retry attempt. This method is called before the RetryCall
close
Clean up the cache if necessary and close the context provided (if the flag indicates that processin
handleRetryExhausted
Actions to take after final attempt has failed. If there is state clean up the cache. If there is a
open
Delegate to the RetryPolicy having checked in the cache for an existing value if the state is not nu
registerThrowable
setThrowLastExceptionOnExhausted

Popular in Java

Making http post requests using okhttp
getApplicationContext (Context)
putExtra (Intent)
getSharedPreferences (Context)
FileNotFoundException (java.io)
Thrown when a file specified by a program cannot be found.
Path (java.nio.file)
Connection (java.sql)
A connection represents a link from a Java application to a database. All SQL statements and results
Timer (java.util)
Timers schedule one-shot or recurring TimerTask for execution. Prefer java.util.concurrent.Scheduled
TimeUnit (java.util.concurrent)
A TimeUnit represents time durations at a given unit of granularity and provides utility methods to
Option (scala)
Sublime Text for Python

How to use org.springframework.retry.support.RetryTemplateconstructor

Best Java code snippets using org.springframework.retry.support.RetryTemplate.<init> (Showing top 20 results out of 405)

How to use
org.springframework.retry.support.RetryTemplate
constructor