package com.assu.study.chap09.config;

import com.assu.study.chap09.server.IdentityHeaderInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.web.client.DefaultResponseErrorHandler;
import org.springframework.web.client.RestTemplate;

@Configuration
public class RestTemplateConfig {

  @Bean
  public ClientHttpRequestFactory clientHttpRequestFactory() {
    // RestTemplate 의 ClientHttpRequestFactory 구현체로 SimpleClientHttpRequestFactory 사용
    SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();

    // 클라이언트와 서버 사이에 커넥션 객체 생성 시 소요되는 최대 시간 (ms)
    factory.setConnectTimeout(3000);
    
    // 클라이언트가 서버에 데이터 처리를 요청하고 응답받기까지 소요되는 최대 시간 (ms)
    factory.setReadTimeout(1000);
    
    // SimpleClientHttpRequestFactory 는 요청 메시지의 바디를 버퍼링하는 기능을 제공함
    // 디폴트는 true
    // 요청 메시지의 바디를 버퍼링하지 않으려면 false 로 설정
    factory.setBufferRequestBody(false);

    return factory;
  }

  @Bean
  public RestTemplate restTemplate(ClientHttpRequestFactory clientHttpRequestFactory) {
    // ClientHttpRequestFactory 인자를 받는 생성자를 사용하여 RestTemplate 객체 생성
    // 바로 위에서 설정한 ClientHttpRequestFactory 스프링 빈을 주입받아서 RestTemplate 객체 생성
    RestTemplate restTemplate = new RestTemplate(clientHttpRequestFactory);

    // RestTemplate 객체에 새로운 인터셉터 객체 추가
    // getInterceptors() 는 RestTemplate 객체에 설정된 인터셉터 리스트 객체를 리턴하므로 리스트 객체의 add() 를 사용하여
    // IdentityHeaderInterceptor 객체 추가 (해당 인터셉터 구현은 뒤에 나옴)
    restTemplate.getInterceptors().add(new IdentityHeaderInterceptor());
    
    // RestTemplate 객체에 새로운 ResponseErrorHandler 설정
    restTemplate.setErrorHandler(new DefaultResponseErrorHandler());

    return restTemplate;
  }
}

package com.assu.study.chap09.server;

import org.springframework.http.HttpRequest;
import org.springframework.http.client.ClientHttpRequestExecution;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.http.client.ClientHttpResponse;

import java.io.IOException;

// 사용자 요청 메시지에 X-COMPONENT-ID 헤더가 없으면 헤더를 추가하는 역할
public class IdentityHeaderInterceptor implements ClientHttpRequestInterceptor {
  private static final String COMPONENT_HEADER_NAME = "X-COMPONENT-ID";
  private static final String COMPONENT_HEADER_VALUE = "HOTEL-API";

  @Override
  public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
    // RestTemplate 에 X-COMPONENT-ID 헤더가 없으면 기본값인 HOTEL-API 헤더값 설정
    request.getHeaders().addIfAbsent(COMPONENT_HEADER_NAME, COMPONENT_HEADER_VALUE);

    // ClientHttpRequestExecution 의 execute() 메서드를 실행하여 다음 인터셉터로 요청 전달
    return execution.execute(request, body);
  }
}

package org.springframework.web.client;

public interface ResponseErrorHandler {
  // 에러가 있는지 여부 판단
  // true 를 리턴하면 handleError() 메서드를 실행하여 에러 처리를 위임
  boolean hasError(ClientHttpResponse response) throws IOException;

  // 에러가 있다면 IOException 예외를 던져도 되고, ClientHttpResponse 객체를 사용하여 에러를 처리해도 됨
  void handleError(ClientHttpResponse response) throws IOException;

  default void handleError(URI url, HttpMethod method, ClientHttpResponse response) throws IOException {
    this.handleError(response);
  }
}

package com.assu.study.chap09.controller;

import lombok.Getter;
import lombok.Setter;

@Setter
@Getter
public class ApiResponse<T> {
  private boolean success;
  private String resultMessage;
  // data 속성은 API 마다 다를 수 있으므로 제네릭 타입 사용
  private T data;

  public ApiResponse() {
  }

