org.springframework.cloud.client.circuitbreaker.CircuitBreaker Java Examples

@Test
public void testFallback() {
	SpringRetryCircuitBreakerFactory factory = new SpringRetryCircuitBreakerFactory();
	Supplier<String> spyedSup = spy(new Supplier<String>() {
		@Override
		public String get() {
			throw new RuntimeException("boom");
		}
	});
	CircuitBreaker cb = factory.create("foo");
	for (int i = 0; i < 10; i++) {
		cb.run(spyedSup, t -> "fallback");
	}
	assertThat((String) cb.run(spyedSup, t -> "fallback")).isEqualTo("fallback");
	// This will only be called 3 times because the SimpleRetryPolicy will trip the
	// circuit after the
	// 3rd attempt.
	verify(spyedSup, times(3)).get();
}
 

@Test
public void testCreateDirectlyThenRun() {
	// Create a circuit breaker without any circuit breaking rules.
	CircuitBreaker cb = new SentinelCircuitBreaker(
			"testSentinelCreateDirectlyThenRunA");
	assertThat(cb.run(() -> "Sentinel")).isEqualTo("Sentinel");
	assertThat(DegradeRuleManager.hasConfig("testSentinelCreateDirectlyThenRunA"))
			.isFalse();

	CircuitBreaker cb2 = new SentinelCircuitBreaker(
			"testSentinelCreateDirectlyThenRunB",
			Collections.singletonList(
					new DegradeRule("testSentinelCreateDirectlyThenRunB")
							.setCount(100).setTimeWindow(10)));
	assertThat(cb2.run(() -> "Sentinel")).isEqualTo("Sentinel");
	assertThat(DegradeRuleManager.hasConfig("testSentinelCreateDirectlyThenRunB"))
			.isTrue();
}
 

@Override
public CircuitBreaker create(String id) {
	Assert.hasText(id, "A circuit breaker must have an id");
	SpringRetryConfigBuilder.SpringRetryConfig config = getConfigurations()
			.computeIfAbsent(id, defaultConfig);
	return new SpringRetryCircuitBreaker(id, config,
			Optional.ofNullable(retryTemplateCustomizers.get(id)));
}
 

public Resilience4JCircuitBreaker(String id,
		io.github.resilience4j.circuitbreaker.CircuitBreakerConfig circuitBreakerConfig,
		TimeLimiterConfig timeLimiterConfig,
		CircuitBreakerRegistry circuitBreakerRegistry,
		ExecutorService executorService,
		Optional<Customizer<io.github.resilience4j.circuitbreaker.CircuitBreaker>> circuitBreakerCustomizer) {
	this.id = id;
	this.circuitBreakerConfig = circuitBreakerConfig;
	this.registry = circuitBreakerRegistry;
	this.timeLimiterConfig = timeLimiterConfig;
	this.executorService = executorService;
	this.circuitBreakerCustomizer = circuitBreakerCustomizer;
}
 

@Test
public void runWithFallback() {
	CircuitBreaker cb = new Resilience4JCircuitBreakerFactory().create("foo");
	assertThat((String) cb.run(() -> {
		throw new RuntimeException("boom");
	}, t -> "fallback")).isEqualTo("fallback");
}
 

@Override
public CircuitBreaker create(String id) {
	Assert.hasText(id, "A CircuitBreaker must have an id.");
	SentinelConfigBuilder.SentinelCircuitBreakerConfiguration conf = getConfigurations()
			.computeIfAbsent(id, defaultConfiguration);
	return new SentinelCircuitBreaker(id, conf.getEntryType(), conf.getRules());
}
 

@Test
public void testCreateWithNullRule() {
	String id = "testCreateCbWithNullRule";
	CircuitBreaker cb = new SentinelCircuitBreaker(id,
			Collections.singletonList(null));
	assertThat(cb.run(() -> "Sentinel")).isEqualTo("Sentinel");
	assertThat(DegradeRuleManager.hasConfig(id)).isFalse();
}
 

@Test
public void testRunWithFallback() {
	CircuitBreaker cb = new SentinelCircuitBreakerFactory()
			.create("testSentinelRunWithFallback");
	assertThat(cb.<String>run(() -> {
		throw new RuntimeException("boom");
	}, t -> "fallback")).isEqualTo("fallback");
}
 

@Test
public void testCreate() {
	CircuitBreaker cb = new SpringRetryCircuitBreakerFactory().create("foo");
	assertThat(cb.run(() -> "foo")).isEqualTo("foo");
}
 

@Override
public <T> T run(Supplier<T> toRun, Function<Throwable, T> fallback) {
	TimeLimiter timeLimiter = TimeLimiter.of(timeLimiterConfig);
	Supplier<Future<T>> futureSupplier = () -> executorService.submit(toRun::get);
	Callable restrictedCall = TimeLimiter.decorateFutureSupplier(timeLimiter,
			futureSupplier);

	io.github.resilience4j.circuitbreaker.CircuitBreaker defaultCircuitBreaker = registry
			.circuitBreaker(id, circuitBreakerConfig);
	circuitBreakerCustomizer
			.ifPresent(customizer -> customizer.customize(defaultCircuitBreaker));
	Callable<T> callable = io.github.resilience4j.circuitbreaker.CircuitBreaker
			.decorateCallable(defaultCircuitBreaker, restrictedCall);
	return Try.of(callable::call).recover(fallback).get();
}
 

@Test
public void run() {
	CircuitBreaker cb = new Resilience4JCircuitBreakerFactory().create("foo");
	assertThat(cb.run(() -> "foobar")).isEqualTo("foobar");
}
 

@Test
public void testCreateFromFactoryThenRun() {
	CircuitBreaker cb = new SentinelCircuitBreakerFactory().create("testSentinelRun");
	assertThat(cb.run(() -> "foobar")).isEqualTo("foobar");
}
 

@Around("anyCircuitBreakerFactoryCreate()")
public Object wrapFactory(ProceedingJoinPoint pjp) throws Throwable {
	CircuitBreaker circuitBreaker = (CircuitBreaker) pjp.proceed();
	return new TraceCircuitBreaker(circuitBreaker, this.tracer);
}
 

TraceCircuitBreaker(CircuitBreaker delegate, Tracer tracer) {
	this.delegate = delegate;
	this.tracer = tracer;
}
 

public String getAlbumList() {
    CircuitBreaker circuitBreaker = circuitBreakerFactory.create("circuitbreaker");
    String url = "https://jsonplaceholder.typicode.com/albums";

    return circuitBreaker.run(() -> restTemplate.getForObject(url, String.class), throwable -> getDefaultAlbumList());
}