• 微信公众号:美女很有趣。 工作之余,放松一下,关注即送10G+美女照片!

初探SpringRetry机制

开发技术 开发技术 4小时前 1次浏览

重试是在网络通讯中非常重要的概念,尤其是在微服务体系内重试显得格外重要。常见的场景是当遇到网络抖动造成的请求失败时,可以按照业务的补偿需求来制定重试策略。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方法,这里可以从这个入口方法来了解代码的核心。

  1. 初始化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

  1. 调用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的机会,如果理解拦截器的思想的话,这点应该很容易理解。

  1. 获取和启动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当中

  2. 执行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;
    				}
    			}
    
    

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

    1. 首先是用一个循环执行RetryCallback的回调内容,此处循环条件有两个:
      • 根据RetryPolicy接口里的canRetry方法的返回值,比如说TimeoutPolicy 里控制retry的条件是(System.currentTimeMillis() - start) <= timeout
      • 还有一个是RetryContext中的isExhaustedOnly()方法,这个方法是一个“筋疲力尽”的标志如果为true那么也会停止重试的循环
    2. 当出现异常时
      • 首先会调用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对象

程序员灯塔
转载请注明原文链接:初探SpringRetry机制
喜欢 (0)