  public ApiResponse(boolean success, String resultMessage) {
    this.success = success;
    this.resultMessage = resultMessage;
  }

  public static <T> ApiResponse ok(T data) {
    ApiResponse apiResponse = new ApiResponse(true, "success");
    apiResponse.data = data;
    return apiResponse;
  }
}

package com.assu.study.chap09.controller;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

@Getter
@Setter
@ToString
public class BillingCodeResponse {
  private String billingCode;

  public static BillingCodeResponse of(String billingCode) {
    BillingCodeResponse response = new BillingCodeResponse();
    response.billingCode = billingCode;
    return response;
  }
}

package com.assu.study.chap09.controller;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

import java.util.List;

@Getter
@Setter
@ToString
public class CreateCodeResponse {
  private List<Long> codes;
  
  public static CreateCodeResponse of(List<Long> codes) {
    CreateCodeResponse response = new CreateCodeResponse();
    response.codes = codes;
    return response;
  }
}

// GET /billing-codes
ApiResponse<List<BillingCodeResponse>>

// POST /billing-codes
ApiResponse<CreateCodeResponse>

package com.assu.study.chap09.Adapter;

import com.assu.study.chap09.controller.ApiResponse;
import com.assu.study.chap09.controller.BillingCodeResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.util.UriComponentsBuilder;

import java.net.URI;
import java.util.List;
import java.util.Objects;

@Component
@Slf4j
public class BillingAdapter {

  private final RestTemplate restTemplate;

  public BillingAdapter(RestTemplate restTemplate) {
    this.restTemplate = restTemplate;
  }

  public List<BillingCodeResponse> getBillingCodes(String codeNameParam) {
    // URI 객체 생성
    UriComponentsBuilder builder = UriComponentsBuilder.fromPath("/billing-codes")
        .scheme("http").host("127.0.0.1").port(8080);

    if (Objects.nonNull(codeNameParam)) {
      builder.queryParam("codeName", codeNameParam);
    }

    URI uri = builder.build(false).encode().toUri();

    // GET 메서드를 이용하여 서버에 요청
    // 두 번째 인자를 응답 메시지를 변환할 클래스 타입
    // 두 번째 인자가 ApiResponse.class 이므로 리턴 타입은 ResponseEntity<ApiResponse> 가 됨
    ResponseEntity<ApiResponse> responseEntity = restTemplate.getForEntity(uri, ApiResponse.class);

    if (HttpStatus.OK != responseEntity.getStatusCode()) {
      log.error("Error from Billing. status: {}, param: {}", responseEntity.getStatusCode(), codeNameParam);
      throw new RuntimeException("Error From Billing~" + responseEntity.getStatusCode());
    }

    // getBody() 는 HTTP 응답 메시지의 바디값을 응답
    // 단, getForEntity() 메서드의 인자로 사용된 클래스 타입으로 응답하므로 ApiResponse 객체로 응답
    ApiResponse apiResponse = responseEntity.getBody();
    
    // 제네릭 타입이 설정되어 있지 않은 ApiResponse 객체의 data 속성의 클래스 타입은 Object 이므로
    // 적절한 타입의 객체로 변경하려면 타입 캐스팅 필요
    return (List<BillingCodeResponse>) apiResponse.getData();
  }
}

package com.assu.study.chap09;

import com.assu.study.chap09.Adapter.BillingAdapter;
import com.assu.study.chap09.controller.BillingCodeResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

import java.util.List;

@Slf4j
@SpringBootApplication
public class Chap09Application {

  public static void main(String[] args) {
    ConfigurableApplicationContext ctx = SpringApplication.run(Chap09Application.class, args);

    BillingAdapter billingAdapter = ctx.getBean(BillingAdapter.class);

    List<BillingCodeResponse> responses = billingAdapter.getBillingCodes("CODE:1234567");
    log.info("getBillingCode: {}", responses);

  }

}

package com.assu.study.chap09.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@Slf4j
@RestController
public class BillingController {

  @GetMapping("/billing-codes")
  public ApiResponse<List<BillingCodeResponse>> getBillingCodes(
      @RequestParam(required = false) String codeName
  ) {
    List<BillingCodeResponse> response = List.of(
        BillingCodeResponse.of("CODE-111111"),
        BillingCodeResponse.of("CODE-222222")
    );
    return ApiResponse.ok(response);
  }
}

