HTTP Interface Client — 선언적 HTTP 호출로 Feign을 대체하는 방법

// 사용자 서비스 API를 선언적으로 정의
@HttpExchange(url = "/api/users", accept = MediaType.APPLICATION_JSON_VALUE)
public interface UserServiceClient {

    // 전체 사용자 목록 조회
    @GetExchange
    List<UserResponse> getAll();

    // ID로 사용자 조회
    @GetExchange("/{id}")
    UserResponse getById(@PathVariable Long id);

    // 사용자 생성
    @PostExchange
    UserResponse create(@RequestBody CreateUserRequest request);

    // 사용자 수정
    @PutExchange("/{id}")
    UserResponse update(@PathVariable Long id, @RequestBody UpdateUserRequest request);

    // 사용자 삭제
    @DeleteExchange("/{id}")
    void delete(@PathVariable Long id);

    // 검색 — 쿼리 파라미터 사용
    @GetExchange("/search")
    List<UserResponse> search(@RequestParam String name, @RequestParam int page);
}

@Configuration
public class HttpClientConfig {

    // RestClient 기반 HTTP Interface 프록시 생성
    @Bean
    public UserServiceClient userServiceClient(RestClient.Builder builder) {
        RestClient restClient = builder
                .baseUrl("https://api.example.com")
                .defaultHeader(HttpHeaders.AUTHORIZATION, "Bearer {token}")
                .requestInterceptor(new LoggingInterceptor()) // 스프링 인터셉터 그대로 사용
                .build();

        // 프록시 팩토리로 인터페이스 구현체 생성
        RestClientAdapter adapter = RestClientAdapter.create(restClient);
        HttpServiceProxyFactory factory = HttpServiceProxyFactory
                .builderFor(adapter)
                .build();

        return factory.createClient(UserServiceClient.class);
    }
}

// 리액티브 인터페이스 — 반환 타입만 다르다
@HttpExchange("/api/users")
public interface ReactiveUserServiceClient {

    @GetExchange
    Flux<UserResponse> getAll();

    @GetExchange("/{id}")
    Mono<UserResponse> getById(@PathVariable Long id);
}

// 설정 — RestClientAdapter 대신 WebClientAdapter 사용
WebClientAdapter adapter = WebClientAdapter.create(webClient);
HttpServiceProxyFactory factory = HttpServiceProxyFactory.builderFor(adapter).build();

@Bean
public UserServiceClient userServiceClient(RestClient.Builder builder) {
    RestClient restClient = builder
            .baseUrl("https://api.example.com")
            // 4xx 에러 처리
            .defaultStatusHandler(
                    HttpStatusCode::is4xxClientError,
                    (request, response) -> {
                        // 응답 본문에서 에러 메시지 추출
                        String body = new String(response.getBody().readAllBytes());
                        throw new ClientException("클라이언트 에러: " + body);
                    })
            // 5xx 에러 처리
            .defaultStatusHandler(
                    HttpStatusCode::is5xxServerError,
                    (request, response) -> {
                        throw new ServerException("외부 서비스 장애 발생");
                    })
            .build();

    return HttpServiceProxyFactory
            .builderFor(RestClientAdapter.create(restClient))
            .build()
            .createClient(UserServiceClient.class);
}

// 요청·응답 로깅 인터셉터
public class LoggingInterceptor implements ClientHttpRequestInterceptor {

    private static final Logger log = LoggerFactory.getLogger(LoggingInterceptor.class);

    @Override
    public ClientHttpResponse intercept(
            HttpRequest request, byte[] body,
            ClientHttpRequestExecution execution) throws IOException {
        log.info(">>> {} {}", request.getMethod(), request.getURI());
        ClientHttpResponse response = execution.execute(request, body);
        log.info("<<< {} {}", response.getStatusCode(), request.getURI());
        return response;
    }
}

@SpringBootTest
class UserServiceClientTest {

    private UserServiceClient client;
    private MockRestServiceServer mockServer;

    @BeforeEach
    void setUp() {
        // MockRestServiceServer와 연결된 RestClient 생성
        RestClient.Builder builder = RestClient.builder()
                .baseUrl("https://api.example.com");

        mockServer = MockRestServiceServer.bindTo(builder).build();

        RestClientAdapter adapter = RestClientAdapter.create(builder.build());
        HttpServiceProxyFactory factory = HttpServiceProxyFactory
                .builderFor(adapter)
                .build();

        client = factory.createClient(UserServiceClient.class);
    }

    @Test
    void 사용자_조회_성공() {
        // 모킹된 응답 설정
        mockServer.expect(requestTo("https://api.example.com/api/users/1"))
                .andExpect(method(HttpMethod.GET))
                .andRespond(withSuccess("""
                        {
                            "id": 1,
                            "name": "홍길동",
                            "email": "hong@example.com"
                        }
                        """, MediaType.APPLICATION_JSON));

        // 실행
        UserResponse user = client.getById(1L);

        // 검증
        assertThat(user.name()).isEqualTo("홍길동");
        mockServer.verify();
    }

    @Test
    void 서버_에러_처리() {
        mockServer.expect(requestTo("https://api.example.com/api/users/999"))
                .andRespond(withServerError());

        // 5xx 에러 시 커스텀 예외가 발생하는지 확인
        assertThatThrownBy(() -> client.getById(999L))
                .isInstanceOf(ServerException.class);
    }
}

@Service
@RequiredArgsConstructor
public class OrderService {

    private final UserServiceClient userClient;

    public OrderResponse createOrder(CreateOrderRequest request) {
        // 메서드 호출처럼 간결하게 외부 API 호출
        UserResponse user = userClient.getById(request.userId());
        return new OrderResponse(user, request.amount());
    }
}