Spring-retry 1.1.4重试功能
在实际项目中，经常需要在某种情况下对调用的方法进行重试，例如超时重试。通过Spring-retry能简化重试功能的实现，并实现更多样的重试操作。
Spring-retry提供的RetryOperations接口，定义如下：
public interface RetryOperations {
T execute(RetryCallback retryCallback) throws E;
T execute(RetryCallback retryCallback, RecoveryCallback recoveryCallback) throws E;
T execute(RetryCallback retryCallback, RecoveryCallback recoveryCallback, RetryState retryState) throws E;
} Spring-retry提供了RetryOperations接口的实现类RetryTemplate。通过RetryTemplate来完成重试，下面是使用RetryTemplate重试的一个简单例子。
public class Main {
public static void main(String[] args) throws Exception {
RetryTemplate template = new RetryTemplate();
TimeoutRetryPolicy policy = new TimeoutRetryPolicy();
template.setRetryPolicy(policy);
String result = template.execute(
new RetryCallback() {
public String doWithRetry(RetryContext arg0) throws Exception {
return "Retry";
}
}
);
System.out.println(result);
}
} 当重试执行完闭，操作还未成为，那么可以通过RecoveryCallback完成一些失败事后处理。
public class Main {
public static void main(String[] args) throws Exception {
RetryTemplate template = new RetryTemplate();
SimpleRetryPolicy policy = new SimpleRetryPolicy();
policy.setMaxAttempts(2);
template.setRetryPolicy(policy);
String result = template.execute(
new RetryCallback() {
public String doWithRetry(RetryContext arg0) throws Exception {
throw new NullPointerException("nullPointerException");
}
}
,
new RecoveryCallback() {
public String recover(RetryContext context) throws Exception {
return "recovery callback";
}
}
);
System.out.println(result);
}
} 一、重试策略
1、SimpleRetryPolicy 策略
该策略定义了对指定的异常进行若干次重试。默认情况下，对Exception异常及其子类重试3次。如果创建SimpleRetryPolicy并指定重试异常map，可以选择性重试或不进行重试。下面的代码定义了对TimeOutException进行重试。
public static void main(String[] args) throws Exception {
RetryTemplate template = new RetryTemplate();
Map, Boolean> maps = new HashMap, Boolean>();
maps.put(TimeoutException.class, true);
SimpleRetryPolicy policy2 = new SimpleRetryPolicy(2, maps);
template.setRetryPolicy(policy2);
new RetryCallback() {
public String doWithRetry(RetryContext arg0) throws Exception {
throw new TimeoutException("TimeoutException");
}
}
,
new RecoveryCallback() {
public String recover(RetryContext context) throws Exception {
return "recovery callback";
}
}
);
System.out.println(result);
} 2、NeverRetryPolicy 策略
执行一次待执行操作，若出现异常后不进行重试。
3、AlwaysRetryPolicy 策略
异常后一直重试直到成功。
4、TimeoutRetryPolicy 策略
在执行execute方法时从open操作开始到调用TimeoutRetryPolicy的canRetry方法这之间所经过的时间。这段时间未超过TimeoutRetryPolicy定义的超时时间，那么执行操作，否则抛出异常。
5、ExceptionClassifierRetryPolicy 策略
根据产生的异常选择重试策略。
Map, RetryPolicy> policyMap = new HashMap, RetryPolicy>();
policyMap.put(TimeoutException.class, new AlwaysRetryPolicy());
policyMap.put(NullPointerException.class, new NeverRetryPolicy());
policy.setPolicyMap(policyMap);
public class Main {
public static void main(String[] args) throws Exception {
RetryTemplate template = new RetryTemplate();
ExceptionClassifierRetryPolicy policy = new ExceptionClassifierRetryPolicy();
Map, RetryPolicy> policyMap = new HashMap, RetryPolicy>();
policyMap.put(TimeoutException.class, new AlwaysRetryPolicy());
policyMap.put(NullPointerException.class, new NeverRetryPolicy());
policy.setPolicyMap(policyMap);
template.setRetryPolicy(policy);
String result = template.execute(
new RetryCallback() {
public String doWithRetry(RetryContext arg0) throws Exception {
if(arg0.getRetryCount() >= 2) {
Thread.sleep(1000);
throw new NullPointerException();
}
throw new TimeoutException("TimeoutException");
}
}
,
new RecoveryCallback() {
public String recover(RetryContext context) throws Exception {
return "recovery callback";
}
}
);
System.out.println(result);
}
}
Classifier exceptionClassifier = new Classifier(){
public RetryPolicy classify(Throwable classifiable) {
if(classifiable instanceof TimeoutException)
return new SimpleRetryPolicy();
return new NeverRetryPolicy();
}
};
policy.setExceptionClassifier(exceptionClassifier); 6、CompositeRetryPolicy 策略
用户指定一组策略，随后根据optimistic选项来确认如何重试。
下面的代码中创建CompositeRetryPolicy策略，并创建了RetryPolicy数组，数组有两个具体策略SimpleRetryPolicy与AlwaysRetryPolicy。当CompositeRetryPolicy设置optimistic为true时，Spring-retry会顺序遍历RetryPolicy[]数组，如果有一个重试策略可重试，例如SimpleRetryPolicy没有达到重试次数，那么就会进行重试。 如果optimistic选项设置为false。那么有一个重试策略无法重试，那么就不进行重试。例如SimpleRetryPolicy达到重试次数不能再重试，而AlwaysRetryPolicy可以重试，那么最终是无法重试的。
public class Main {
public static void main(String[] args) throws Exception {
RetryTemplate template = new RetryTemplate();
CompositeRetryPolicy policy = new CompositeRetryPolicy();
RetryPolicy[] polices = {new SimpleRetryPolicy(), new AlwaysRetryPolicy()};
policy.setPolicies(polices);
policy.setOptimistic(true);
template.setRetryPolicy(policy);
String result = template.execute(
new RetryCallback() {
public String doWithRetry(RetryContext arg0) throws Exception {
if(arg0.getRetryCount() >= 2) {
Thread.sleep(1000);
throw new NullPointerException();
}
throw new TimeoutException("TimeoutException");
}
}
,
new RecoveryCallback() {
public String recover(RetryContext context) throws Exception {
return "recovery callback";
}
}
);
System.out.println(result);
}
} 二、退避(BackOff)策略：
当操作执行失败时，根据设置的重试策略进行重试。通过BackoffPolicy可以设定再次重试的时间间隔。
public interface BackOffPolicy {
BackOffContext start(RetryContext context);
void backOff(BackOffContext backOffContext) throws BackOffInterruptedException;
} 
1、StatelessBackoffPolicy下的3个实现类
1）org.springframework.retry.backoff.FixedBackOffPolicy
在等待一段固定的时间后，再进行重试。默认为1秒。
2）org.springframework.retry.backoff.NoBackOffPolicy
实现了空方法，因此采用次策略，重试不会等待。这也是RetryTemplate采用的默认退避(backOff)策略。
private volatile BackOffPolicy backOffPolicy = new NoBackOffPolicy();均匀随机退避策略，等待时间为 最小退避时间 + [0,最大退避时间 - 最小退避时间)间的一个随机数，如果最大退避时间等于最小退避时间那么等待时间为0。
2、SleepingbackOffPolicy的下的4个实现类
1）org.springframework.retry.backoff.ExponentialBackOffPolicy
指数退避策略 ，每次等待时间为 等待时间 = 等待时间 * N ，即每次等待时间为上一次的N倍。如果等待时间超过最大等待时间，那么以后的等待时间为最大等待时间。
ExponentialBackOffPolicy exponentialBackOffPolicy = new ExponentialBackOffPolicy();
exponentialBackOffPolicy.setInitialInterval(1500);
exponentialBackOffPolicy.setMultiplier(2);
exponentialBackOffPolicy.setMaxInterval(6000); 2）org.springframework.retry.backoff.ExponentialRandomBackOffPolicy
指数随机策略，该类是ExponentialBackOffPolicy的子类，计算等待时间的算法为
@Override
public synchronized long getSleepAndIncrement() {
long next = super.getSleepAndIncrement();
next = (long)(next*(1 + r.nextFloat()*(getMultiplier()-1)));
return next;
}3）org.springframework.retry.backoff.FixedBackOffPolicy
4）org.springframework.retry.backoff.UniformRandomBackOffPolicy
这两个类与StatelessBackoffPolicy的同名实现类返回等待时间的方法是一致的。而两者的主要区别是，SleepingbackOffPolicy可以设置用户定义的Sleeper。
public interface Sleeper {
void sleep(long backOffPeriod) throws InterruptedException;
}
通过监听器，可以在重试操作的某些位置嵌入调用者定义的一些操作，以便在某些场景触发。
public class Main {
public static void main(String[] args) throws Exception {
RetryTemplate template = new RetryTemplate();
ExponentialRandomBackOffPolicy exponentialBackOffPolicy = new ExponentialRandomBackOffPolicy();
exponentialBackOffPolicy.setInitialInterval(1500);
exponentialBackOffPolicy.setMultiplier(2);
exponentialBackOffPolicy.setMaxInterval(6000);
CompositeRetryPolicy policy = new CompositeRetryPolicy();
RetryPolicy[] polices = {new SimpleRetryPolicy(), new AlwaysRetryPolicy()};
policy.setPolicies(polices);
policy.setOptimistic(true);
template.setRetryPolicy(policy);
template.setBackOffPolicy(exponentialBackOffPolicy);
template.registerListener(new RetryListener() {
public boolean open(RetryContext context, RetryCallback callback) {
System.out.println("open");
return true;
}
public void onError(RetryContext context, RetryCallback callback,
Throwable throwable) {
System.out.println("onError");
}
public void close(RetryContext context, RetryCallback callback,
Throwable throwable) {
System.out.println("close");
}
});
template.registerListener(new RetryListener() {
public boolean open(RetryContext context, RetryCallback callback) {
System.out.println("open2");
return true;
}
public void onError(RetryContext context, RetryCallback callback,
Throwable throwable) {
System.out.println("onError2");
}
public void close(RetryContext context, RetryCallback callback,
Throwable throwable) {
System.out.println("close2");
}
});
String result = template.execute(
new RetryCallback() {
public String doWithRetry(RetryContext arg0) throws Exception {
arg0.getAttribute("");
if(arg0.getRetryCount() >= 2) {
throw new NullPointerException();
}
throw new TimeoutException("TimeoutException");
}
}
);
System.out.println(result);
}
} 上述代码注册了两个Listener，Listener中的三个实现方法，onError,open,close会在执行重试操作时被调用，在RetryTemplate中doOpenInterceptors,doCloseInterceptors,doOnErrorInterceptors会调用监听器对应的open,close,onError 方法。
doOpenInterceptors方法在第一次重试之前会被调用，如果该方法返回true，则会继续向下直接，如果返回false，则抛出异常，停止重试。
doCloseInterceptors 会在重试操作执行完毕后调用。
doOnErrorInterceptors 在抛出异常后执行，
当注册多个Listener时，open方法按会按Listener的注册顺序调用，而onError和close则按Listener注册的顺序逆序调用。