package com.assu.study.chap09.Adapter;

import com.assu.study.chap09.controller.ApiResponse;
import com.assu.study.chap09.controller.BillingCodeResponse;
import com.assu.study.chap09.controller.CreateCodeRequest;
import com.assu.study.chap09.controller.CreateCodeResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.util.UriComponentsBuilder;

import java.net.URI;
import java.util.List;
import java.util.Map;
import java.util.Objects;

@Component
@Slf4j
public class BillingAdapter {

  private final RestTemplate restTemplate;

  public BillingAdapter(RestTemplate restTemplate) {
    this.restTemplate = restTemplate;
  }

  public CreateCodeResponse createWithPostForEntity(List<Long> hotelIds) {
    URI uri = UriComponentsBuilder.fromPath("/billing-codes")
        .scheme("http").host("127.0.0.1").port(8080)
        .build(false).encode().toUri();

    CreateCodeRequest request = new CreateCodeRequest(1, hotelIds);

    ResponseEntity<ApiResponse> responseEntity = restTemplate.postForEntity(uri, request, ApiResponse.class);

    if (HttpStatus.OK != responseEntity.getStatusCode()) {
      log.error("Error from Billing. status:{}, hotelIds:{}", responseEntity.getStatusCode(), hotelIds);
      throw new RuntimeException("Error from Billing. " + responseEntity.getStatusCode());
    }

    ApiResponse apiResponse = responseEntity.getBody();

    // data 속성값을 Map 으로 캐스팅
    // JSON 객체의 data 속성값은 "codes": [111,222,333] 이므로 Map 의 key 는 "codes" 문자열이, Map 의 값에는 Long 타입의 리스트가 저장됨
    Map<String, List<Long>> dataMap = (Map) apiResponse.getData();

    return CreateCodeResponse.of(dataMap.get("codes"));
  }

package com.assu.study.chap09.controller;

import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.Getter;
import lombok.Setter;

import java.util.List;

@Getter
@Setter
//@ToString
public class CreateCodeRequest {
  private Integer type;

  @JsonProperty("hotelIds") // JSON 객체로 마셜링하는 과정에서 ids 속성명 대신 hotelIds 가 JSON 객체의 속성명이 됨
  private List<Long> ids;

  public CreateCodeRequest(Integer type, List<Long> ids) {
    this.type = type;
    this.ids = ids;
  }
}

package com.assu.study.chap09.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@Slf4j
@RestController
public class BillingController {
  @PostMapping(path = "/billing-codes")
  public ApiResponse<CreateCodeResponse> createBillingCodes(
          @RequestBody CreateCodeRequest request
  ) {
    return ApiResponse.ok(CreateCodeResponse.of(request.getIds()));
  }
}

package com.assu.study.chap09;

import com.assu.study.chap09.Adapter.BillingAdapter;
import com.assu.study.chap09.controller.BillingCodeResponse;
import com.assu.study.chap09.controller.CreateCodeResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

import java.util.List;

@Slf4j
@SpringBootApplication
public class Chap09Application {

  public static void main(String[] args) {
    ConfigurableApplicationContext ctx = SpringApplication.run(Chap09Application.class, args);

    BillingAdapter billingAdapter = ctx.getBean(BillingAdapter.class);

    CreateCodeResponse createCodeResponse = billingAdapter.createWithPostForEntity(List.of(1234567L));

    // createWithPostForEntity: CreateCodeResponse(codes=[1234567])
    log.info("createWithPostForEntity: {}", createCodeResponse);
  }
}

package com.assu.study.chap09.Adapter;

import com.assu.study.chap09.controller.ApiResponse;
import com.assu.study.chap09.controller.CreateCodeRequest;
import com.assu.study.chap09.controller.CreateCodeResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.*;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.util.UriComponentsBuilder;

import java.net.URI;
import java.util.List;

@Component
@Slf4j
public class BillingAdapter {

  // ParameterizedTypeReference 를 사용하여 ApiResponse<CreateCodeResponse> 처럼 중첩된 클래스 타입에 대한 클래스 타입 정보 정의
  private static final ParameterizedTypeReference<ApiResponse<CreateCodeResponse>> TYPE_REFERENCE;

