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()} > 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.commons.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;
    }
}