Spring Retry로 구현하는 재시도와 서킷 브레이커

  public final <T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback) throws E {
  }

public interface RetryCallback<T, E extends Throwable> {
  T doWithRetry(RetryContext context) throws E;
}

import java.util.Map;

import org.springframework.retry.RetryOperations;
import org.springframework.retry.backoff.ExponentialBackOffPolicy;
import org.springframework.retry.policy.SimpleRetryPolicy;
import org.springframework.retry.support.RetryTemplate;

public class NotificationRetryDecorator {
	private RetryOperations buildRetryOperations(int maxAttempts) { // (1)
		var retryPolicy = new SimpleRetryPolicy( // (2)
			maxAttempts,
			Map.of(RuntimeException.class, true)
		);
		var backOffPolicy = new ExponentialBackOffPolicy(); // (3)
		backOffPolicy.setInitialInterval(200L);
		backOffPolicy.setMultiplier(2d);
		backOffPolicy.setMaxInterval(600L);

		var retryTemplate = new RetryTemplate(); // (4)
		retryTemplate.setRetryPolicy(retryPolicy);
		retryTemplate.setBackOffPolicy(backOffPolicy);
		return retryTemplate;
	}
}

import org.springframework.retry.RetryCallback;
import org.springframework.retry.RetryContext;

public class NotificationRetryDecorator implements NotificationService { // (1)
	private final Logger logger = LoggerFactory.getLogger(NotificationRetryDecorator.class);
	private final NotificationService target;
	private final RetryOperations retryOperations;

	public NotificationRetryDecorator(NotificationService target, int maxAttempts) { // (2)
		this.target = target;
		this.retryOperations = buildRetryOperations(maxAttempts); // (3)
	}

	@Override
	public boolean send(String message) {
		RetryCallback<Boolean, RuntimeException> retryCallback = (RetryContext context) -> { // (4)
			logger.info("{}", context);
			return target.send(message);
		};
		return this.retryOperations.execute(retryCallback);
	}
    // buildRetryOperations(...) 메서드 생략
}

	@Override
	public boolean send(String message) {
		return this.retryOperations.execute((context) -> target.send(message));
	}

		this.retryOperations = RetryTemplate.builder()
			.retryOn(RuntimeException.class)
			.maxAttempts(maxAttempts)
			.exponentialBackoff(200L, 2d, 600L)
			.build();

class NotificationRetryDecoratorTest {
	@Test
	void successByRetry() {
		var target = new UnstableNotificationService(3); // (1)
		var decorator = new NotificationRetryDecorator(target, 4); // (2)

		boolean success = decorator.send("hello");

		assertThat(success).isTrue();
		assertThat(target.getTryCount()).isEqualTo(4); // (3)
	}
}

INFO net.benelog.retry.NotificationRetryDecorator -- [RetryContext: count=0, lastException=null, exhausted=false]
INFO net.benelog.retry.NotificationRetryDecorator -- [RetryContext: count=1, lastException=java.lang.RuntimeException: 실패 : 1, exhausted=false]
INFO net.benelog.retry.NotificationRetryDecorator -- [RetryContext: count=2, lastException=java.lang.RuntimeException: 실패 : 2, exhausted=false]
INFO net.benelog.retry.NotificationRetryDecorator -- [RetryContext: count=3, lastException=java.lang.RuntimeException: 실패 : 3, exhausted=false]
INFO net.benelog.retry.UnstableNotificationService -- 성공 : 4, hello

public interface RecoveryCallback<T> {
  T recover(RetryContext context) throws Exception;
}

	@Override
	public boolean send(String message) {
		return retryOperations.execute(
			(context) -> this.target.send(message),
			(context) -> recover(context.getLastThrowable(), message) // (1)
		);
	}

	private boolean recover(Throwable error, String message) { // (2)
		logger.warn("메시지 전송 최종 실패 후 recover : {}", message, error);
		return false;
	}

	@Test
	void recover() {
		var target = new UnstableNotificationService(2); // (1)
		var decorator = new NotificationRetryDecorator(target, 2); // (2)

		boolean success = decorator.send("hello");

		assertThat(success).isFalse(); // (3)
		assertThat(target.getTryCount()).isEqualTo(2);
	}

	<T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback, RecoveryCallback<T> recoveryCallback,
			RetryState retryState) throws E;

public class NotificationCircuitDecorator implements NotificationService {
	// 중간 생략

	private RetryOperations buildRetryOperations(int maxAttempts) {
		var simplePolicy = new SimpleRetryPolicy(
			maxAttempts,
			Map.of(RuntimeException.class, true)
		);
		var circuitBreakerPolicy = new CircuitBreakerRetryPolicy(simplePolicy); // (1)
		circuitBreakerPolicy.setOpenTimeout(200L); // (2)
		circuitBreakerPolicy.setResetTimeout(300L); // (3)

		var retryTemplate = new RetryTemplate();
		retryTemplate.setRetryPolicy(circuitBreakerPolicy); // (4)
		return retryTemplate;
	}
}