  static {
    TYPE_REFERENCE = new ParameterizedTypeReference<>() {
    };
  }

  private final RestTemplate restTemplate;

  public BillingAdapter(RestTemplate restTemplate) {
    this.restTemplate = restTemplate;
  }

  // exchange() 로 REST-API 호출
  public CreateCodeResponse createWithExchange(List<Long> hotelIds) {
    URI uri = UriComponentsBuilder.fromPath("/billing-codes")
        .scheme("http").host("127.0.0.1").port(8080)
        .build(false).encode().toUri();

    CreateCodeRequest request = new CreateCodeRequest(1, hotelIds);

    HttpHeaders headers = new HttpHeaders();
    // 요청 메시지의 바디가 JSON 메시지이므로 Content-type 헤더 추가
    headers.setContentType(MediaType.APPLICATION_JSON);
    // HTTP 요청 메시지를 생성하려고 HttpEntity 객체 생성
    HttpEntity<CreateCodeRequest> httpEntity = new HttpEntity<>(request, headers);

    // HTTP 요청 메시지는 HttpEntity 객체 사용
    // 리턴 타입은 ParameterizedTypeReference 를 사용하여 정의
    ResponseEntity<ApiResponse<CreateCodeResponse>> responseEntity =
        restTemplate.exchange(uri, HttpMethod.POST, httpEntity, TYPE_REFERENCE);

    if (HttpStatus.OK != responseEntity.getStatusCode()) {
      log.error("Error from Billing. status:{}, hotelIds:{}", responseEntity.getStatusCode(), hotelIds);
      throw new RuntimeException("Error from Billing. " + responseEntity.getStatusCode());
    }

    // 타입 캐스팅없이 클래스 타입에 안전하게 CreateCodeResponse 객체 리턴
    return responseEntity.getBody().getData();
  }
}

package com.assu.study.chap09;

import com.assu.study.chap09.Adapter.BillingAdapter;
import com.assu.study.chap09.controller.BillingCodeResponse;
import com.assu.study.chap09.controller.CreateCodeResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

import java.util.List;

@Slf4j
@SpringBootApplication
public class Chap09Application {

  public static void main(String[] args) {
    ConfigurableApplicationContext ctx = SpringApplication.run(Chap09Application.class, args);

    BillingAdapter billingAdapter = ctx.getBean(BillingAdapter.class);

    CreateCodeResponse createCodeResponse2 = billingAdapter.createWithExchange(List.of(1234567L, 111L, 876456L));
    // createWithExchange: CreateCodeResponse(codes=[1234567, 111, 876456])
    log.info("createWithExchange: {}", createCodeResponse2);
  }
}

ResponseEntity<ApiResponse> responseEntity = restTemplate.postForEntity(uri, request, ApiResponse.class);

ApiResponse apiResponse = responseEntity.getBody();
// data 속성값을 Map 으로 캐스팅
// JSON 객체의 data 속성값은 "codes": [111,222,333] 이므로 Map 의 key 는 "codes" 문자열이, Map 의 값에는 Long 타입의 리스트가 저장됨
Map<String, List<Long>> dataMap = (Map) apiResponse.getData();

// ParameterizedTypeReference 를 사용하여 ApiResponse<CreateCodeResponse> 처럼 중첩된 클래스 타입에 대한 클래스 타입 정보 정의
private static final ParameterizedTypeReference<ApiResponse<CreateCodeResponse>> TYPE_REFERENCE;

static {
  TYPE_REFERENCE = new ParameterizedTypeReference<>() {
  };
}

public URI build(Object... uriVariables)
public URI build(Map<String, ?> uriVariables)
public UriComponents build()

package com.assu.study.chap09;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.web.util.UriComponentsBuilder;

import java.net.URI;

public class UriComponentsBuilderTest {

