10.3 异常的重试

This project provides declarative retry support for Spring applications. It is used in Spring Batch, Spring Integration, and others. Imperative retry is also supported for explicit usage.

• NeverRetryPolicy： 只允许调用 RetryCallback 一次，不允许重试；
• AlwaysRetryPolicy： 允许无限重试，直到成功，此方式逻辑不当会导致死循环；
• SimpleRetryPolicy： 固定次数重试策略，默认重试最大次数为 3 次，是 RetryTemplate 默认使用的策略；
• ExpressionRetryPolicy： 表达式重试策略，符合表达式就会重试；
• TimeoutRetryPolicy： 超时时间重试策略，默认超时时间为 1 秒，在指定的超时时间内允许重试；
• ExceptionClassifierRetryPolicy： 设置不同异常的重试策略，类似组合重试策略，区别在于这里只区分不同异常的重试；
• CircuitBreakerRetryPolicy： 有熔断功能的重试策略，需设置 3 个参数 openTimeout、resetTimeout 和 delegate，如果不在熔断状态，则允许重试；
• CompositeRetryPolicy： 组合重试策略，有两种组合方式，乐观组合重试策略是指只要有一个策略允许重试即可以重试，悲观组合重试策略是指只要有一个策略不允许重试即不可以重试，但不管哪种组合方式，组合中的每一个策略都会执行。

• FixedBackOffPolicy： 固定时间的退避策略，需设置参数 sleeper 和 backOffPeriod，sleeper 指定等待策略，默认是 Thread.sleep，即线程休眠，backOffPeriod 指定休眠时间，默认 1 秒；
• NoBackOffPolicy： 无退避算法策略，即需要重试时立即重试；
• UniformRandomBackOffPolicy： 随机时间退避策略，需设置 sleeper、minBackOffPeriod 和 maxBackOffPeriod，该策略在 [minBackOffPeriod, maxBackOffPeriod] 之间取一个随机休眠时间，minBackOffPeriod 默认 500 毫秒，maxBackOffPeriod 默认 1500 毫秒；
• ExponentialBackOffPolicy： 指数退避策略，需设置参数 sleeper、initialInterval、maxInterval 和 multiplier，initialInterval 指定初始休眠时间，默认 100 毫秒，maxInterval 指定最大休眠时间，默认 30 秒，multiplier 指定乘数，即下一次休眠时间为当前休眠时间*multiplier；
• ExponentialRandomBackOffPolicy： 随机指数退避策略，引入随机乘数，相对 ExponentialBackOffPolicy 和 FixedBackOffPolicy 可能会引起很多服务同时重试导致 DDoS，使用随机休眠时间就可以避免这种情况。

BinaryExceptionClassifier classifier = 
    new BinaryExceptionClassifier(Collections.singleton(Throwable.class));
RetryState state = new DefaultRetryState("mykey", false, classifier);
String result = template.execute((RetryCallback<String, Throwable>)context -> {
    remoteInvoke();
    return "ret";
}, context -> {
	return "recovery";
}, state);

@Configuration
@EnableRetry
public class Application {
    @Bean
    public Service service() {
        return new Service();
    }
}
@Service
class Service {
    @Retryable(RemoteAccessException.class)
    public void service() {
        // ... do something
    }
    @Recover
    public void recover(RemoteAccessException e) {
       // ... panic
    }
}

RetryTemplate template = RetryTemplate.builder()
				.maxAttempts(3)
				.fixedBackoff(1000)
				.retryOn(RemoteAccessException.class)
				.build();
template.execute(ctx -> {
    // ... do something
});

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.retry</groupId>
    <artifactId>spring-retry</artifactId>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId >
    <artifactId>aspectjweaver</artifactId >
</dependency>

package com.example.retry;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.retry.annotation.EnableRetry;
@SpringBootApplication
@EnableRetry
public class SpringBootRetryApplication {
	public static void main(String[] args) {
		SpringApplication.run(SpringBootRetryApplication.class, args);
	}
}

package com.example.retry.service;
import java.time.LocalTime;
import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Recover;
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Service;
@Service
public class RetryService {
	@Retryable(value = Exception.class, maxAttempts = 3, backoff = @Backoff(delay = 2000, multiplier = 1.5))
	public int service(int code) throws Exception {
		System.out.println("service called: " + LocalTime.now());
		if (code == 0) {
			throw new Exception("EXCCEPTION: It's bad.");
		}
		System.out.println("service called, it's good.");
		return 200;
	}
	@Recover
    public int recover(Exception e){
        System.out.println("retry recover.");
        return 500;
    }
}

package com.example.retry.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.example.retry.service.RetryService;
@RestController
@RequestMapping("/retry/")
public class RetryController {
	@Autowired 
	RetryService service;
	@RequestMapping("/service")
	public String service(int code) throws Exception {
		int result = service.service(code);
		return "spring-retry in Spring Boot: "+ result;
	}
}