Spring Boot中使用Spring Retry重试框架的操作方法

<dependency>

     <groupId>org.springframework.retry</groupId>

     <artifactId>spring-retry</artifactId>

</dependency>

<!-- also need to add Spring AOP into our project-->

<dependency>

     <groupId>org.springframework</groupId>

     <artifactId>spring-aspects</artifactId>

</dependency>

package org.example;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.retry.annotation.EnableRetry;

@SpringBootApplication

@EnableRetry

public class RetryApp {

     public static void main(String[] args) {

         SpringApplication.run(RetryApp. class , args);

     }

}

package org.example;

import lombok.extern.slf4j.Slf4j;

import org.springframework.retry.annotation.Backoff;

import org.springframework.retry.annotation.Recover;

import org.springframework.retry.annotation.Retryable;

import org.springframework.stereotype.Service;

import java.time.LocalDateTime;

@Service

@Slf4j

public class RetryService {

     @Retryable (value = IllegalAccessException. class )

     public void service1() throws IllegalAccessException {

         log.info( "do something... {}" , LocalDateTime.now());

         throw new IllegalAccessException( "manual exception" );

     }

}

@Target ({ ElementType.METHOD, ElementType.TYPE })

@Retention (RetentionPolicy.RUNTIME)

@Documented

public @interface Retryable {

     /**

      * Retry interceptor bean name to be applied for retryable method. Is mutually

      * exclusive with other attributes.

      * @return the retry interceptor bean name

      */

     String interceptor() default "" ;

      * Exception types that are retryable. Synonym for includes(). Defaults to empty (and

      * if excludes is also empty all exceptions are retried).

      * @return exception types to retry

     Class<? extends Throwable>[] value() default {};

      * Exception types that are retryable. Defaults to empty (and if excludes is also

      * empty all exceptions are retried).

     Class<? extends Throwable>[] include() default {};

