初探SpringRetry机制

重试是在网络通讯中非常重要的概念，尤其是在微服务体系内重试显得格外重要。常见的场景是当遇到网络抖动造成的请求失败时，可以按照业务的补偿需求来制定重试策略。Spring框架提供了SpringRetry能让我们在项目工程中很方便的使用重试。这里我主要试着分析一下在Spring框架的各个核心模块里如何集成是使用SpringRetry。

1. SpringRetry的快速上手示例

首先我们引入springRetry的依赖: implementation group: 'org.springframework.retry', name: 'spring-retry',version:'1.2.5.RELEASE'，同时已SpringBoot作为项目示例基础：

    @Bean
    public RetryTemplate retryTemplate() {
        RetryTemplate retryTemplate = new RetryTemplate();
        TimeoutRetryPolicy timeoutRetryPolicy = new TimeoutRetryPolicy(); //定义基于时间超时的重试策略
        timeoutRetryPolicy.setTimeout(3000L);
        retryTemplate.setRetryPolicy(timeoutRetryPolicy);
        return retryTemplate;

    }


   public static void main(String[]args){
     
        ConfigurableApplicationContext applicationContext = SpringApplication.run(RetryDemo.class, args);
        RetryTemplate retryTemplate = applicationContext.getBean(RetryTemplate.class);
        retryTemplate.execute(new RetryCallback<Object, Throwable>() { //2 重试执行的代码块
            private int index = 1;

            @Override
            public Object doWithRetry(RetryContext context) throws Throwable {
                System.out.println("第" + index + "次执行");
                index++;
                System.out.println(1 / 0);//3  重试代码块里模拟异常的操作
                return null;
            }
        });
     
   }

上面的代码示例展示了SpringRetry的最基本使用方式，首先在代码1处先定义了RetryTemplate的Bean，同时定义了重试的策略配置，等会说一下这个RetryPolicy接口。在此处定义TimeoutRetryPolicy主要控制重试多长时间，此处设置3秒。3秒后没有成功的话结束重试。在代码2处，使用RetryTemplate的execute方法来执行重试的回调，如果在回调中出现异常则执行重试，因此我们可以把执行重试的代码块放在这里。在代码3处模拟了抛出异常的操作

这里运行的结果:

....
第110823次执行
第110824次执行
第110825次执行
第110826次执行
Exception in thread "main" java.lang.ArithmeticException: / by zero

2. SpringRetry的核心代码

在RetryTemplate里核心方法时exectute方法，这里可以从这个入口方法来了解代码的核心。

初始化RetryContext

	// Allow the retry policy to initialise itself...
		RetryContext context = open(retryPolicy, state);
		if (this.logger.isTraceEnabled()) {
			this.logger.trace("RetryContext retrieved: " + context);
		}

在这里会调用给RetryPolicy接口的open方法，目的是为了初始化RetryContext(重试上下文)，RetryContext可以扩展我们的业务字段，这里我举个例子TimeoutRetryContext中定义了timeout与start属性。LoadBalancedRetryContext中定义了request与serviceInstance

调用RetryListener的onOpen方法



// Give clients a chance to enhance the context...
			boolean running = doOpenInterceptors(retryCallback, context);


private <T, E extends Throwable> boolean doOpenInterceptors(
			RetryCallback<T, E> callback, RetryContext context) {

		boolean result = true;

		for (RetryListener listener : this.listeners) {
			result = result && listener.open(context, callback);
		}

		return result;

	}

在这里单行注释已经明明白白的写出了，我们可以利用RetryListener的来给客户端一个机会增强RetryContext的机会，如果理解拦截器的思想的话，这点应该很容易理解。

获取和启动BackOffContext

// Get or Start the backoff context...
			BackOffContext backOffContext = null;
			Object resource = context.getAttribute("backOffContext");

			if (resource instanceof BackOffContext) {
				backOffContext = (BackOffContext) resource;
			}

			if (backOffContext == null) {
				backOffContext = backOffPolicy.start(context);
				if (backOffContext != null) {
					context.setAttribute("backOffContext", backOffContext);
				}
			}

先从RetryContext中获取backOffContext,如果没有会调用backOffPolicy的start方法。该方法会返回BackOffContext对象不等于null的情况下把此对象放在RetryContext当中

