spring retry是从spring batch独立出来的一个能功能,主要实现了重试和熔断。对于重试是有场景限制的,不是什么场景都适合重试,比如参数校验不合法、写操作等(要考虑写是否幂等)都不适合重试。远程调用超时、网络突然中断可以重试。在微服务治理框架中,通常都有自己的重试与超时配置,比如dubbo可以设置retries=1,timeout=500调用失败只重试1次,超过500ms调用仍未返回则调用失败。在spring retry中可以指定需要重试的异常类型,并设置每次重试的间隔以及如果重试失败是继续重试还是熔断(停止重试)。
设计与实现
retryoperations
定义重试的api,retrytemplate
是api的模板模式实现,实现了重试和熔断。提供的api如下:
1
2
3
4
|
public interface retryoperations { <t, e extends throwable>t execute(retrycallback<t, e>retrycallback) throws e; } // 其他api已省略 |
retrycallback
定义了需要执行重试的操作,定义好操作后,就是如何重试的问题了。retrytemplate
通过制定不同的重试策略来执行如何重试的逻辑。默认的重试策略是simpleretryplicy
,也就是会重试3次。重试第1次如果成功后面就不会继续重试了。那么如果3尺都重试失败了呢?流程结束或者返回兜底结果。要返回兜底结果需要配置recoveycallback
,从名字可以看出这是一个兜底回调接口,也就是重试失败后执行的逻辑。除了simpleretrypolicy
还有其他重试策略,先来看下retrypolicy
接口:
1
2
3
4
5
6
|
public interface retrypolicy extends serializable { boolean canretry(retrycontext context); retrycontext open(retrycontext parent); void close(retrycontext context); void registerthrowable(retrycontext context, throwable throwable); } |
canretry
在每次重试的时候调用,是否可以继续重试的判断条件
open
重试开始前调用,会创建一个重试上下文到retrycontext
,保存重试的堆栈等信息
registerthrowable
每次重试异常时调用(有异常会继续重试)
以simpleretrypolicy
为例,当重试次数达到3(默认3次)停止重试,重试次数保存在重试上下文中。
提供如下重试策略实现:
- neverretrypolicy:只允许调用retrycallback一次,不允许重试
- alwaysretrypolicy:允许无限重试,直到成功,此方式逻辑不当会导致死循环
- simpleretrypolicy:固定次数重试策略,默认重试最大次数为3次,retrytemplate默认使用的策略
- timeoutretrypolicy:超时时间重试策略,默认超时时间为1秒,在指定的超时时间内允许重试
- exceptionclassifierretrypolicy:设置不同异常的重试策略,类似组合重试策略,区别在于这里只区分不同异常的重试
- circuitbreakerretrypolicy:有熔断功能的重试策略,需设置3个参数opentimeout、resettimeout和delegate
- compositeretrypolicy:组合重试策略,有两种组合方式,乐观组合重试策略是指只要有一个策略允许重试即可以,悲观组合重试策略是指只要有一个策略不允许重试即可以,但不管哪种组合方式,组合中的每一个策略都会执行
重试回退策略,指的是每次重试是立即重试还是等待一段时间后重试。默认情况下是立即重试,如果需要配置等待一段时间后重试则需要指定回退策略backoffretrypolicy
。backoffretrypolicy有如下实现:
- nobackoffpolicy:无退避算法策略,每次重试时立即重试
- fixedbackoffpolicy:固定时间的退避策略,需设置参数sleeper和backoffperiod,sleeper指定等待策略,默认是thread.sleep,即线程休眠,backoffperiod指定休眠时间,默认1秒
- uniformrandombackoffpolicy:随机时间退避策略,需设置sleeper、minbackoffperiod和maxbackoffperiod,该策略在[minbackoffperiod,maxbackoffperiod之间取一个随机休眠时间,minbackoffperiod默认500毫秒,maxbackoffperiod默认1500毫秒
- exponentialbackoffpolicy:指数退避策略,需设置参数sleeper、initialinterval、maxinterval和multiplier,initialinterval指定初始休眠时间,默认100毫秒,maxinterval指定最大休眠时间,默认30秒,multiplier指定乘数,即下一次休眠时间为当前休眠时间*multiplier
- exponentialrandombackoffpolicy:随机指数退避策略,引入随机乘数可以实现随机乘数回退
有状态重试 or 无状态重试
所谓无状态重试是指重试在一个线程上下文中完成的重试,反之不在一个线程上下文完成重试的就是有状态重试。之前的simpleretrypolicy
就属于无状态重试,因为重试是在一个循环中完成的。那么什么会后会出现或者说需要有状态重试呢?通常有两种情况:事务回滚和熔断。
数据库操作异常dataaccessexception,不能执行重试,而如果抛出其他异常可以重试。
熔断的意思不在当前循环中处理重试,而是全局重试模式(不是线程上下文)。熔断会跳出循环,那么必然会丢失线程上下文的堆栈信息。那么肯定需要一种“全局模式”保存这种信息,目前的实现放在一个cache(map实现的)中,下次从缓存中获取就能继续重试了。
quick start
在需要执行重试的类上使用@enableretry
,如果设置了proxytargetclass=true
这使用cglib动态代理:
1
2
3
4
5
6
|
@configuration @enableretry (proxytargetclass = true ) @component public class retryexamples { } |
基于最大重试次数策略的重试,如果重试了3次仍然抛出异常则停止重试,执行兜底回调,所以最后的输出结果是integer.max_value
:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
private void retryexample3() throws exception { retrytemplate retrytemplate = new retrytemplate(); simpleretrypolicy simpleretrypolicy = new simpleretrypolicy(); simpleretrypolicy.setmaxattempts( 3 ); retrytemplate.setretrypolicy(simpleretrypolicy); integer result = retrytemplate.execute( new retrycallback<integer, exception>() { int i = 0 ; // 重试操作 @override public integer dowithretry(retrycontext retrycontext) throws exception { log.info( "retry count: {}" , retrycontext.getretrycount()); return len(i++); } }, new recoverycallback<integer>() { //兜底回调 @override public integer recover(retrycontext retrycontext) throws exception { log.info( "after retry: {}, recovery method called!" , retrycontext.getretrycount()); return integer.max_value; } }); log.info( "final result: {}" , result); } private int len( int i) throws exception { if (i < 10 ) throw new exception(i + " le 10" ); return i; } |
下面介绍如何使用熔断重试策略模式(circuitbreakerretrypolicy),需要设置如下三个参数:
- delegate:传入retrypolicy(每个retrypolicy实现都有自己的重试策略实现),是真正判断是否重试的策略,当重试失败时,则执行熔断策略
- opentimeout:openwindow,配置熔断器电路打开的超时时间,当超过opentimeout之后熔断器电路变成半打开状态(只要有一次重试成功,则闭合电路)
- resettimeout:timeout,配置重置熔断器重新闭合的超时时间
断路器开闭实现判断:
- 当重试失败,且在熔断器打开时间窗口[0,openwindow) 内,立即熔断
- 当重试失败,且超过timeout,熔断器电路重新闭合
- 在熔断器半打开状态[openwindow, timeout] 时,只要重试成功则重置上下文,断路器闭合
测试代码如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
retrytemplate template = new retrytemplate(); circuitbreakerretrypolicy retrypolicy = new circuitbreakerretrypolicy( new simpleretrypolicy( 3 )); retrypolicy.setopentimeout( 5000 ); retrypolicy.setresettimeout( 20000 ); template.setretrypolicy(retrypolicy); for ( int i = 0 ; i < 10 ; i++) { //thread.sleep(100); try { object key = "circuit" ; boolean isforcerefresh = false ; retrystate state = new defaultretrystate(key, isforcerefresh); string result = template.execute( new retrycallback<string, runtimeexception>() { @override public string dowithretry(retrycontext context) throws runtimeexception { log.info( "retry count: {}" , context.getretrycount()); throw new runtimeexception( "timeout" ); } }, new recoverycallback<string>() { @override public string recover(retrycontext context) throws exception { return "default" ; } }, state); log.info( "result: {}" , result); } catch (exception e) { system.out.println(e); } } |
这里由于设置了isforcerefresh = false
,则key = "circuit"
的值(也就是retrycontext)会从缓存中获取,所以当重试失败且满足this.time < this.openwindow
发生熔断的时候,后面仍然可以继续已全局模式实现重试(拿到的retrycontext
是同一个)。
注解开发
如果每次有重试需求的时候都写一个retrytemplate
太臃肿了,使用注解可以大大简化开发,减少重复代码。下面是一个使用注解实现的最大重试策略的重试:
1
2
3
4
5
6
7
8
9
10
|
@retryable (value = sqldataexception. class , backoff = @backoff (value = 0l)) public string service3() throws sqldataexception { log.info( "service3 open" ); throw new sqldataexception(); } @recover public string recover(sqldataexception ne) { return "sqldataexception recover" ; } |
注解包括:
@enableretry
@retryable
@recover
@backoff
@circuitbreaker
@enableretry:能否重试,proxytargetclass属性为true时(默认false),使用cglib代理
@retryable:注解需要被重试的方法
- include 指定处理的异常类。默认为空
- exclude指定不需要处理的异常。默认为空
- vaue指定要重试的异常。默认为空
- maxattempts 最大重试次数。默认3次
- backoff 重试等待策略。默认使用@backoff注解
@backoff:重试回退策略(立即重试还是等待一会再重试)
- 不设置参数时,默认使用fixedbackoffpolicy,重试等待1000ms
- 只设置delay()属性时,使用fixedbackoffpolicy,重试等待指定的毫秒数
- 当设置delay()和maxdealy()属性时,重试等待在这两个值之间均态分布
- 使用delay(),maxdealy()和multiplier()属性时,使用exponentialbackoffpolicy
- 当设置multiplier()属性不等于0时,同时也设置了random()属性时,使用exponentialrandombackoffpolicy
@recover: 用于方法。用于@retryable失败时的“兜底”处理方法。 @recover注释的方法必须要与@retryable注解的方法“签名”保持一致,第一入参为要重试的异常,其他参数与@retryable保持一致,返回值也要一样,否则无法执行!
@circuitbreaker:用于方法,实现熔断模式。
- include 指定处理的异常类。默认为空
- exclude指定不需要处理的异常。默认为空
- vaue指定要重试的异常。默认为空
- maxattempts 最大重试次数。默认3次
- opentimeout 配置熔断器打开的超时时间,默认5s,当超过opentimeout之后熔断器电路变成半打开状态(只要有一次重试成功,则闭合电路)
- resettimeout 配置熔断器重新闭合的超时时间,默认20s,超过这个时间断路器关闭
更多的例子欢迎到我的github(https://github.com/happyxiaofan/springboot-learning-example) star。谢谢
以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持服务器之家。
原文链接:https://blog.csdn.net/u011116672/article/details/77823867