1

我正在尝试将重试策略与具有 Failsafe 的 CircuitBreaker 模式相结合，但是当尝试在电路打开并中断时出现 CircuitBreakerOpenException 异常。

https://github.com/jhalterman/failsafe

问题是通过将重试延迟设置为小于电路的关闭时间而产生的。

如何控制此异常，使重试策略不中断？我想这样做是因为我可以让多个同时实例向休息服务发起请求，并且重试不会中断。

我的代码：

public class UnstableApplication {
    private final int MAX_FAILS = 4;
    private AtomicInteger failCount = new AtomicInteger(1);

    public String generateId() throws Exception {
        if (failCount.getAndIncrement() < MAX_FAILS) {
            System.err.printf("UnstableApplication throws SampleException at '%s'\n", ZonedDateTime.now());
            throw new Exception();
        }

        final String id = UUID.randomUUID().toString();
        System.out.printf("UnstableApplication: id '%s' generated at '%s'\n", id, ZonedDateTime.now());

        return id;
    }

}

public class FailsafeExample {

    public static void main(String[] args) throws Exception {

        UnstableApplication app = new UnstableApplication();

        RetryPolicy retryPolicy = new RetryPolicy()
                .retryOn(Exception.class)
                .withDelay(2, TimeUnit.SECONDS)
                .withMaxRetries(5);

        CircuitBreaker breaker = new CircuitBreaker();
        breaker.withFailureThreshold(2);
        breaker.withDelay(5, TimeUnit.SECONDS);
        breaker.withSuccessThreshold(3);
        breaker.onOpen(() -> {
            System.out.println("Circuit breaker is open");
        });

        breaker.onClose(() -> {
            System.out.println("Circuit breaker is close");
        });

        breaker.onHalfOpen(() -> {
            System.out.println("Circuit breaker is half-close");
        }); 

        Failsafe.with(retryPolicy)
        .with(breaker)
        .onFailedAttempt((a, b) -> {
            System.out.println(
                    String.format("Failed with exception: %s, at %s, circuit-breaker state is: %s", 
                            b, ZonedDateTime.now(), breaker.getState()));
        })
        .onSuccess(cxn -> {
            System.out.println("Succcess!");
        })
        .onFailure(cxn -> {
            System.out.println("Failed!");
        })
        .get(new Callable<String>() {
            @Override
            public String call() throws Exception {
                return app.generateId();
            }
        });
    }
}

我的结果：

UnstableApplication throws SampleException at '2019-05-31T16:30:09.214Z[Etc/UTC]'
Failed with exception: java.lang.Exception, at 2019-05-31T16:30:09.221Z[Etc/UTC], circuit-breaker state is: CLOSED
UnstableApplication throws SampleException at '2019-05-31T16:30:11.229Z[Etc/UTC]'
Circuit breaker is open
Failed with exception: java.lang.Exception, at 2019-05-31T16:30:11.230Z[Etc/UTC], circuit-breaker state is: OPEN
Exception in thread "main" net.jodah.failsafe.CircuitBreakerOpenException
    at net.jodah.failsafe.SyncFailsafe.call(SyncFailsafe.java:136)
    at net.jodah.failsafe.SyncFailsafe.get(SyncFailsafe.java:56)
    at com.kash.test.Foo.main(Foo.java:63)
4

2 回答 2

1

这是预期的行为。当电路打开时，对那个端点的请求就会停止——如果依赖关系被破坏或不可靠，当然你的重试也必须被切断，否则你会像没有一样容易地经历一堆重试。根本没有cb。

如果你想继续发送请求，要么你的断路触发器太敏感，要么你处于不需要断路的情况。故障安全强制执行的行为很可能是正确的方法。

如果您真的想这样做，请将您的重试逻辑放在您发送给断路器的函数中，而不是使用故障安全中的 RetryPolicy。或者在重试策略中使用指数退避函数。

于 2018-12-11T16:13:42.440 回答
1

这是我在此示例中尝试将断路器与重试策略结合使用时的理解：

CircuitBreaker breaker = new CircuitBreaker()
                .withFailureThreshold(3, 10)
                .withSuccessThreshold(5)
                .failOn(Exception.class)
                .withDelay(30, TimeUnit.SECONDS);

RetryPolicy retryPolicy = new RetryPolicy()
                .retryOn(ConnectException.class)
                .withDelay(3, TimeUnit.SECONDS)
                .withMaxRetries(5);
  • 首先，它会重试 5 次，但由于 Circuit Breaker 的阈值为 3，因此在第 3 次“连续”重试尝试时，它将断开并打开电路。
  • 因此，一旦打开，它可能“仍然重试”，但由于电路已经打开，仍然在时间延迟下重试，将导致 CircuitBreakerOpenException。
于 2018-03-15T06:45:29.293 回答