执行RetryCallback的代码回调

	/*
			 * We allow the whole loop to be skipped if the policy or context already
			 * forbid the first try. This is used in the case of external retry to allow a
			 * recovery in handleRetryExhausted without the callback processing (which
			 * would throw an exception).
			 */
			while (canRetry(retryPolicy, context) && !context.isExhaustedOnly()) {

				try {
					if (this.logger.isDebugEnabled()) {
						this.logger.debug("Retry: count=" + context.getRetryCount());
					}
					// Reset the last exception, so if we are successful
					// the close interceptors will not think we failed...
					lastException = null;
					return retryCallback.doWithRetry(context);
				}
				catch (Throwable e) {

					lastException = e;

					try {
						registerThrowable(retryPolicy, state, context, e);
					}
					catch (Exception ex) {
						throw new TerminatedRetryException("Could not register throwable",
								ex);
					}
					finally {
						doOnErrorInterceptors(retryCallback, context, e);
					}

					if (canRetry(retryPolicy, context) && !context.isExhaustedOnly()) {
						try {
							backOffPolicy.backOff(backOffContext);
						}
						catch (BackOffInterruptedException ex) {
							lastException = e;
							// back off was prevented by another thread - fail the retry
							if (this.logger.isDebugEnabled()) {
								this.logger
										.debug("Abort retry because interrupted: count="
												+ context.getRetryCount());
							}
							throw ex;
						}
					}

					if (this.logger.isDebugEnabled()) {
						this.logger.debug(
								"Checking for rethrow: count=" + context.getRetryCount());
					}

					if (shouldRethrow(retryPolicy, context, state)) {
						if (this.logger.isDebugEnabled()) {
							this.logger.debug("Rethrow in retry for policy: count="
									+ context.getRetryCount());
						}
						throw RetryTemplate.<E>wrapIfNecessary(e);
					}

				}

				/*
				 * A stateful attempt that can retry may rethrow the exception before now,
				 * but if we get this far in a stateful retry there's a reason for it,
				 * like a circuit breaker or a rollback classifier.
				 */
				if (state != null && context.hasAttribute(GLOBAL_STATE)) {
					break;
				}
			}

此处代码是重试代码的执行核心:

首先是用一个循环执行RetryCallback的回调内容，此处循环条件有两个：
- 根据RetryPolicy接口里的canRetry方法的返回值，比如说TimeoutPolicy 里控制retry的条件是(System.currentTimeMillis() - start) <= timeout
- 还有一个是RetryContext中的isExhaustedOnly()方法，这个方法是一个“筋疲力尽”的标志如果为true那么也会停止重试的循环
当出现异常时
- 首先会调用RetryPolicy里的registerThrowable的方法。然后当RetryState不为null时会把RetryContext对象放入RetryContextCache中保存。
- 依次循环调用RetryListener里的onError方法
- 再次判断重试条件，如果满足的情况下，会调用BackoffPolicy的backoff方法。BackOffPolicy的接口主要用于定义在执行重试时出现异常情况的处理逻辑，举个例子说明：FixedBackOffPolicy重写的backoff方法里可以控制线程休眠让其间隔多长时间进行重试: sleeper.sleep(backOffPeriod) 。
- 调用RetryState的rollbackFor方法的方法来判断当前的异常需不需要回滚，而在该接口的唯一实现类DefaultRetryState里会用Classifier<? super Throwable, Boolean> rollbackClassifier来将Throwable类型转换成Boolean类型，可以在这里定义处理逻辑。如果该方法的返回值为true，将会重新抛出异常

3. SpringRetry的注解式配置

使用注解的方式是SpringRetry中最常见的方式，其实它底层还是aop与前面所说的基本执行流程。对于注解的方式使用起来还是比较简单的。首先我们打上@EnableRetry的注解

@SpringBootApplication
@EnableRetry
public class SpringApplicationProvider {
 	 
  //....
}


    @Retryable(maxAttempts = 2, recover = "recover") 
    public void send() {
        System.out.println("send....");
        System.out.println(1 / 0);
    }

    @Recover
    public void recover(ArithmeticException exception) {
        System.out.println(2 / 1);
    }

可以在需要重试的方法上打上@Retryable ，这个注解有几个常见的属性：

maxAttepts 这个定义了重试的最大次数，默认值是3
recover : 用于定义@Recover修饰的方法名，旨在指定重试失败后用于执行的方法。@Recover修饰的方法参数必须是Throwable的子类，同时返回值必须和@Retryable修饰的返回值相同
stateful：表示重试是有状态的,默认值为false，如果为true则有如下影响: 1.会重新抛出异常 2.执行重试期间，注册当前的重试上下文至缓存
backoff : 这个属性用于收集Backoff的元数据，那么根据文档描述，可以得到以下信息：
- 没有明确设置的情况下，默认值为 1000 毫秒的固定延迟
  只有delay()设置：设置固定的延迟时间进行重试
  当设置delay()和maxDelay() ，延时的值在两个值之间均匀分布
  使用delay() 、 maxDelay()和multiplier()后退指数增长到最大值
  如果设置了random()标志，则从 [1, multiplier-1] 中的均匀分布中为每个延迟选择乘数
- 实际上这个几个属性是控制创建BackOff接口实现类的：
  - 如果multiplier大于0，则创建ExponentialBackOffPolicy对象
  - 如果max > min，则创建UniformRandomBackOffPolicy对象
  - 否则创建FixedBackOffPolicy对象

posted on 2021-07-22 10:32 聂晨阅读(742) 评论(1) 编辑收藏举报