服务治理之轻量级熔断框架：Resilience4j

@Repository
public class CircuitBreakerServiceImpl {
    @Autowired
    private RemoteServiceConnector remoteServiceConnector;
    @Autowired
    private CircuitBreakerRegistry circuitBreakerRegistry;
    @Bean
    public List<String> circuitBreakerNotAOP(){
        // 通过注册器获取熔断器的实例
//        CircuitBreaker circuitBreaker = circuitBreakerRegistry.circuitBreaker("backendA");
        CircuitBreaker circuitBreaker = circuitBreakerRegistry.circuitBreaker("backendA", CircuitBreakerUtil.circuitBreakerConfig());
        CircuitBreakerUtil.getCircuitBreakerStatus("执行开始前：", circuitBreaker);
        // 使用熔断器包装连接器的方法
        CheckedFunction0<List<String>> checkedSupplier = CircuitBreaker.
                decorateCheckedSupplier(circuitBreaker, remoteServiceConnector::process);
        // 使用Try.of().recover()调用并进行降级处理
        Try<List<String>> result = Try.of(checkedSupplier).
                recover(CallNotPermittedException.class, throwable -> {
                    LogUtil.info("熔断器已经打开，拒绝访问被保护方法~");
                    CircuitBreakerUtil
                            .getCircuitBreakerStatus("熔断器打开中:", circuitBreaker);
                    return new ArrayList();
                })
                .recover(throwable -> {
                    LogUtil.info("方法被降级了~~");
                    CircuitBreakerUtil
                            .getCircuitBreakerStatus("降级方法中:",circuitBreaker);
                    return new ArrayList();
                });
        CircuitBreakerUtil.getCircuitBreakerStatus("执行结束后：", circuitBreaker);
        LogUtil.info("===========================================================================");
        return result.get();
    }
}

public class CircuitBreakerUtil {
    /**
     * @Description: 获取熔断器的状态
     */
    public static void getCircuitBreakerStatus(String time, CircuitBreaker circuitBreaker) {
        CircuitBreaker.Metrics metrics = circuitBreaker.getMetrics();
        // Returns the failure rate in percentage.
        float failureRate = metrics.getFailureRate();
        // Returns the current number of buffered calls.
        int bufferedCalls = metrics.getNumberOfBufferedCalls();
        // Returns the current number of failed calls.
        int failedCalls = metrics.getNumberOfFailedCalls();
        // Returns the current number of successed calls.
        int successCalls = metrics.getNumberOfSuccessfulCalls();
        // Returns the current number of not permitted calls.
        long notPermittedCalls = metrics.getNumberOfNotPermittedCalls();
        LogUtil.info(time + "state=" + circuitBreaker.getState() + " , metrics[ failureRate=" + failureRate +
                ", bufferedCalls=" + bufferedCalls +
                ", failedCalls=" + failedCalls +
                ", successCalls=" + successCalls +
                ", notPermittedCalls=" + notPermittedCalls +
                " ]"
        );
    }
    /**
     * @Description: 监听熔断器事件
     */
    public static void addCircuitBreakerListener(CircuitBreaker circuitBreaker){
        circuitBreaker.getEventPublisher()
                .onSuccess(event -> LogUtil.info("服务调用成功：" + event.toString()))
                .onError(event -> LogUtil.info("服务调用失败：" + event.toString()))
                .onIgnoredError(event -> LogUtil.info("服务调用失败，但异常被忽略：" + event.toString()))
                .onReset(event -> LogUtil.info("熔断器重置：" + event.toString()))
                .onStateTransition(event -> LogUtil.info("熔断器状态改变：" + event.toString()))
                .onCallNotPermitted(event -> LogUtil.info(" 熔断器已经打开：" + event.toString()));
    }
    /**
     * 熔断器配置
     * @return
     */
    public static CircuitBreakerConfig circuitBreakerConfig() {
        return CircuitBreakerConfig.custom()
                // 环形缓冲区大小是 10，填满 10 个请求后，才开始计算失败率，达到 60%即熔断
                .failureRateThreshold(60) // 熔断器打开的失败阈值
                .slidingWindowType(SlidingWindowType.COUNT_BASED)
                .slidingWindowSize(10)
                .minimumNumberOfCalls(10)
                .slidingWindow(10, 10, SlidingWindowType.COUNT_BASED)// 替代上面三个属性
                .ignoreExceptions(BusinessAException.class) // 忽略的异常
                .recordExceptions(BusinessAException.class,BusinessBException.class) // 记录的异常
                .waitDurationInOpenState(Duration.ofMillis(10000)) //10秒尝试open->half-open
                .permittedNumberOfCallsInHalfOpenState(5) // half-open时允许通过的请求即：累计 5 个请求计算失败率
                .automaticTransitionFromOpenToHalfOpenEnabled(true)// 如果置为true，当等待时间结束会自动由打开变为半开，若置为false，则需要一个请求进入来触发熔断器状态转换
                .slowCallRateThreshold(50)  // 300ms以上的请求大于50%熔断
                .slowCallDurationThreshold(Duration.ofMillis(300))
                .build();
    }
}

@Component
public class RemoteServiceImpl implements RemoteService {
    private static AtomicInteger count = new AtomicInteger(0);
    public List<String> process() throws BusinessAException, BusinessBException{
        int num = count.getAndIncrement();
        LogUtil.info("count的值 = " + num);
        if (num % 4 == 1){
            LogUtil.info("异常A，不需要被记录");
            throw new BusinessAException("异常A，不需要被记录");
        }
        if (num % 4 == 2 || num % 4 == 3){
            LogUtil.info("异常B，需要被记录");
            throw new BusinessBException("异常B，需要被记录");
        }
        LogUtil.info("服务正常运行，获取用户列表");
        // 模拟数据库的正常查询
        List<String> strFromDB = new ArrayList<>();
        strFromDB.add("data");
        strFromDB.add("from");
        strFromDB.add("db");
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return strFromDB;
    }
}

public class BusinessAException extends TimeoutException {
    private static final long serialVersionUID = 1L;
    // 提供无参数的构造方法
    public BusinessAException() {
    }
    // 提供一个有参数的构造方法，可自动生成
    public BusinessAException(String message) {
        super(message);// 把参数传递给Throwable的带String参数的构造方法
    }
}

public class BusinessBException extends TimeoutException {
    private static final long serialVersionUID = 1L;
    // 提供无参数的构造方法
    public BusinessBException() {
    }
    // 提供一个有参数的构造方法，可自动生成
    public BusinessBException(String message) {
        super(message);// 把参数传递给Throwable的带String参数的构造方法
    }
}

@Repository
public interface RemoteService {
    List<String> process() throws TimeoutException, InterruptedException;
}

@Repository
public class RemoteServiceConnector {
    @Autowired
    private CircuitBreakerRegistry circuitBreakerRegistry;
    @Autowired
    private RemoteService remoteService;
    public List<String> process() throws TimeoutException, InterruptedException {
        List<String> users = remoteService.process();
        return users;
    }
}

@Autowired
private CircuitBreakerServiceImpl circuitService;
for (int i=0; i<13; i++){
  circuitService.circuitBreakerNotAOP();
}