      * Exception types that are not retryable. Defaults to empty (and if includes is also

      * If includes is empty but excludes is not, all not excluded exceptions are retried

      * @return exception types not to retry

     Class<? extends Throwable>[] exclude() default {};

      * A unique label for statistics reporting. If not provided the caller may choose to

      * ignore it, or provide a default .

      *

      * @return the label for the statistics

     String label() default "" ;

      * Flag to say that the retry is stateful: i.e. exceptions are re-thrown, but the

      * retry policy is applied with the same policy to subsequent invocations with the

      * same arguments. If false then retryable exceptions are not re-thrown.

      * @return true if retry is stateful, default false

     boolean stateful() default false ;

      * @return the maximum number of attempts (including the first failure), defaults to 3

     int maxAttempts() default 3 ;  //默认重试次数3次

      * @return an expression evaluated to the maximum number of attempts (including the first failure), defaults to 3

      * Overrides { @link #maxAttempts()}.

      * @since 1.2

     String maxAttemptsExpression() default "" ;

      * Specify the backoff properties for retrying this operation. The default is a

      * simple { @link Backoff} specification with no properties - see it's documentation

      * for defaults.

      * @return a backoff specification

     Backoff backoff() default @Backoff (); //默认的重试中的退避策略

      * Specify an expression to be evaluated after the { @code SimpleRetryPolicy.canRetry()}

      * returns true - can be used to conditionally suppress the retry. Only invoked after

      * an exception is thrown. The root object for the evaluation is the last { @code Throwable}.

      * Other beans in the context can be referenced.

      * For example:

      * <pre class =code>

      *  { @code "message.contains('you can retry this')" }.

      * </pre>

      * and

      *  { @code "@someBean.shouldRetry(#root)" }.

      * @return the expression.

     String exceptionExpression() default "" ;

      * Bean names of retry listeners to use instead of default ones defined in Spring context

      * @return retry listeners bean names

     String[] listeners() default {};

}

@Target (ElementType.TYPE)

@Retention (RetentionPolicy.RUNTIME)

@Documented

public @interface Backoff {

     /**

      * Synonym for {@link #delay()}.

      *

      * @return the delay in milliseconds (default 1000)

      */

     long value() default 1000 ; //默认的重试间隔1秒

      * A canonical backoff period. Used as an initial value in the exponential case , and

      * as a minimum value in the uniform case .

      * @return the initial or canonical backoff period in milliseconds ( default 1000 )

     long delay() default 0 ;

      * The maximimum wait (in milliseconds) between retries. If less than the

      * { @link #delay()} then the default of

      * { @value org.springframework.retry.backoff.ExponentialBackOffPolicy#DEFAULT_MAX_INTERVAL}

      * is applied.

      * @return the maximum delay between retries ( default 0 = ignored)

     long maxDelay() default 0 ;

      * If positive, then used as a multiplier for generating the next delay for backoff.

      * @return a multiplier to use to calculate the next backoff delay ( default 0 =

      * ignored)

     double multiplier() default 0 ;

      * An expression evaluating to the canonical backoff period. Used as an initial value

      * in the exponential case , and as a minimum value in the uniform case . Overrides

      * { @link #delay()}.

      * @return the initial or canonical backoff period in milliseconds.

      * @since 1.2

     String delayExpression() default "" ;

      * An expression evaluating to the maximimum wait (in milliseconds) between retries.

      * If less than the { @link #delay()} then the default of

      * is applied. Overrides { @link #maxDelay()}

     String maxDelayExpression() default "" ;

      * Evaluates to a vaule used as a multiplier for generating the next delay for

      * backoff. Overrides { @link #multiplier()}.

      * @return a multiplier expression to use to calculate the next backoff delay ( default

      * 0 = ignored)

     String multiplierExpression() default "" ;

      * In the exponential case ({ @link #multiplier()} &gt; 0 ) set this to true to have the

      * backoff delays randomized, so that the maximum delay is multiplier times the

      * previous delay and the distribution is uniform between the two values.

      * @return the flag to signal randomization is required ( default false )

     boolean random() default false ;

}

package org.example;

import org.junit.jupiter.api.Test;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest

class RetryServiceTest {

     @Autowired

     private RetryService retryService;

     @Test

     void testService1() throws IllegalAccessException {

         retryService.service1();

     }

}

java.lang.IllegalAccessException: manual exception

     at org.example.RetryService.service1(RetryService.java: 19 )

     at org.example.RetryService$$FastClassBySpringCGLIB$$c0995ddb.invoke(<generated>)

     at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java: 218 )

     at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java: 769 )

     at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java: 163 )

     at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.proceed(CglibAopProxy.java: 747 )

     at org.springframework.retry.interceptor.RetryOperationsInterceptor$ 1 .doWithRetry(RetryOperationsInterceptor.java: 91 )

     at org.springframework.retry.support.RetryTemplate.doExecute(RetryTemplate.java: 287 )

     at org.springframework.retry.support.RetryTemplate.execute(RetryTemplate.java: 164 )

     at org.springframework.retry.interceptor.RetryOperationsInterceptor.invoke(RetryOperationsInterceptor.java: 118 )

     at org.springframework.retry.annotation.AnnotationAwareRetryOperationsInterceptor.invoke(AnnotationAwareRetryOperationsInterceptor.java: 153 )

     at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java: 186 )

     at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java: 689 )

     at org.example.RetryService$$EnhancerBySpringCGLIB$$499afa1d.service1(<generated>)

     at org.example.RetryServiceTest.testService1(RetryServiceTest.java: 16 )

     at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

     at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java: 62 )

     at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java: 43 )

     at java.base/java.lang.reflect.Method.invoke(Method.java: 566 )

     at org.junit.platform测试数据mons.util.ReflectionUtils.invokeMethod(ReflectionUtils.java: 675 )

     at org.junit.jupiter.engine.execution.MethodInvocation.proceed(MethodInvocation.java: 60 )

     at org.junit.jupiter.engine.execution.InvocationInterceptorChain$ValidatingInvocation.proceed(InvocationInterceptorChain.java: 125 )

     at org.junit.jupiter.engine.extension.TimeoutExtension.intercept(TimeoutExtension.java: 132 )

     at org.junit.jupiter.engine.extension.TimeoutExtension.interceptTestableMethod(TimeoutExtension.java: 124 )

     at org.junit.jupiter.engine.extension.TimeoutExtension.interceptTestMethod(TimeoutExtension.java: 74 )

     at org.junit.jupiter.engine.execution.ExecutableInvoker$ReflectiveInterceptorCall.lambda$ofVoidMethod$ 0 (ExecutableInvoker.java: 115 )

     at org.junit.jupiter.engine.execution.ExecutableInvoker.lambda$invoke$ 0 (ExecutableInvoker.java: 105 )

     at org.junit.jupiter.engine.execution.InvocationInterceptorChain$InterceptedInvocation.proceed(InvocationInterceptorChain.java: 104 )

     at org.junit.jupiter.engine.execution.InvocationInterceptorChain.proceed(InvocationInterceptorChain.java: 62 )

     at org.junit.jupiter.engine.execution.InvocationInterceptorChain.chainAndInvoke(InvocationInterceptorChain.java: 43 )

     at org.junit.jupiter.engine.execution.InvocationInterceptorChain.invoke(InvocationInterceptorChain.java: 35 )

     at org.junit.jupiter.engine.execution.ExecutableInvoker.invoke(ExecutableInvoker.java: 104 )

     at org.junit.jupiter.engine.execution.ExecutableInvoker.invoke(ExecutableInvoker.java: 98 )

     at org.junit.jupiter.engine.descriptor.TestMethodTestDescriptor.lambda$invokeTestMethod$ 6 (TestMethodTestDescriptor.java: 202 )

     at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java: 73 )

     at org.junit.jupiter.engine.descriptor.TestMethodTestDescriptor.invokeTestMethod(TestMethodTestDescriptor.java: 198 )

     at org.junit.jupiter.engine.descriptor.TestMethodTestDescriptor.execute(TestMethodTestDescriptor.java: 135 )

     at org.junit.jupiter.engine.descriptor.TestMethodTestDescriptor.execute(TestMethodTestDescriptor.java: 69 )

     at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$ 5 (NodeTestTask.java: 135 )

     at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$ 7 (NodeTestTask.java: 125 )

     at org.junit.platform.engine.support.hierarchical.Node.around(Node.java: 135 )

     at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$ 8 (NodeTestTask.java: 123 )

     at org.junit.platform.engine.support.hierarchical.NodeTestTask.executeRecursively(NodeTestTask.java: 122 )

     at org.junit.platform.engine.support.hierarchical.NodeTestTask.execute(NodeTestTask.java: 80 )

     at java.base/java.util.ArrayList.forEach(ArrayList.java: 1540 )

     at org.junit.platform.engine.support.hierarchical.SameThreadHierarchicalTestExecutorService.invokeAll(SameThreadHierarchicalTestExecutorService.java: 38 )

     at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$ 5 (NodeTestTask.java: 139 )

     at org.junit.platform.engine.support.hierarchical.SameThreadHierarchicalTestExecutorService.submit(SameThreadHierarchicalTestExecutorService.java: 32 )

     at org.junit.platform.engine.support.hierarchical.HierarchicalTestExecutor.execute(HierarchicalTestExecutor.java: 57 )

     at org.junit.platform.engine.support.hierarchical.HierarchicalTestEngine.execute(HierarchicalTestEngine.java: 51 )

     at org.junit.platform.launcher.core.DefaultLauncher.execute(DefaultLauncher.java: 229 )

     at org.junit.platform.launcher.core.DefaultLauncher.lambda$execute$ 6 (DefaultLauncher.java: 197 )

     at org.junit.platform.launcher.core.DefaultLauncher.withInterceptedStreams(DefaultLauncher.java: 211 )

     at org.junit.platform.launcher.core.DefaultLauncher.execute(DefaultLauncher.java: 191 )

     at org.junit.platform.launcher.core.DefaultLauncher.execute(DefaultLauncher.java: 128 )

     at com.intellij.junit5.JUnit5IdeaTestRunner.startRunnerWithArgs(JUnit5IdeaTestRunner.java: 71 )

     at com.intellij.rt.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java: 33 )

