congrats Icon
New! Announcing Tabnine Chat Beta
Learn More
Tabnine Logo
RetryTemplate.<init>
Code IndexAdd Tabnine to your IDE (free)

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

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

origin: spring-projects/spring-retry

public StatefulRetryOperationsInterceptor() {
  RetryTemplate retryTemplate = new RetryTemplate();
  retryTemplate.setRetryPolicy(new NeverRetryPolicy());
  this.retryOperations = retryTemplate;
}
origin: spring-projects/spring-retry

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;
}
origin: spring-projects/spring-batch

@Before
public void onSetUpInTransaction() throws Exception {
  retryTemplate = new RetryTemplate();
}
origin: spring-io/initializr

@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;
}
origin: spring-projects/spring-retry

/**
 * 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();
}
origin: spring-projects/spring-batch

@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();
}
origin: spring-projects/spring-batch

@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();
}
origin: spring-projects/spring-batch

@Test
public void testFailureAndRecovery() throws Exception {
  final RetryTemplate retryTemplate = new RetryTemplate();
  retryTemplate.setRetryPolicy(new NeverRetryPolicy());
  container.setMessageListener(new MessageListener() {
origin: spring-projects/spring-kafka

@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();
}
origin: spring-projects/spring-kafka

@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();
}
origin: spring-projects/spring-kafka

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;
  });
}
origin: spring-projects/spring-kafka

@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);
}
origin: spring-projects/spring-kafka

@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);
}
origin: spring-projects/spring-kafka

@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;
}
origin: spring-projects/spring-integration

RequestHandlerRetryAdvice advice = new RequestHandlerRetryAdvice();
RetryTemplate retryTemplate = new RetryTemplate();
origin: org.springframework.cloud/spring-cloud-commons

  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;
  }
}
origin: spring-projects/spring-integration

@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));
}
origin: spring-projects/spring-integration

@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));
}
origin: spring-projects/spring-kafka

@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;
}
origin: spring-projects/spring-integration

ErrorMessageSendingRecoverer recoverer = new ErrorMessageSendingRecoverer(errors);
advice.setRecoveryCallback(recoverer);
RetryTemplate retryTemplate = new RetryTemplate();
retryTemplate.setRetryPolicy(new SimpleRetryPolicy() {
org.springframework.retry.supportRetryTemplate<init>

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
  • registerThrowable,
  • setThrowLastExceptionOnExhausted,
  • doCloseInterceptors,
  • doExecute,
  • doOnErrorInterceptors,
  • doOpenInterceptors,
  • doOpenInternal,
  • registerContext,
  • rethrow

Popular in Java

  • Parsing JSON documents to java classes using gson
  • getSystemService (Context)
  • runOnUiThread (Activity)
  • onCreateOptionsMenu (Activity)
  • InputStreamReader (java.io)
    A class for turning a byte stream into a character stream. Data read from the source input stream is
  • PrintStream (java.io)
    Fake signature of an existing Java class.
  • Socket (java.net)
    Provides a client-side TCP socket.
  • ByteBuffer (java.nio)
    A buffer for bytes. A byte buffer can be created in either one of the following ways: * #allocate
  • Time (java.sql)
    Java representation of an SQL TIME value. Provides utilities to format and parse the time's represen
  • Executors (java.util.concurrent)
    Factory and utility methods for Executor, ExecutorService, ScheduledExecutorService, ThreadFactory,
  • Best IntelliJ plugins
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now