public class NotificationCircuitDecorator implements NotificationService {

	private final Logger logger = LoggerFactory.getLogger(NotificationCircuitDecorator.class);
	private final NotificationService target;
	private final RetryOperations retryOperations;
	private final RetryState state; // (1)

	public NotificationCircuitDecorator(NotificationService target, int maxAttempts) {
		this.target = target;
		this.retryOperations = buildRetryOperations(maxAttempts);
		String stateKey = "NotificationService.send"; // (2)
		var rollbackClassifier = new BinaryExceptionClassifier(false); // (3)
		this.state = new DefaultRetryState(stateKey, rollbackClassifier);
	}

	@Override
	public boolean send(String message) {
		return this.retryOperations.execute(
			(context) -> this.target.send(message),
			(context) -> recover(context.getLastThrowable(), message),
			this.state // (4)
		);
	}
	// recover 메서드는 NotificationRetryDecorator의 것과 동일
}

class NotificationCircuitDecoratorTest {
	UnstableNotificationService target = new UnstableNotificationService(2); // (1)
	NotificationCircuitDecorator decorator = new NotificationCircuitDecorator(target, 2); // (2)

	private void callAndAssert(boolean expectedResult, int expectedTryCount) { // (3)
		boolean success = decorator.send("Hello!");
		assertThat(success).isEqualTo(expectedResult);
		assertThat(target.getTryCount()).isEqualTo(expectedTryCount);
	}

	@Test
	void recoveredWithCircuit() throws InterruptedException {
		callAndAssert(false, 1); // (4)
		callAndAssert(false, 2);
		callAndAssert(false, 2); // (5)
		TimeUnit.MILLISECONDS.sleep(310); // (6)
		callAndAssert(true, 3); // (7)
	}
}

import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Retryable;

interface NotificationRetryService extends NotificationService {
	@Retryable(
		retryFor = RuntimeException.class, maxAttempts = 4,
		backoff = @Backoff(delay = 200L, multiplier = 2d, maxDelay = 600L)
	)
	boolean send(String message);
}

public class UnstableNotificationService implements NotificationRetryService {

@Configuration
@EnableRetry(proxyTargetClass = true) // (1)
public class TestServiceConfig {
	@Bean
	public UnstableNotificationService fail3Service() {
		return new UnstableNotificationService(3); // (2)
	}
}

@SpringJUnitConfig(TestServiceConfig.class) // (1)
class NotificationRetryServiceTest {
	@Test
	void retry(@Qualifier("fail3Service") UnstableNotificationService fail3Service) { // (2)
		boolean success = fail3Service.send("Hello!");
		assertThat(fail3Service.getTryCount()).isEqualTo(4); // (3)
		assertThat(success).isTrue();
	}
}

	Logger logger = LoggerFactory.getLogger(NotificationRetryService.class);

	@Recover // (1)
	default boolean recover(Throwable error, String message) { // (2)
		logger.warn("메시지 전송 최종 실패 후 recover : {}", message, error);
		return false;
	}

	@Bean
	public UnstableNotificationService fail4Service() {
		return new UnstableNotificationService(4);
	}

	@Test
	void retryAndRecover(@Qualifier("fail4Service") UnstableNotificationService fail4Service) {
		boolean success = fail4Service.send("Hello!");
		assertThat(fail4Service.getTryCount()).isEqualTo(4);
		assertThat(success).isFalse(); // (1)
	}

interface NotificationCircuitService {

	@CircuitBreaker(
		retryFor = RuntimeException.class, // (1)
		maxAttempts = 2, openTimeout = 200L, resetTimeout = 300L // (2)
	)
	boolean sendOnCircuit(String message); // (3)
}

public class FragileService extends UnstableNotificationService implements NotificationCircuitService {
	public FragileService(int failures) {
		super(failures);
	}

	@Override
	public boolean sendOnCircuit(String message) {
		return super.send(message);
	}
}

    @Bean
    public FragileService fail2Service() {
      return new FragileService(2); // (1)
    }

@SpringJUnitConfig(TestServiceConfig.class) // (1)
class NotificationCircuitServiceTest {

	@Autowired
	FragileService fail2Service;

	private void callAndAssert(boolean expectedResult, int expectedTryCount) { // (2)
		boolean success = fail2Service.sendOnCircuit("Hello!");
		assertThat(success).isEqualTo(expectedResult);
		assertThat(fail2Service.getTryCount()).isEqualTo(expectedTryCount);
	}

	@Test
	void recoveredWithCircuit() throws InterruptedException {
		callAndAssert(false, 1); // (3)
		callAndAssert(false, 2);
		callAndAssert(false, 2); // (4)
		TimeUnit.MILLISECONDS.sleep(310); // (5)
		callAndAssert(true, 3); // (6)
	}
}