     at com.intellij.rt.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java: 220 )

     at com.intellij.rt.junit.JUnitStarter.main(JUnitStarter.java: 53 )

@Retryable (include = IllegalAccessException. class , maxAttempts = 5 )

public void service2() throws IllegalAccessException {

     log.info( "do something... {}" , LocalDateTime.now());

     throw new IllegalAccessException( "manual exception" );

}

@Retryable (value = IllegalAccessException. class , maxAttemptsExpression = "${maxAttempts}" )

public void service3() throws IllegalAccessException {

     log.info( "do something... {}" , LocalDateTime.now());

     throw new IllegalAccessException( "manual exception" );

}

maxAttempts: 4

@Retryable (value = IllegalAccessException. class , maxAttemptsExpression = "#{1+1}" )

public void service3_1() throws IllegalAccessException {

     log.info( "do something... {}" , LocalDateTime.now());

     throw new IllegalAccessException( "manual exception" );

}

@Retryable (value = IllegalAccessException. class , maxAttemptsExpression = "#{${maxAttempts}}" ) //效果和上面的一样

public void service3_2() throws IllegalAccessException {

     log.info( "do something... {}" , LocalDateTime.now());

     throw new IllegalAccessException( "manual exception" );

}

@Retryable (value = IllegalAccessException. class , exceptionExpression = "message.contains('test')" )