  @Test
  void testBuild() {
    // URI 를 리턴하는 build() 이므로 내부적으로 인코딩하는 케이스
    // given, when
    URI uri = UriComponentsBuilder.fromPath("/hotels/{hotelName}")
        .queryParam("type", "{type}")
        .queryParam("isActive", "{isActive}")
        .scheme("https").host("127.0.0.1").port(18080)
        .build("한국 hotel", "Hotel", "true");  

    // then
    Assertions.assertEquals("https://127.0.0.1:18080/hotels/%ED%95%9C%EA%B5%AD%20hotel?type=Hotel&isActive=true", uri.toString());
  }
}

package com.assu.study.chap09;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.web.util.UriComponentsBuilder;

import java.net.URI;

public class UriComponentsBuilderTest {
  @Test
  void testEncoding() {
    // 1. URI 를 리턴하는 build() 이므로 내부적으로 인코딩하는 케이스
    URI firstUri = UriComponentsBuilder.fromPath("/hotels/{hotelName}")
        .scheme("https").host("127.0.0.1").port(18080)
        .build("한국호텔"); // URL 경로에 포함된 템플릿 변수를 인자로 치환하고 인코딩함

    Assertions.assertEquals("https://127.0.0.1:18080/hotels/%ED%95%9C%EA%B5%AD%ED%98%B8%ED%85%94", firstUri.toString());


    // 2. UriComponents 를 리턴하는 build() 이므로 내부적으로 인코딩하지 않는 케이스
    String variable = "한국호텔";
    String path = "/hotels/" + variable;  // 템플릿 변수 없음

    // 템플릿을 사용하지 않았으므로 UriComponents 를 리턴하는 build() 사용 (내부에서 인코딩하지 않음)
    URI secondUri = UriComponentsBuilder.fromPath(path)
        .scheme("https").host("127.0.0.1").port(18080)
        .build()  // UriComponents 리턴
        .toUri(); // UriComponents 를 리턴하므로 toUri() 를 통해 URI 객체로 변환

    // 퍼센트 인코딩을 물론 UTF-8 문자셋 인코딩도 되지 않음
    Assertions.assertEquals("https://127.0.0.1:18080/hotels/한국호텔", secondUri.toString());


    // 3. UriComponents 를 리턴하는 build() 이므로 내부적으로 인코딩하지 않기 때문에 별도의 인코딩해주는 케이스
    String variable2 = "한국호텔";
    String path2 = "/hotels/" + variable2;  // 템플릿 변수 없음

    URI thirdUri = UriComponentsBuilder.fromPath(path2)
        .scheme("https").host("127.0.0.1").port(18080)
        .build(false) // 받아온 인자값이 인코딩 되어있는지 여부에 따라 true/false 입력
        .encode() // 인코딩 
        .toUri();

    Assertions.assertEquals("https://127.0.0.1:18080/hotels/%ED%95%9C%EA%B5%AD%ED%98%B8%ED%85%94", thirdUri.toString());
  }
}

UriComponents build(boolean encoded)

package com.assu.study.chap09.config;

import org.apache.hc.client5.http.HttpRoute;
import org.apache.hc.client5.http.config.RequestConfig;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.HttpClientBuilder;
import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManager;
import org.apache.hc.core5.http.HttpHost;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

import java.util.concurrent.TimeUnit;

@Configuration
public class PoolingRestTemplateConfig {
  @Bean
  public PoolingHttpClientConnectionManager poolingHttpClientConnectionManager() {
    PoolingHttpClientConnectionManager manager = new PoolingHttpClientConnectionManager();
    manager.setMaxTotal(100); // 커넥션 풀에서 관리할 수 있는 총 커넥션 갯수, 여기서는 100개 설정
    manager.setDefaultMaxPerRoute(5); // 커넥션 풀에서 루트마다 관리할 수 있는 총 커넥션 갯수, 일반적으로 별도의 설정이 없다면 5개로 사용함

    // 터넥션 풀에서 특정 루트마다 관리할 수 있는 총 커넥션 개수 설정
    // defaultMaxPerRoute 설정을 덮어씀
    // 여기서는 http://10.192.10.111:8080 의 최대 커넥션 갯수는 10개로 설정
    HttpHost httpHost = new HttpHost("http", "10.192.10.111", 8080);
    manager.setMaxPerRoute(new HttpRoute(httpHost), 10);

    return manager;
  }

