일단 씻고 나가자
[스프링 부트 핵심 가이드] 12. 서버 간 통신 본문
(본 포스팅은 해당 도서의 정리 및 개인 공부의 목적 포스팅임을 밝힙니다.)
장정우, 『스프링 부트 핵심 가이드 : 스프링 부트를 활용한 애플리케이션 개발 실무』, 위키북스, 2022
12. 서버 간 통신
최근 서비스들은 마이크로서비스 아키텍쳐(Micro Service Architecture)를 주로 채택하고 있다.
마이크로서비스 아키텍쳐란 모놀리식 아키텍쳐(Monolithic Architecture) 개념과 대응하는 개념인데,
모놀리식은 전통적인 단일 시스템에 모든 기능과 컴포넌트, 서버를 통째로 담아두고 운영하는 구조로
단순한 구조 덕에 운영환경이 용이하지만 규모가 커질수록 빌드와 배포에 시간이 소모되는 단점이 있는 구조이며
마이크로서비스 아키텍쳐는 하나의 애플리케이션을 작은 단위의 서비스 모듈로 나누어 개별 프로세스로 독립적으로 역할을 수행하는 구조이다.
즉, MSA는 애플리케이션이 가지고 있는 기능이 하나의 비즈니스 범위만 가지는 형태이고, 각 애플리케이션이 자신의 API를 노출하여 다른 서버가 그 API를 활용하여 통신하는 구조를 가지고 있다.
이번 장에서는 그러한 트렌드에 맞춰 다른 서버로 웹 요청을 보내고 응답을 받을 수 있게 도와주는 RestTemplate과 WebClient에 대해 살펴본다.
참고 사이트
https://dreamcoding.tistory.com/65
12.1 RestTemplate이란?
RestTemplate이란 HTTP 서버와의 통신을 단순화한 스프링에서 제공하는 템플릿으로,
RESTful 원칙을 따르는 서비스를 편리하게 만들 수 있게 도와준다.
기본적으로 동기 방식으로 지원하며, AsyncRestTemplate을 이용하면 비동기 방식으로 활용할 수 있다.
단 RestTemplate은 현업에선 주로 사용되지만 지원 중단(deprecated)된 상태이므로 향후 대체하게 될 WebClient 방식도 함께 숙지해두어야 한다.
RestTemplate의 특징은 다음과 같다.
- HTTP 프로토콜 메서드에 맞는 여러 메서드 제공
- RESTful 형식을 갖춤
- HTTP 요청으로 JSON, XML, 문자열 등 다양한 형식의 응답을 받을 수 있음
- 블로킹(blocking) I/O 기반의 동기 방식
- 다른 API 호출 시 HTTP 헤더에 다양한 값 설정 가능
12.1.1 RestTemplate의 동작 원리
RestTemplate의 동작을 도식화하면 다음과 같다. 순서대로 살펴보자.
(1) 우선 Application에서 시작하며, Application은 개발자가 작성하는 코드부를 의미한다. 개발자는 코드에서 REST API에의 요청을 위해 RestTemplate을 선언하고 URI와 HTTP 메서드, Body 등을 설정한다.
(2) RestTemplate은 요청을 위해 HttpMessageConverter를 통해 RequestEntity를 요청 메세지로 변환한다. RequestEntity란 자바 객체를 request body에 담을 메세지 형태(JSON 등)를 의미한다.
(3) RestTemplate은 ClientHttpRequestFactory에서 ClientHttpRequest 객체를 만들어 (2)에서 만든 메세지를 전달한다.
(4) (3)에서 만들어진 ClientHttpRequest 객체가 실질적으로 HTTP 통신의 요청을 수행하며, 외부 API로 요청을 보낸다.
(5) 요청에 대한 응답을 외부에서 받게 되면, RestTemplate은 ResponseErrorHandler로 오류를 확인한다.
(6) ClientHttpResponse에서 응답 데이터를 받으며, 오류가 있을 시 처리한다.
(7) 응답 데이터가 정상이라면 HttpMessageConverter에 응답 데이터를 전달하여 자바 객체로 변환한다.
(8) 변환된 자바 객체를 Application에 전달한다.
참고 사이트
https://dejavuhyo.github.io/posts/spring-resttemplate/
12.1.2 RestTemplate의 대표적인 메서드
RestTemplate은 외부 API에 요청의 편의성을 위해 다음과 같은 메서드를 제공한다.
| 메서드 | HTTP 형태 | 설명 |
| getForObject | GET | GET 형식으로 요청한 결과를 객체로 반환 |
| getForEntity | GET | GET 형식으로 요청한 결과를 ResponseEntity 객체로 반환 |
| postForLocation | POST | POST 형식으로 요청한 결과를 헤더에 저장된 URI로 반환 |
| postForObject | POST | POST 형식으로 요청한 결과를 객체로 반환 |
| postForEntity | POST | POST 형식으로 요청한 결과를 ResponseEntity 객체로 반환 |
| delete | DELETE | DELETE 형식으로 요청 |
| put | PUT | PUT 형식으로 요청 |
| patchForObject | PATCH | PATCH 형식으로 요청한 결과를 객체로 반환 |
| optionsForAllow | OPTIONS | 해당 URI에서 지원하는 HTTP 메서드를 조 |
| exchange | any | HTTP 헤더를 임의로 추가할 수 있고, 어떤 메서드 형식에서도 사용할 수 있음 |
| execute | any | 요청과 응답에 대한 콜백을 수정 |
12.2 RestTemplate 사용하기
실습을 위해 프로젝트를 생성한다. 이번 실습은 서버간의 통신을 확인하기 위해 요청을 받는 프로젝트를 생성하고 다른 프로젝트에서 RestTemplate을 통해 요청을 보내는 방식으로 진행한다.
12.2.1 서버 프로젝트 생성하기
우선 요청을 받는 프로젝트를 생성한다. 같은 컴퓨터 내에서 요청을 보내고 요청을 받는 두 개의 서버를 실행하여야 하므로 톰캣의 포트를 변경하여야 한다. start.spring.io에서 다음과 같이 설정하여 생성 후, 인텔리제이에서 [open] 한다.
본 책에서는 spring-boot-starter-web의 의존성만을 추가했으나, 이후 dto 작성의 편의성을 위해 lombok까지 추가하였다.
이후 다음과 같이 작성한다. 우선 application.properties에 서버를 나누기 위해 다른 포트를 연결한다.
마찬가지로 controller 패키지를 생성하고 내부에 CrudController를, dto 패키지를 생성하고 내부에 MemberDto 클래스를 다음과 같이 작성한다.
package com.springboot.serverbox.controller;
import com.springboot.serverbox.dto.MemberDto;
import org.springframework.http.*;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("api/v1/crud-api")
public class CrudController {
@GetMapping
public String getName() { return "Flature"; }
@GetMapping(value = "/{variable}")
public String getVariable(@PathVariable String variable) { return variable; }
@GetMapping("/param")
public String getNameWithParam(@RequestParam String name){ return "Hello, " + name + "!"; }
@PostMapping
public ResponseEntity<MemberDto> getMember(
@RequestBody MemberDto request,
@RequestParam String name,
@RequestParam String email,
@RequestParam String organization
) {
System.out.println(request.getName());
System.out.println(request.getEmail());
System.out.println(request.getOrganization());
MemberDto memberDto = MemberDto.builder()
.name(name)
.email(email)
.organization(organization)
.build();
return ResponseEntity.status(HttpStatus.OK).body(memberDto);
}
@PostMapping(value = "/add-header")
public ResponseEntity<MemberDto> addHeader(@RequestHeader("my-header") String header,
@RequestBody MemberDto memberDto) {
System.out.println(header);
return ResponseEntity.status(HttpStatus.OK).body(memberDto);
}
}
package com.springboot.serverbox.dto;
import lombok.*;
@Getter
@Setter
@ToString
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class MemberDto {
private String name;
private String email;
private String organization;
}
컨트롤러의 코드는 각각 GET 방식에서 파라미터를 받는 종류별 메서드와, POST 방식에서 RequestParameter/Body를 함께 받는 방식과 임의의 HTTP 헤더를 받는 방식의 메서드로 구성되어 있다.
(+) Exception
12.2.2 부분 실습까지 실행한 후에 통신을 연결해보니 이상하게 post 관련 메서드만 swagger에서 정상 작동하지 않았다.
첫 번째 이유는 getMember() 부분에서 name, email, organization 부분을 @RequestParam이 아닌 @RequestBody로 선언한 이유였고, 해당 부분을 수정하고 다시 시도하였으나 이번엔 invaliddefinitionexception cannot deserialize from object value 에러가 나와버렸다.
결과적으로 해당 에러는 빈 생성자를 선언해주지 않아서 생긴 에러로, jackson 라이브러리가 JSON 데이터를 자바 객체로 바꾸는 시점에서 빈 생성자에 대한 선언이 없기 때문에 발생하는 에러라고 한다.
최종적으로 DTO 부분에서 @NoArgsConstructor, @AllArgsConstructor을 선언하므로써 해결하였으며, 아마 lombok을 사용하다보니 발생하지 않았을까 추측한다.
해당 에러를 해결하다 알게 된 좋은 사이트를 소개한다. 첫 번째는 기본적인 본 책의 코드를 담고 있는 git 주소이며, 두 번째는 두 텍스트 간의 차이를 알려주는 사이트로 실습 중 알 수 없는 에러를 만났을 때 유용하다. (처음에 나타는 유료 결제는 무시하고 진행하면 된다.)
- https://github.com/wikibook/springboot (위키북스 실습 코드 git 주소)
- https://www.diffchecker.com/text-compare/ (두 텍스트 간 차이를 알려주는 사이트)
추가로, 상위의 코드는 모든 에러를 해결한 최종 코드이다.
참고 사이트
https://velog.io/@tritny6516/Spring-cannot-deserialize-from-Object-value-%EC%97%90%EB%9F%AC
12.2.2 RestTemplate 구현하기
일반적으로 RestTemplate은 별도의 유틸리티 클래스로 생성하거나 서비스 또는 비즈니스 계층에 구현된다.
RestTemplate을 구현하는 서버는 다른 서버와 마찬가지로 클라이언트의 요청을 컨트롤러에서 받으면서,
구현된 RestTemplate으로 다른 서버의 컨트롤러와 통신한다.
위에서 생성한 프로젝트(서버)에 요청을 날리면서 또한 서버의 역할 또한 수행하는 새로운 프로젝트를 생성한다.
start.spring.io에서 다음과 같이 설정하여 생성 후, 인텔리제이에서 [open] 한다.
이후 원활한 클라이언 실습을 위해 이전에 작성했던 config 패키지와 SwaggerConfiguration 클래스를 가져온다.
swagger을 원활히 구성하기 위한 springfox 의존성도 pom.xml에 추가해준다. 코드는 다음과 같다.
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>2.9.2</version>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>2.9.2</version>
</dependency>해당 코드를 <dependencies> 내부에 붙여넣으면 되며, 최상단의 <parent>.<version> 또한 2.5.2로 맞춰주자.
서버 간 통신에서 데이터의 통일성을 위해, serverbox 프로젝트에서 작성했던 dto.MemberDto 클래스를 가져온다.
dto 패키지를 생성하고 하위에 MemberDto 클래스를 작성한다.
package com.springboot.rest.dto;
import lombok.Builder;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
@Getter
@Setter
@ToString
@Builder
public class MemberDto {
private String name;
private String email;
private String organization;
}
GET 형식의 RestTemplate 작성하기
프로젝트에 service 패키지를 생성하고, 하위에 RestTemplateService 클래스를 다음과 같이 작성한다.
package com.springboot.rest.service;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.util.UriComponentsBuilder;
import java.net.URI;
@Service
public class RestTemplateService {
public String getName() {
URI uri = UriComponentsBuilder
.fromUriString("http://localhost:9090")
.path("/api/v1/crud-api")
.encode()
.build()
.toUri();
RestTemplate restTemplate = new RestTemplate();
ResponseEntity<String> responseEntity = restTemplate.getForEntity(uri, String.class);
return responseEntity.getBody();
}
public String getNameWithPathVariable() {
URI uri = UriComponentsBuilder
.fromUriString("http://localhost:9090")
.path("/api/v1/crud-api/{name}")
.encode()
.build()
.expand("Flatue") // 복수의 값 추가 경우 , 로 추가하여 구분
.toUri();
RestTemplate restTemplate = new RestTemplate();
ResponseEntity<String> responseEntity = restTemplate.getForEntity(uri, String.class);
return responseEntity.getBody();
}
public String getNameWithParameter() {
URI uri = UriComponentsBuilder
.fromUriString("http://localhost:9090")
.path("/api/v1/crud-api/param")
.queryParam("name", "Flature")
.encode()
.build()
.toUri();
RestTemplate restTemplate = new RestTemplate();
ResponseEntity<String> responseEntity = restTemplate.getForEntity(uri, String.class);
return responseEntity.getBody();
}
}
RestTemplate의 생성과 사용 방법은 다양하지만, 우리는 그 중 스프링 프레임워크에서 제공하는 UriComponentsBuilder를 통하여 URI를 생성하는 방식으로 실습해본다.
코드에 대한 설명은 다음과 같다.
getName() 메서드는 path variable 방식이나 파라미터를 이용하지 않는 방식으로, fromUriString()으로 호출부의 URL을 입력하고 path()에 세부 경로를 입력한다. encode()는 인코딩 문자셋을 설정하는 방식으로, 인자가 없을 시 UTF-8이 기본적으로 설정된다. build() 이후에 toUri() 혹은 toUriString() 메서드를 통해 리턴 형식을 지정하면 된다.
이렇게 생성된 uri는 RestTemplate의 인자로 활용되며, getForEntity()를 통해 ResponseEntity 형식으로 return 된 것을 볼 수 있다.
getNameWithPathVariable() 메서드는 path variable을 사용한 방식으로, path()에서 {}를 통해 변수명을, expand()에서 중괄호에 해당하는 값을 입력한다. 여러개를 입력할 때는 콤마로 구분하여 나열한다.
getNameWithParameter() 메서드는 파라미터를 이용한 방식으로, queryParam() 메서드를 통해 (키, 값) 형식으로 파라미터를 추가한다.
POST 형식의 RestTemplate 작성
service 패키지 하위의 RestTemplateService 클래스에 다음과 같이 이어서 작성한다.
public ResponseEntity<MemberDto> postWithParamAndBody() {
URI uri = UriComponentsBuilder
.fromUriString("http://localhost:9090")
.path("/api/v1/crud-api")
.queryParam("name", "Flature")
.queryParam("email", "flature@wikibooks.co.kr")
.queryParam("organization", "Wikibooks")
.encode()
.build()
.toUri();
MemberDto memberDto = MemberDto.builder()
.name("flature!!")
.email("flature@gmail.com")
.organization("Around Hub Studio")
.build();
RestTemplate restTemplate = new RestTemplate();
ResponseEntity<MemberDto> responseEntity = restTemplate.postForEntity(uri, memberDto, MemberDto.class);
return responseEntity;
}
public ResponseEntity<MemberDto> postWithHeader() {
URI uri = UriComponentsBuilder
.fromUriString("http://localhost:9090")
.path("/api/v1/crud-api/add-header")
.encode()
.build()
.toUri();
MemberDto memberDto = MemberDto.builder()
.name("flature")
.email("flature@wikibooks.co.kr")
.organization("Around Hub Studio")
.build();
RequestEntity<MemberDto> requestEntity = RequestEntity
.post(uri)
.header("my-header", "Wikibooks API")
.body(memberDto);
RestTemplate restTemplate = new RestTemplate();
ResponseEntity<MemberDto> responseEntity = restTemplate.exchange(requestEntity, MemberDto.class);
return responseEntity;
}postWithParamAndBody() 메서드는 POST 형식의 API 요청으로, body 값과 파라미터 값을 담는 두 방법을 모두 보여준다.
URI 객체를 초기화하는 부분에서는 파라미터에 값을 추가하고, MemberDto를 초기화하는 부분에서는 RequestBody에 데이터를 담으며, 최종적으로 ReqeustBody에 값을 담기 위해 데이터 객체를 생성한다.
postWithHeader() 메서드 역시 POST 형식의 API 요청으로, 대부분의 외부 API는 토큰키를 받아 서비스 접근을 인증하는 방식으로 사용되는데 이때 토큰값을 헤더에 담아 전달하는 방식으로 사용된다. 헤더 설정은 RequestEntity를 정의하는 방법이 가장 편하며, 코드에서 RequestEntity를 초기화하는 부에서 .header() 메서드를 통해 키 이름과 값을 설정한다.
.post() 메서드는 매개변수로 받는 URI를 POST 형식으로 설정하여 값을 겠다는 의미이다.
마지막으로 모든 형식의 HTTP 요청을 생성할 수 있는 RestTemplate의 exchange() 메서드를 통해 ResponseEntity로 형식을 바꾸어주었다.
이후에 해당 서비스 코드를 연결하는 컨트롤러 코드를 설정한다.
contorller 패키지를 생성하고, 하위에 RestTemplateController 클래스를 다음과 같이 작성한다.
package com.springboot.rest.controller;
import com.springboot.rest.dto.MemberDto;
import com.springboot.rest.service.RestTemplateService;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/rest-template")
public class RestTemplateController {
private final RestTemplateService restTemplateService;
RestTemplateController(RestTemplateService restTemplateService){
this.restTemplateService = restTemplateService;
}
@GetMapping
public String getName() {
return restTemplateService.getName();
}
@GetMapping("/path-variable")
public String getNameWithPathVariable() {
return restTemplateService.getNameWithPathVariable();
}
@GetMapping("/parameter")
public String getNameWithParameter() {
return restTemplateService.getNameWithParameter();
}
@PostMapping
public ResponseEntity<MemberDto> postDto() {
return restTemplateService.postWithParamAndBody();
}
@PostMapping("/header")
public ResponseEntity<MemberDto> postWithHeader() {
return restTemplateService.postWithHeader();
}
}
이후 swagger에서 [Try it out]을 실습하면 올바른 status가 반환되고, serverbox 프로젝트의 콘솔창에 해당 내용이 잘 나타남을 확인할 수 있다.
12.2.3 RestTemplate 커스텀 설정
RestTemplate은 HTTPClient를 추상화하고 있는데, HTTPClient의 종류에 따라 각 기능의 세부 차이가 존재한다. RestTemplate은 기본적으로 커넥션 풀(Connection Pool)을 지원하지 않는다. 이때 커넥션 풀이란 웹 애플리케이션과 데이터베이스 사이에 존재하는 일종의 캐시로서, 미리 커넥션을 미리 만들어놓고 pool로 관리하여 필요할 때마다 커넥션을 이용하고 반납할 수 있도록하여 데이터베이스 연결 시 많이 사용되는 자원을 중간단에서 줄여준다.
참고 사이트
https://code-lab1.tistory.com/209
커넥션 풀을 이용하지 못하는 RestTemplate은 호출 시마다 포트를 열고 커넥션을 연결하므로, TIME_WAIT 상태의 소켓을 재사용할 수 없다. 이를 방지하기 위해 커넥션 풀 기능을 활성화하여 재사용이 가능하도록 하는 실습을 진행해보자. 이때 사용할 수 있는 대표적인 방법 중 하나가 아파치에서 제공하는 HTTPClient로 대체하여 사용하는 방법이다.
우선 아파치의 HTTPClient를 사용하기 위해 다음과 같이 pom.xml에 의존성을 추가해준다.
이후 작성했었던 service 패키지의 RestTemplateService 클래스를 다음과 같이 수정한다.
RestTemplate은 생성자로 ClientHttpRequestFactory를 매개변수로 받을 수 있으며, 이때 ClientHttpRequestFactory는 함수형 인터페이스로 대표적으로 SimpleClientHttpRequestFactory와 HttpComponentsClientHttpRequestFactory 구현체가 존재한다. 별도의 구현체를 지정하지 않으면 HttpAccessor에 따라 SimpleClientHttpRequestFactory를 사용한다.
커넥션 풀을 사용하기 위해 HttpComponentsClientHttpRequestFactory의 setHttpClient()를 통해 클라이언트를 설정해야하며, 클라이언트를 생성하는 방법은 HttpClient와 CloseableHttpClient 두 가지 방법이 있다.
이렇게 생성된 클라이언트를 factory에 연결해주면 HttpClient에 의해 .setReadTimeout() 메서드로 time out을 설정할 수 있게 되며, 설정을 마친 factory를 RestTemplate의 초기화 시에 생성자의 인자로 전달하면 커넥션 풀을 사용할 수 있게 된다.
12.3 WebClient란?
일반적으로 실제 운영환경의 애플리케이션은 정식 버전의 스프링 부트 버전보다 낮으므로 RestTemplate을 주로 사용한다.
하지만 스프링이 최신 버전으로 넘어오며 RestTemplate의 지원이 중단되고 WebClient 사용을 권고하고 있으므로, 빈번히 사용되고 있는 RestTemplate과 WebClient를 모두 알고 있는 것이 중요하다.
Spring WebFlux는 HTTP 요청을 수행하는 클라이언트로 WebClient를 제공한다. WebClient는 리액터(Reactor) 기반의 API인데, 이때 리액터란 Reactive Programming으로 함수형 프로그래밍과 흡사한 스트림 특징의 방식이며 비동기 형식의 사용이 가능해진다.
WebClient의 특징은 다음과 같다.
- 논블로킹(Non-Blocking) I/O 지원
- 리액티브 스트림(Reactive Streams)의 백 프레셔(Back Pressure) 지원
- 적은 하드웨어 리소스로 동시성 지원
- 함수형 API 지원
- 동기, 비동기 상호작용 지원
- 스트리밍 지원
12.3.1 WebClient 구성
WebClient 사용을 위해, pom.xml WebFlux 의존성을 다음과 같이 추가한다. WebFlux는 클라이언트, 서버 간 리액티프 애플리케이션 지원을 위한 스프링 프레임워크 5에서 추가된 모듈이다.
12.4 WebClient 사용하기
이제 WebClient를 활용한 실습을 진행해보자. 다만 여태까지의 실습은 리액티브 프로그래밍을 염두한 프로젝트 코드가 아니었으므로 WebClient 기능의 온전한 사용에는 제약사항이 있다.
12.4.1 WebClient 구현
WebClient 생성에는 create(), builder() 두 메서드를 활용한 방식이 있다.
service 패키지 내에 WebClientService 클래스를 생성하고 다음과 같이 작성한다.
package com.springboot.rest.service;
import org.springframework.http.*;
import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;
@Service
public class WebClientService {
public String getName() {
WebClient webClient = WebClient.builder()
.baseUrl("http://localhost:9090")
.defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
.build();
return webClient.get()
.uri("/api/v1/crud-api")
.retrieve()
.bodyToMono(String.class)
.block();
}
public String getNameWithPathVariable() {
WebClient webClient = WebClient.create("http://loaclhost:9090");
ResponseEntity<String> responseEntity = webClient.get()
.uri(uriBuilder -> uriBuilder.path("/api/v1/crud-api/{name}").build("Flature"))
.retrieve().toEntity(String.class).block();
return responseEntity.getBody();
}
public String getNameWithParameter() {
WebClient webClient = WebClient.create("http://localhost:9090");
return webClient.get().uri(uriBuilder -> uriBuilder.path("/api/v1/crud-api")
.queryParam("name", "Flature")
.build())
.exchangeToMono(clientResponse -> {
if(clientResponse.statusCode().equals(HttpStatus.OK))
return clientResponse.bodyToMono(String.class);
else
return clientResponse.createException().flatMap(Mono::error);
})
.block();
}
}
기본적으로 WebClient 객체는 코드와 같이 객체를 생성하고 전달하는 방식으로 동작하며, 생성된 객체를 재사용하는 방식으로 구현하는 것이 좋다. 위에서 getName() 메서드는 builder()를 통해 객체를 생성했으며, 남은 두 메서드는 create()를 활용했다. builder()를 활용할 경우 defaultHeader(), defaultCookie(), defaultUriVariable(), filter() 등의 메서드로 WebClient 객체를 설정할 수 있다.
WebClient 객체는 빌드된 후엔 변경할 수 없으며, 다음과 같이 복제하여 사용할 수 있다.
WebClient clone = webClient.mutate().build();
getName()부터 살펴보며 WebClient의 특징에 대해 알아보자.
우선 WebClient는 .get/post/put/delete() 처럼 명확한 이름으로 HTTP 종류를 설정할 수 있으며, uri() 메서드로 URI를 확장할 수 있다. return 부의 retrieve() 메서드는 요청에 대한 응답의 값을 추출하는 방법 중 하나로, bodyToMono() 메서드의 매개변수를 통해 리턴 타입을 설정하여 받아올 수 있다. Mono는 Flux와 비교되는 개념으로, 리액티브 스트림에서 데이터를 제공하는 발행자 역할의 Publisher의 구현체이다. 추가로 WebClient는 기본적으로 non-blocking 방식의 동작이기 때문에 .block() 메서드를 통해 블로킹 구조로 바꾸어줄 수 있다.
getNameWithPathVariable()의 방식은 path variable 방식으로 요청을 전달한다. uri() 메서드 내부에서 uriBuilder를 사용하고 path를 설정할 수 있다. ResponseEntity를 구현하는 부분은 다음과 같이 간편하게 작성할 수 있다.
/*
ResponseEntity<String> responseEntity = webClient.get()
.uri(uriBuilder -> uriBuilder.path("/api/v1/crud-api/{name}").build("Flature"))
.retrieve().toEntity(String.class).block();
*/
ResponseEntity<String> responseEntity = webClient.get()
.uri("/api/v1/crud-api/{name}", "Flature")
.retrieve().toEntity(String.class).block();bodyByMono() 대신 toEntity() 메서드를 활용하였기 때문에 ResponseEntity 타입으로 응답을 전달 받을 수 있다.
getNameWithParameter() 메서드는 쿼리 파라미터를 함께 전달하는 방식으로 구현됐으며, uri() 메서드 내부의 uriBuilder를 통해 queryParam()으로 전달하려는 값을 설정한다. .exchange() 메서드는 지원 중단되었으므로 exchangeToMono/Flux()를 사용하는 것이 권장된다. 기본적으로 exchange는 응답 결과 코드에 따라 응답을 다르게 설정할 수 있으므로, 실습에선 if문 분기로 상황에 맞는 결괏값을 전달했다.
POST 요청 방식을 알아보기 위해, 위 실습 클래스의 service 패키지의 WebClientService 클래스에 다음과 같이 작성한다.
public ResponseEntity<MemberDto> postWithParamAndBody() {
WebClient webClient = WebClient.builder()
.baseUrl("http://localhost:9090")
.defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
.build();
MemberDto memberDto = MemberDto.builder()
.name("flature!!")
.email("flature@gmail.com")
.organization("Around Hub Studio")
.build();
return webClient
.post()
.uri(uriBuilder -> uriBuilder.path(("/api/v1/crud-api"))
.queryParam("name", "Flature")
.queryParam("email", "flature@wikibooks.co.kr")
.queryParam("organization", "Wikibooks")
.build())
.bodyValue(memberDto)
.retrieve()
.toEntity(MemberDto.class)
.block();
}
public ResponseEntity<MemberDto> postWithHeader() {
WebClient webClient = WebClient.builder()
.baseUrl("http://localhost:9090")
.defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
.build();
MemberDto memberDto = MemberDto.builder()
.name("flature!!")
.email("flature@gmail.com")
.organization("Around Hub Studio")
.build();
return webClient
.post()
.uri(uriBuilder -> uriBuilder.path("api/v1/crud-api/add-header").build())
.bodyValue(memberDto)
.header("my-header", "Wikibooks API")
.retrieve()
.toEntity(MemberDto.class)
.block();
}POST 방식은 위의 GET 방식과 유사하지만, HTTP 바디 값을 담는 방법과 커스텀 헤더를 추가하는 방식을 유의해야 한다.
우선 postWithParamBody() 메서드는 post() 방식으로 선언 후, uri() 메서드와 queryParam() 메서드를 통해 uri를 설정하고 bodyValue() 메서드를 통해 HTTP 바디 값을 전달했다. HTTP 바디 값으로는 일반적으로 데이터 객체(DTO, VO)를 파라미터로 전달한다.
postWithHeader() 메서드는 유사하게 작성되며 header() 메서드를 통해 헤더에 값을 추가했다. 일반적으로 임의로 추가한 헤더에는 외부 API의 인증 토큰 값을 담아 전달한다.
12.5 정리
웹 통신을 통한 다른 서버의 접근으로 RestTemplate과 WebClient를 사용하는 방법을 알아봤다.
실무에서 다른 서버로의 접근은 빈번하므로, 대체로 이번 장에서 사용한 모듈을 사용하여 구현하면 된다.
이후로는 통신 횟수, 접근하는 서버에 맞는 커넥션 풀 설정, 타임 아웃 등의 설정을 최적화하는 등의 심화 학습이 권장된다.
'Backend > Spring' 카테고리의 다른 글
| [스프링 부트 핵심 가이드] 13. 서비스 인증과 권한 부여 (0) | 2023.07.13 |
|---|---|
| [스프링 부트 핵심 가이드] 11. 액추에이터 활용하기 (0) | 2023.06.27 |
| [스프링 부트 핵심 가이드] 10. 유효성 검사와 예외 처리 (0) | 2023.06.21 |
| [스프링 부트 핵심 가이드] 09. 연관관계 매핑 (1) | 2023.06.14 |
| [스프링 부트 핵심 가이드] 08. Spring Data JPA 활용 (0) | 2023.06.08 |