public void service4(String exceptionMessage) throws IllegalAccessException {

     log.info( "do something... {}" , LocalDateTime.now());

     throw new IllegalAccessException(exceptionMessage);

}

     @Retryable (value = IllegalAccessException. class , exceptionExpression = "#{message.contains('test')}" )

public void service4_3(String exceptionMessage) throws IllegalAccessException {

     log.info( "do something... {}" , LocalDateTime.now());

     throw new IllegalAccessException(exceptionMessage);

}

<dependency>

     <groupId>org.springframework.retry</groupId>

     <artifactId>spring-retry</artifactId>

     <version> 1.3 . 0 </version>

</dependency>

@Retryable (value = IllegalAccessException. class , exceptionExpression = "#{@retryService.checkException(#root)}" )

    public void service5(String exceptionMessage) throws IllegalAccessException {

        log.info( "do something... {}" , LocalDateTime.now());

        throw new IllegalAccessException(exceptionMessage);

    }

    @Retryable (value = IllegalAccessException. class , exceptionExpression = "@retryService.checkException(#root)" )

    public void service5_1(String exceptionMessage) throws IllegalAccessException {

    public boolean checkException(Exception e) {

        log.error( "error message:{}" , e.getMessage());

        return true ; //返回true的话表明会执行重试，如果返回false则不会执行重试

@Retryable (exceptionExpression = "#{#root instanceof T(java.lang.IllegalAccessException)}" ) //判断exception的类型

     public void service5_2(String exceptionMessage) {

         log.info( "do something... {}" , LocalDateTime.now());

         throw new NullPointerException(exceptionMessage);

     }

     @Retryable (exceptionExpression = "#root instanceof T(java.lang.IllegalAccessException)" )

     public void service5_3(String exceptionMessage) {

         log.info( "do something... {}" , LocalDateTime.now());

         throw new NullPointerException(exceptionMessage);

     }

@Retryable (exceptionExpression = "myMessage.contains('test')" ) //查看自定义的MyException中的myMessage的值是否包含test字符串

    public void service5_4(String exceptionMessage) throws MyException {

        log.info( "do something... {}" , LocalDateTime.now());

        throw new MyException(exceptionMessage); //自定义的exception

    }

    @Retryable (exceptionExpression = "#root.myMessage.contains('test')" )  //和上面service5_4方法的效果一样

    public void service5_5(String exceptionMessage) throws MyException {

        log.info( "do something... {}" , LocalDateTime.now());

        throw new MyException(exceptionMessage);

    }

package org.example;

import lombok.Getter;

import lombok.Setter;

@Getter

@Setter

public class MyException extends Exception {

     private String myMessage;

     public MyException(String myMessage) {

         this .myMessage = myMessage;

     }

}

@Retryable (exclude = MyException. class )

    public void service6(String exceptionMessage) throws MyException {

        log.info( "do something... {}" , LocalDateTime.now());

        throw new MyException(exceptionMessage);

    }

@Retryable (value = IllegalAccessException. class ,

             backoff = @Backoff (value = 2000 ))

     public void service7() throws IllegalAccessException {

         log.info( "do something... {}" , LocalDateTime.now());

         throw new IllegalAccessException();

     }

@Retryable (value = IllegalAccessException. class ,

             backoff = @Backoff (value = 2000 ,delay = 500 ))

     public void service8() throws IllegalAccessException {

         log.info( "do something... {}" , LocalDateTime.now());

         throw new IllegalAccessException();

     }

@Retryable (value = IllegalAccessException. class ,maxAttempts = 4 ,

             backoff = @Backoff (delay = 2000 , multiplier = 2 ))

     public void service9() throws IllegalAccessException {

         log.info( "do something... {}" , LocalDateTime.now());

         throw new IllegalAccessException();

     }

@Retryable (value = IllegalAccessException. class ,maxAttempts = 4 ,

             backoff = @Backoff (delay = 2000 , multiplier = 2 ,maxDelay = 5000 ))

     public void service10() throws IllegalAccessException {

         log.info( "do something... {}" , LocalDateTime.now());

         throw new IllegalAccessException();

     }

@Retryable (value = IllegalAccessException. class )

     public void service11() throws IllegalAccessException {

         log.info( "do something... {}" , LocalDateTime.now());

         throw new IllegalAccessException();

     }

     @Recover

     public void recover11(IllegalAccessException e) {

         log.info( "service retry after Recover => {}" , e.getMessage());

     //=========================

     @Retryable (value = ArithmeticException. class )

     public int service12() throws IllegalAccessException {

         return 1 / 0 ;

     public int recover12(ArithmeticException e) {

         return 0 ;

     public int service13(String message) throws IllegalAccessException {

         log.info( "do something... {},{}" , message, LocalDateTime.now());

     public int recover13(ArithmeticException e, String message) {

         log.info( "{},service retry after Recover => {}" , message, e.getMessage());

// openTimeout时间范围内失败maxAttempts次数后，熔断打开resetTimeout时长

     @CircuitBreaker (openTimeout = 1000 , resetTimeout = 3000 , value = NullPointerException. class )

     public void circuitBreaker( int num) {

         log.info( " 进入断路器方法num={}" , num);

         if (num > 8 ) return ;

         Integer n = null ;

         System.err.println( 1 / n);

     }

     @Recover

     public void recover(NullPointerException e) {

         log.info( "service retry after Recover => {}" , e.getMessage());

     }

@Test

     public void testCircuitBreaker() throws InterruptedException {

         System.err.println( "尝试进入断路器方法，并触发异常..." );

         retryService.circuitBreaker( 1 );

         retryService.circuitBreaker( 1 );

         retryService.circuitBreaker( 9 );

         retryService.circuitBreaker( 9 );

         System.err.println( "在openTimeout 1秒之内重试次数为2次，未达到触发熔断, 断路器依然闭合..." );

         TimeUnit.SECONDS.sleep( 1 );

         System.err.println( "超过openTimeout 1秒之后, 因为未触发熔断，所以重试次数重置，可以正常访问...,继续重试3次方法..." );

         retryService.circuitBreaker( 1 );

         retryService.circuitBreaker( 1 );

         retryService.circuitBreaker( 1 );

         System.err.println( "在openTimeout 1秒之内重试次数为3次，达到触发熔断，不会执行重试，只会执行恢复方法..." );

         retryService.circuitBreaker( 1 );

         TimeUnit.SECONDS.sleep( 2 );

         retryService.circuitBreaker( 9 );

         TimeUnit.SECONDS.sleep( 3 );

         System.err.println( "超过resetTimeout 3秒之后，断路器重新闭合...,可以正常访问" );

         retryService.circuitBreaker( 9 );

         retryService.circuitBreaker( 9 );

         retryService.circuitBreaker( 9 );

         retryService.circuitBreaker( 9 );

         retryService.circuitBreaker( 9 );

     }

package org.example;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.retry.backoff.FixedBackOffPolicy;

import org.springframework.retry.policy.SimpleRetryPolicy;

import org.springframework.retry.support.RetryTemplate;

@Configuration

public class AppConfig {

     @Bean

     public RetryTemplate retryTemplate() {

         RetryTemplate retryTemplate = new RetryTemplate();

         SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy(); //设置重试策略

         retryPolicy.setMaxAttempts( 2 );

         retryTemplate.setRetryPolicy(retryPolicy);

         FixedBackOffPolicy fixedBackOffPolicy = new FixedBackOffPolicy(); //设置退避策略

         fixedBackOffPolicy.setBackOffPeriod(2000L);

         retryTemplate.setBackOffPolicy(fixedBackOffPolicy);

         return retryTemplate;

     }

}

package org.example;

import org.junit.jupiter.api.Test;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.retry.RetryCallback;

import org.springframework.retry.RetryContext;

import org.springframework.retry.support.RetryTemplate;

@SpringBootTest

public class RetryTemplateTest {

     @Autowired

     private RetryTemplate retryTemplate;

     private RetryTemplateService retryTemplateService;

     @Test

     void test1() throws IllegalAccessException {

         retryTemplate.execute( new RetryCallback<Object, IllegalAccessException>() {

             @Override

             public Object doWithRetry(RetryContext context) throws IllegalAccessException {

                  retryTemplateService.service1();

                 return null ;

             }

         });

     }

     void test2() throws IllegalAccessException {

                 retryTemplateService.service1();

         }, new RecoveryCallback<Object>() {

             public Object recover(RetryContext context) throws Exception {

                 log.info( "RecoveryCallback...." );

}

package org.springframework.retry;

import org.springframework.retry.support.DefaultRetryState;

/**

  * Defines the basic set of operations implemented by {@link RetryOperations} to execute

  * operations with configurable retry behaviour.

  *

  * @author Rob Harrop

  * @author Dave Syer

  */

public interface RetryOperations {

     /**

      * Execute the supplied {@link RetryCallback} with the configured retry semantics. See

      * implementations for configuration details.

      * @param <T> the return value

      * @param retryCallback the {@link RetryCallback}

      * @param <E> the exception to throw

      * @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

      */

     <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.

      * @param recoveryCallback the { @link RecoveryCallback}

      * @param retryCallback the { @link RetryCallback} { @link RecoveryCallback} upon

      * @param <T> the type to return

      * @param <E> the type of the exception

      * @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 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 retryState the { @link RetryState}

      * @param <T> the type of the return value

      * @param <E> the type of the exception to return

      * @throws E any { @link Exception} raised by the { @link RecoveryCallback}.

      * @throws ExhaustedRetryException if the last attempt for this state has already been

      * reached

     <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 <T> the return value type

      * @param <E> the exception type

      * @see #execute(RetryCallback, RetryState)

      * @throws E any { @link Exception} raised by the { @link RecoveryCallback} upon

     <T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback, RecoveryCallback<T> recoveryCallback,

             RetryState retryState) throws E;

}

package org.springframework.retry;

import java.io.Serializable;

/**

  * A {@link RetryPolicy} is responsible for allocating and managing resources needed by

  * {@link RetryOperations}. The {@link RetryPolicy} allows retry operations to be aware of

  * their context. Context can be internal to the retry framework, e.g. to support nested

  * retries. Context can also be external, and the {@link RetryPolicy} provides a uniform

  * API for a range of different platforms for the external context.

  *

  * @author Dave Syer

  */

public interface RetryPolicy extends Serializable {

     /**

      * @param context the current retry status

      * @return true if the operation can proceed

      */

     boolean canRetry(RetryContext context);

      * Acquire resources needed for the retry operation. The callback is passed in so that

      * marker interfaces can be used and a manager can collaborate with the callback to

      * set up some state in the status token.

      * @param parent the parent context if we are in a nested retry.

      * @return a { @link RetryContext} object specific to this policy.

      *

     RetryContext open(RetryContext parent);

      * @param context a retry status created by the { @link #open(RetryContext)} method of

      * this policy.

     void close(RetryContext context);

      * Called once per retry attempt, after the callback fails.

      * @param context the current status object.

      * @param throwable the exception to throw

     void registerThrowable(RetryContext context, Throwable throwable);

}

package org.springframework.retry;

/**

  * Interface for listener that can be used to add behaviour to a retry. Implementations of

  * {@link RetryOperations} can chose to issue callbacks to an interceptor during the retry

  * lifecycle.

  *

  * @author Dave Syer

  */

public interface RetryListener {

     /**

      * Called before the first attempt in a retry. For instance, implementers can set up

      * state that is needed by the policies in the {@link RetryOperations}. The whole

      * retry can be vetoed by returning false from this method, in which case a

      * {@link TerminatedRetryException} will be thrown.

      * @param <T> the type of object returned by the callback

      * @param <E> the type of exception it declares may be thrown

      * @param context the current {@link RetryContext}.

      * @param callback the current {@link RetryCallback}.

      * @return true if the retry should proceed.

      */

     <T, E extends Throwable> boolean open(RetryContext context, RetryCallback<T, E> callback);

      * Called after the final attempt (successful or not). Allow the interceptor to clean

      * up any resource it is holding before control returns to the retry caller.

      * @param throwable the last exception that was thrown by the callback.

      * @param <E> the exception type

      * @param <T> the return value

     <T, E extends Throwable> void close(RetryContext context, RetryCallback<T, E> callback, Throwable throwable);

      * Called after every unsuccessful attempt at a retry.

      * @param <E> the exception to throw

     <T, E extends Throwable> void onError(RetryContext context, RetryCallback<T, E> callback, Throwable throwable);

}

package org.example;

import lombok.extern.slf4j.Slf4j;

import org.springframework.retry.RetryCallback;

import org.springframework.retry.RetryContext;

import org.springframework.retry.listener.RetryListenerSupport;

@Slf4j

public class DefaultListenerSupport extends RetryListenerSupport {

     @Override

     public <T, E extends Throwable> void close(RetryContext context,

                                                RetryCallback<T, E> callback, Throwable throwable) {

         log.info( "onClose" );

         super .close(context, callback, throwable);

     }

     public <T, E extends Throwable> void onError(RetryContext context,

                                                  RetryCallback<T, E> callback, Throwable throwable) {

         log.info( "onError" );

         super .onError(context, callback, throwable);

     public <T, E extends Throwable> boolean open(RetryContext context,

                                                  RetryCallback<T, E> callback) {

         log.info( "onOpen" );

         return super .open(context, callback);

}

package org.example;

import lombok.extern.slf4j.Slf4j;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.retry.backoff.FixedBackOffPolicy;

import org.springframework.retry.policy.SimpleRetryPolicy;

import org.springframework.retry.support.RetryTemplate;

@Configuration

@Slf4j

public class AppConfig {

     @Bean

     public RetryTemplate retryTemplate() {

         RetryTemplate retryTemplate = new RetryTemplate();

         SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy(); //设置重试策略

         retryPolicy.setMaxAttempts( 2 );

         retryTemplate.setRetryPolicy(retryPolicy);

         FixedBackOffPolicy fixedBackOffPolicy = new FixedBackOffPolicy(); //设置退避策略

         fixedBackOffPolicy.setBackOffPeriod(2000L);

         retryTemplate.setBackOffPolicy(fixedBackOffPolicy);

         retryTemplate.registerListener( new DefaultListenerSupport()); //设置retryListener

         return retryTemplate;

     }

}