Spring Retry

<dependency>
    <groupId>org.springframework.retry</groupId>
    <artifactId>spring-retry</artifactId>
    <version>1.2.2.RELEASE</version>
</dependency>

compile 'org.springframework.retry:spring-retry:1.2.2.RELEASE'

@Retryable(value = {Exception.class}, maxAttempts = 3, backoff = @Backoff(delay = 3000L))
private void retryService() {
    
}

   @Override
    @Retryable(value = {Exception.class}, maxAttempts = 3, backoff = @Backoff(delay = 1000L))
    public void retryTest() {

        String text = null;
        if (text.equals("1")) {
            System.out.println(text);
        }
    }

public interface RetryOperations {

    /**
     * Execute the supplied {@link RetryCallback} with the configured retry
     * semantics. See implementations for configuration details.
     * 
     * @return the value returned by the {@link RetryCallback} upon successful
     * invocation.
     * @throws E any {@link Exception} raised by the
     * {@link RetryCallback} upon unsuccessful retry.
     * @throws E the exception thrown
     * @param <T> the return value
     * @param retryCallback the {@link RetryCallback}
     * @param <E> the exception to throw
     */
    <T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback) throws E;

    /**
     * Execute the supplied {@link RetryCallback} with a fallback on exhausted
     * retry to the {@link RecoveryCallback}. See implementations for
     * configuration details.
     * 
     * @return the value returned by the {@link RetryCallback} upon successful
     * invocation, and that returned by the {@link RecoveryCallback} otherwise.
     * @throws E any {@link Exception} raised by the
     * @param <T> the type to return
     * @param <E> the type of the exception
     * @param recoveryCallback the {@link RecoveryCallback}
     * @param retryCallback the {@link RetryCallback}
     * {@link RecoveryCallback} upon unsuccessful retry.
     */
    <T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback, RecoveryCallback<T> recoveryCallback) throws E;

    /**
     * A simple stateful retry. Execute the supplied {@link RetryCallback} with
     * a target object for the attempt identified by the {@link DefaultRetryState}.
     * Exceptions thrown by the callback are always propagated immediately so
     * the state is required to be able to identify the previous attempt, if
     * there is one - hence the state is required. Normal patterns would see
     * this method being used inside a transaction, where the callback might
     * invalidate the transaction if it fails.
     * 
     * See implementations for configuration details.
     *
     * @param retryCallback the {@link RetryCallback}
     * @param retryState the {@link RetryState}
     * @return the value returned by the {@link RetryCallback} upon successful
     * invocation, and that returned by the {@link RecoveryCallback} otherwise.
     * @throws E any {@link Exception} raised by the {@link RecoveryCallback}.
     * @throws ExhaustedRetryException if the last attempt for this state has
     * already been reached
     * @param <T> the type of the return value
     * @param <E> the type of the exception to return
     */
    <T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback, RetryState retryState) throws E, ExhaustedRetryException;

    /**
     * A stateful retry with a recovery path. Execute the supplied
     * {@link RetryCallback} with a fallback on exhausted retry to the
     * {@link RecoveryCallback} and a target object for the retry attempt
     * identified by the {@link DefaultRetryState}.
     * @param recoveryCallback the {@link RecoveryCallback}
     * @param retryState the {@link RetryState}
     * @param retryCallback the {@link RetryCallback}
     * @see #execute(RetryCallback, RetryState)
     * @param <T> the return value type
     * @param <E> the exception type
     * @return     the value returned by the {@link RetryCallback} upon successful
     *             invocation, and that returned by the {@link RecoveryCallback} otherwise.
     * @throws E any {@link Exception} raised by the {@link RecoveryCallback} upon unsuccessful retry.
     */
    <T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback, RecoveryCallback<T> recoveryCallback, RetryState retryState)
            throws E;

}

/**
 *
 * Simple retry policy that retries a fixed number of times for a set of named
 * exceptions (and subclasses). The number of attempts includes the initial try,
 * so e.g.
 *
 * <pre>
 * retryTemplate = new RetryTemplate(new SimpleRetryPolicy(3));
 * retryTemplate.execute(callback);
 * </pre>
 *
 * will execute the callback at least once, and as many as 3 times.
 *
 * @author Dave Syer
 * @author Rob Harrop
 * @author Gary Russell
 *
 */

  public void retryTest() {
        RetryTemplate template = new RetryTemplate();
        TimeoutRetryPolicy policy = new TimeoutRetryPolicy();
        policy.setTimeout(30000L);
        template.setRetryPolicy(policy);
        try {
            String result = template.execute(new RetryCallback<String, Exception>() {
                // 重试操作
                @Override
                public String doWithRetry(RetryContext retryContext) throws Exception {
                    return "";
                }
            }, new RecoveryCallback<String>() {
                @Override
                public String recover(RetryContext retryContext) throws Exception {
                    return "";
                }
            });

        } catch (Exception e) {
            e.printStackTrace();
        }
    }