  @Bean
  public RequestConfig requestConfig() {
    return RequestConfig.custom()
        .setConnectionRequestTimeout(3000, TimeUnit.MILLISECONDS) // PoolingHttpClientConnectionManager 에서 커넥션을 요청해서 받기까지 걸리는 시간
        .setConnectTimeout(3000, TimeUnit.MILLISECONDS) // 서버와 클라이언트 사이의 커넥션을 생성하는 시간
        .setResponseTimeout(1000, TimeUnit.MILLISECONDS)  // HTTP 요청 메시지 전달 후 응답 메시지를 받기까지의 시간
        .build();
  }

  // 적절한 값으로 설정한 `PoolingHttpClientConnectionManager` 객체를 `CloseableHttpClient` 의 `setConnectionManager()` 메서드의 인자로 입력하면
  // `CloseableHttpClient` 는 `PoolingHttpClientConnectionManager` 에서 커넥션 객체를 받아 HTTP 통신을 함.
  @Bean
  public CloseableHttpClient httpClient() {
    // HttpClientBuilder 를 사용하여 CloseableHttpClient 객체 생성
    // 위에서 생성한 PoolingHttpClientConnectionManager 스프링 빈과 RequestConfig 스프링 빈을 주입받아 CloseableHttpClient 스프링 빈 생성
    return HttpClientBuilder.create()
        .setConnectionManager(poolingHttpClientConnectionManager())
        .setDefaultRequestConfig(requestConfig())
        .build();
  }

  // 커넥션 풀을 사용하는 CloseableHttpClient 를 사용하고자 HttpComponentsClientHttpRequestFactory 객체를 생성
  // 그리고 이를 사용하는 RestTemplate 스프링 빈 생성
  @Bean
  public RestTemplate poolingRestTemplate() {
    HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
    requestFactory.setHttpClient(httpClient());
    return new RestTemplate(requestFactory);
  }
}

@Bean
public PoolingHttpClientConnectionManager poolingHttpClientConnectionManager() {
  PoolingHttpClientConnectionManager manager = new PoolingHttpClientConnectionManager();
  manager.setMaxTotal(100); // 커넥션 풀에서 관리할 수 있는 총 커넥션 갯수, 여기서는 100개 설정
  manager.setDefaultMaxPerRoute(5); // 커넥션 풀에서 루트마다 관리할 수 있는 총 커넥션 갯수, 일반적으로 별도의 설정이 없다면 5개로 사용함
  
  // 터넥션 풀에서 특정 루트마다 관리할 수 있는 총 커넥션 개수 설정
  // defaultMaxPerRoute 설정을 덮어씀
  // 여기서는 http://10.192.10.111:8080 의 최대 커넥션 갯수는 10개로 설정
  HttpHost httpHost = new HttpHost("http", "10.192.10.111", 8080);
  manager.setMaxPerRoute(new HttpRoute(httpHost), 10);
  
  return manager;
}

WebClient webClient1 = WebClient.create();
WebClient webClient2 = WebClient.create("http://127.0.0.1:8080");
WebClient webClient3 = WebClient.builder().build();

package com.assu.study.chap09.config;

import io.netty.channel.ChannelOption;
import io.netty.handler.timeout.ReadTimeoutHandler;
import io.netty.handler.timeout.WriteTimeoutHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.client.reactive.ClientHttpConnector;
import org.springframework.http.client.reactive.ReactorClientHttpConnector;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.netty.http.client.HttpClient;

@Slf4j
@Component
public class WebClientConfig {
  @Bean
  public WebClient webClient() {
    // tcpConfiguration() 는 deprecated 됨
//    HttpClient httpClient = HttpClient.create()
//        .tcpConfiguration(tcpClient ->
//            tcpClient.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 10000) // 커넥션을 생성하는 최대 시간
//                .doOnConnected(conn ->
//                    conn.addHandlerLast(new ReadTimeoutHandler(10)) // 서버의 응답 메시지를 읽는데 걸리는 최대 시간 (s)
//                        .addHandlerLast(new WriteTimeoutHandler(10))  // 서버에 데이터를 전송할 때 걸리는 최대 시간 (s)
//                )
//        );
    HttpClient httpClient = HttpClient.create()
            .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 10000) // 커넥션을 생성하는 최대 시간
            .doOnConnected(conn ->
                    conn.addHandlerLast(new ReadTimeoutHandler(10))   // 서버의 응답 메시지를 읽는데 걸리는 최대 시간 (s)
                            .addHandlerLast(new WriteTimeoutHandler(10))  // 서버에 데이터를 전송할 때 걸리는 최대 시간 (s)
            );

    // 생성한 HttpClient 객체를 하용하여 ClientHttpConnector 객체 생성
    // wiretap() 메서드를 사용하여 요청 메시지와 응답 메시지 전체를 로깅할 수 있음
    // 단, 로그 설정 파일에 logging.level.reactor.netty.http.client=DEBUG 레벨로 설정해야 함
    ClientHttpConnector connector = new ReactorClientHttpConnector(httpClient.wiretap(true));

    return WebClient.builder()
            .baseUrl("http://localhost:8080") // REST-API 의 기본 URL
            .clientConnector(connector)
            .defaultHeaders(httpHeaders -> {
              httpHeaders.add(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);
              httpHeaders.add(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON_VALUE);
            })
            .build();
  }
}

package com.assu.study.chap09.adapter;

import com.assu.study.chap09.controller.ApiResponse;
import com.assu.study.chap09.controller.CreateCodeRequest;
import com.assu.study.chap09.controller.CreateCodeResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.client.WebClient;
import org.springframework.web.util.UriComponentsBuilder;
import reactor.core.publisher.Mono;

import java.net.URI;
import java.util.List;

@Slf4j
@Component
public class WebClientBillingAdapter {
  private static final ParameterizedTypeReference<ApiResponse<CreateCodeResponse>> TYPE_REFERENCE;

  static {
    TYPE_REFERENCE = new ParameterizedTypeReference<>() {
    };
  }

  private final WebClient webClient;

  public WebClientBillingAdapter(WebClient webClient) {
    this.webClient = webClient;
  }

  public CreateCodeResponse createWithWebClient(List<Long> hotelIds) {
    URI uri = UriComponentsBuilder.fromPath("/billing-codes")
        .scheme("http").host("127.0.0.1").port(8080)
        .build(false).encode().toUri();

    CreateCodeRequest request = new CreateCodeRequest(1, hotelIds);

    return webClient.mutate().build()   // mutate() 메서드로 WebClient.Builder 를 다시 사용할 수 있음을 보여줌, 설정 후 build() 메서드를 다시 호출하면 다시 WebClient 객체 리턴받음
        .method(HttpMethod.POST).uri(uri)   // 기존에 WebClientConfig 에서 설정한 baseUrl() 설정이 있더라도 덮어씀
        .bodyValue(request) // HTTP 요청 메시지의 바디 부분 설정
        .retrieve()   // 서버의 REST-API 실행
        .onStatus(httpStatus -> HttpStatus.OK != httpStatus,  // HTTP 의 상태 코드를 이용하여 에러 처리
            response -> Mono.error(new RuntimeException("Error from Billing. " + response.statusCode().value())))
        .bodyToMono(TYPE_REFERENCE) // ParameterizedTypeReference 상수를 사용하여 바디를 Mono 로 응답
        .flux().toStream()    // 리턴받은 Mono 를 Flux 로 변환한 후 다시 Stream 객체로 변환
        .findFirst()
        .map(ApiResponse::getData)
        .orElseThrow(() -> new RuntimeException("Empty response"));
  }
}

package com.assu.study.chap09;

import com.assu.study.chap09.adapter.WebClientBillingAdapter;
import com.assu.study.chap09.controller.CreateCodeResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

import java.util.List;

@Slf4j
@SpringBootApplication
public class Chap09Application2 {

  public static void main(String[] args) {
    ConfigurableApplicationContext ctx = SpringApplication.run(Chap09Application2.class, args);

    WebClientBillingAdapter adapter = ctx.getBean(WebClientBillingAdapter.class);
    CreateCodeResponse codeResponse = adapter.createWithWebClient(List.of(19000L, 18000L, 17000L));

    // Result : CreateCodeResponse(codes=[19000, 18000, 17000])
    log.info("Result : {}", codeResponse);
  }
}