HTTP X SpringBoot - RestTemplate & WebClient

HTTP 요청 메시지와 자바 웹개발

•

HTTP 메시지의 헤더 정보에는 요청하는 리소스의 타입, 길이, 인코딩 방식 등의 정보가 포함될 수 있습니다.

•

Java에서는 HttpURLConnection 클래스를 사용하여 HTTP 요청을 보낼 수 있습니다. 예시 코드에서는 GET 요청을 보내는 방법을 보여줍니다.

•

또한, Spring Boot에서는 RestTemplate과 WebClient를 사용하여 HTTP 요청을 보낼 수 있습니다. 

Java 에서 HTTP 요청 보내기

: HttpURLConnection 클래스를 사용하여, 요청을 보내기

예시코드

import java.net.HttpURLConnection;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class HttpURLConnectionExample {
    public static void main(String[] args) {
        try {
            URL url = new URL("https://api.example.com/data");
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");

            BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            StringBuilder response = new StringBuilder();
            String line;

            while ((line = reader.readLine()) != null) {
                response.append(line);
            }
            reader.close();

            System.out.println("Response: " + response.toString());
            connection.disconnect();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
Java
복사

Spring Boot 에서 HTTP 요청 보내기

1. RestTemplate을 사용한 HTTP 요청

RestTemplate은 Spring에서 제공하는 간단한 HTTP 통신을 위한 클래스입니다. 다양한 HTTP 메서드(GET, POST, PUT, DELETE 등)를 사용하여 요청을 보낼 수 있습니다.

의존성

maven

•

pom.xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
XML
복사

gradle

•

build.gradle

implementation 'org.springframework.boot:spring-boot-starter-web'
Plain Text
복사

예시코드

import org.springframework.web.client.RestTemplate;
import org.springframework.http.ResponseEntity;

// RestTemplate 객체 생성
RestTemplate restTemplate = new RestTemplate();

// GET 요청 보내기
String url = "https://api.example.com/data";
ResponseEntity<String> response = restTemplate.getForEntity(url, String.class);

// POST 요청 보내기
String postUrl = "https://api.example.com/data";
String requestData = "{ \"key\": \"value\" }";
ResponseEntity<String> postResponse = restTemplate.postForEntity(postUrl, requestData, String.class);
Java
복사

2. WebClient을 사용한 HTTP 요청

WebClient는 비동기적이고 리액티브한 방식으로 HTTP 요청을 보낼 수 있는 라이브러리입니다.

의존성

maven

•

pom.xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>
XML
복사

gradle

•

build.gradle

implementation 'org.springframework.boot:spring-boot-starter-webflux'
Plain Text
복사

예시코드

import org.springframework.web.reactive.function.client.WebClient;

// WebClient 객체 생성
WebClient webClient = WebClient.create();

// GET 요청 보내기
webClient.get()
    .uri("https://api.example.com/data")
    .retrieve()
    .bodyToMono(String.class)
    .subscribe(response -> {
        // 요청 후 처리할 내용
    });

// POST 요청 보내기
webClient.post()
    .uri("https://api.example.com/data")
    .bodyValue("{ \"key\": \"value\" }")
    .retrieve()
    .bodyToMono(String.class)
    .subscribe(response -> {
        // 요청 후 처리할 내용
    });
Java
복사

RestTemplate vs WebClient 비교

RestTemplate은 Spring 애플리케이션에서 일반적으로 사용되는 동기식 HTTP 클라이언트로, HTTP 요청을 보내고 응답을 받는 간단하고 편리한 방법을 제공합니다.

반면에 WebClient는 Spring 5에서 소개된 비동기식, 리액티브 HTTP 클라이언트로, 리액티브 프로그래밍 모델과 함께 작동하도록 설계되어 있으며 RestTemplate에 비해 더 나은 성능을 제공합니다.

RestTemplate은 여전히 널리 사용되고 있지만, 새로운 프로젝트에서는 현대적인 웹 애플리케이션의 리액티브 및 비동기적인 특성과 더욱 일치하는 WebClient를 사용하는 것이 권장됩니다.

그러나, RestTemplate과 WebClient 모두 Spring Boot 애플리케이션에서 HTTP 요청을 보내고 응답을 처리하는 데 효과적으로 사용될 수 있습니다. 두 방법 중 선택은 애플리케이션의 특정 요구사항과 디자인에 따라 다를 수 있습니다.

RestTemplate은 Spring 5에서는 주로 WebClient로 대체되고 있습니다. WebClient는 리액티브(non-blocking) 방식으로 동작하여 성능상 이점을 가집니다.

resttesttest.com

HTTP 요청 테스트 사이트

REST test test...

Method and Endpoint are required. Click below to add additional parameters.

https://resttesttest.com/

httpbin

HTTP 요청을 테스트하고 디버깅하는 데 사용되는 무료 온라인 서비스입니다. 이 사이트를 사용하면 다양한 유형의 HTTP 요청을 보낼 수 있으며, 해당 요청에 대한 다양한 유형의 응답을 받을 수 있습니다.

GET 요청 확인

•

https://httpbin.org/get: 기본 GET 요청을 보냅니다.

•

https://httpbin.org/anything: 전송된 모든 것을 반환합니다.

POST 요청 확인

•

https://httpbin.org/post: 전송된 데이터를 반환합니다.

기타 유용한 기능

•

https://httpbin.org/status/{상태 코드}: 지정된 HTTP 상태 코드를 반환합니다.

•

https://httpbin.org/headers: 클라이언트로부터 전송된 헤더를 반환합니다.

•

https://httpbin.org/cookies: 클라이언트로부터 수신된 쿠키를 반환합니다.

•

https://httpbin.org/ip: 클라이언트의 IP 주소를 반환합니다.

RestTemplate, WebClient 을 이용한 HTTP 요청 실습

•

프로젝트 구조

•

프로젝트 환경

•

작업 파일

•

실행 결과

프로젝트 구조

spring-http/ ├── src/ │ ├── main/ │ │ ├── java/ │ │ │ └── com/ │ │ │ └── joeun/ │ │ │ └── springhttp/ │ │ │ ├── dto/ │ │ │ │ └── HttpResponse.java │ │ │ ├── ServletInitializer.java │ │ │ └── SpringHttpApplication.java │ ├── resources/ │ │ ├── application.properties │ │ ├── static/ │ │ └── templates/ └── build.gradle

프로젝트 환경

•

Spring boot version : 3.3.5

•

Group Id : com.aloha

•

Artifact Id : spring-http

•

Java version : JDK 17

•

Packaging : WAR

•

Dependency

◦

Spring Web

◦

Spring Reactive Web

◦

Spring Dev Tools

◦

Lombok

작업 파일

•

build.gradle

•

HttpResponse.java

•

SpringHttpApplication.java

•

build.gradle

dependencies {
	implementation 'org.springframework.boot:spring-boot-starter-web'
	implementation 'org.springframework.boot:spring-boot-starter-webflux'
	compileOnly 'org.projectlombok:lombok'
	developmentOnly 'org.springframework.boot:spring-boot-devtools'
	annotationProcessor 'org.projectlombok:lombok'
	providedRuntime 'org.springframework.boot:spring-boot-starter-tomcat'
	testImplementation 'org.springframework.boot:spring-boot-starter-test'
	testImplementation 'io.projectreactor:reactor-test'
}
SQL
복사

•

HttpResponse.java

package com.aloha.springhttp.dto;

import java.util.Map;

import lombok.Data;

@Data
public class HttpResponse {
    private Map<String, String> args;
    private Map<String, String> headers;
    private String origin;
    private String url;
}
Java
복사

•

SpringHttpApplication.java

package com.aloha.springhttp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.client.WebClient;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.aloha.springhttp.dto.HttpResponse;

@SpringBootApplication
public class SpringHttpApplication {

	public static void main(String[] args) throws Exception {
		SpringApplication.run(SpringHttpApplication.class, args);

		restTemplate();
		restTemplateToObject();
		webClient();
		webClientToObject();
	}


	/**
	 * RestTemplate 을 사용한 HTTP 요청
	 */
	public static void restTemplate() {
		System.out.println("########### RestTemplate ###########\n");
		RestTemplate restTemplate = new RestTemplate();

		// GET 요청
        String getUrl = "https://httpbin.org/get";
        String response = restTemplate.getForObject(getUrl, String.class);

        System.out.println("########### GET Response ########### \n" + response);

		// POST 요청
		HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);

        String postUrl = "https://httpbin.org/post";
        String requestData = "{key: value}";
        HttpEntity<String> request = new HttpEntity<>(requestData, headers);

        String postResponse = restTemplate.postForObject(postUrl, request, String.class);

        System.out.println("########### POST Response ########### \n" + postResponse);

	}

	/**
	 * RestTemplate 요청 -> 응답 -> 객체로 변환하기
	 * @throws JsonProcessingException
	 */
	public static void restTemplateToObject() throws JsonMappingException, JsonProcessingException {
		RestTemplate restTemplate = new RestTemplate();
        ObjectMapper objectMapper = new ObjectMapper();
		
        // GET 요청
        String getUrl = "https://httpbin.org/get";
        ResponseEntity<String> getResponseEntity = restTemplate.getForEntity(getUrl, String.class);
        String getResponseBody = getResponseEntity.getBody();
		
		HttpResponse httpResponse = objectMapper.readValue(getResponseBody, HttpResponse.class);
		System.out.println("########### Response to Object (RestTemplate) ###########");
		System.out.println(httpResponse);
		System.out.println();
	}


	/**
	 * WebClient 를 사용한 HTTP 요청
	 */
	public static void webClient() {
		System.out.println("########### WebClient ###########\n");
		WebClient webClient = WebClient.create();

		// GET 요청
        String getUrl = "https://httpbin.org/get";

        String response = webClient.get()
            .uri(getUrl)
            .retrieve()
            .bodyToMono(String.class)
            .block(); // block()은 요청 완료를 대기하고 결과를 가져옵니다.

        System.out.println("########### GET Response ########### \n" + response);

		// POST 요청
		String postUrl = "https://httpbin.org/post";
		String requestData = "{ key : value }";

        String postResponse = webClient.post()			// POST 요청
            .uri(postUrl)								// uri 지정
            .contentType(MediaType.APPLICATION_JSON)	// contentType 요청 헤더 설정
            .body(BodyInserters.fromValue(requestData))	// 요청 본문(body)을 설정
            .retrieve()									// 요청
            .bodyToMono(String.class)		// 스트림 형태로 받은 응답을 모노로 변환
            .block(); 									// block()은 요청 완료를 대기하고 결과 받음

        System.out.println("########### POST Response ########### \n" + postResponse);
	}


	/**
	 * WebClient 요청 -> 응답 -> 객체로 변환하기
	 * @throws JsonProcessingException
	 */
	private static void webClientToObject() throws JsonProcessingException {

		WebClient webClient = WebClient.create();

        String getUrl = "https://httpbin.org/get";

        HttpResponse httpResponse = webClient.get()
												.uri(getUrl)
												.retrieve()
												.bodyToMono(HttpResponse.class)
												.block();

		// GetResponse를 JSON 문자열로 변환
        ObjectMapper objectMapper = new ObjectMapper();
        String jsonResponse = objectMapper.writeValueAsString(httpResponse);

        // JSON 문자열을 User 객체로 변환
        HttpResponse response = objectMapper.readValue(jsonResponse, HttpResponse.class);

		System.out.println("########### Response to Object (WebClient) ###########");
		System.out.println(response.toString());
		System.out.println();
	}



}
Java
복사

실행 결과

########### RestTemplate ###########

########### GET Response ########### 
{
  "args": {},
  "headers": {
    "Accept": "text/plain, application/json, application/*+json, */*",
    "Host": "httpbin.org",
    "User-Agent": "Java/1.8.0_202",
    "X-Amzn-Trace-Id": "Root=1-65409ad8-4108dc922304952c08309ec7"
  },
  "origin": "14.37.8.141",
  "url": "https://httpbin.org/get"
}

########### POST Response ########### 
{
  "args": {},
  "data": "{key: value}",
  "files": {},
  "form": {},
  "headers": {
    "Accept": "text/plain, application/json, application/*+json, */*",
    "Content-Length": "12",
    "Content-Type": "application/json",
    "Host": "httpbin.org",
    "User-Agent": "Java/1.8.0_202",
    "X-Amzn-Trace-Id": "Root=1-65409ad8-19f9017679f786530b296b38"
  },
  "json": null,
  "origin": "14.37.8.141",
  "url": "https://httpbin.org/post"
}

########### Response to Object (RestTemplate) ###########
HttpResponse(args={}, headers={Accept=text/plain, application/json, application/*+json, */*, Host=httpbin.org, User-Agent=Java/1.8.0_202, X-Amzn-Trace-Id=Root=1-65409ad9-09b29f6449dab4f70e43154a}, origin=14.37.8.141, url=https://httpbin.org/get)

########### WebClient ###########

########### GET Response ###########
{
  "args": {},
  "headers": {
    "Accept": "*/*",
    "Accept-Encoding": "gzip",
    "Host": "httpbin.org",
    "User-Agent": "ReactorNetty/1.0.38",
    "X-Amzn-Trace-Id": "Root=1-65409ada-1f78a58f3cd9db604c2ffe84"
  },
  "origin": "14.37.8.141",
  "url": "https://httpbin.org/get"
}

########### POST Response ###########
{
  "args": {},
  "data": "{ key : value }",
  "files": {},
  "form": {},
  "headers": {
    "Accept": "*/*",
    "Accept-Encoding": "gzip",
    "Content-Length": "15",
    "Content-Type": "application/json",
    "Host": "httpbin.org",
    "User-Agent": "ReactorNetty/1.0.38",
    "X-Amzn-Trace-Id": "Root=1-65409ada-442b88ff2f1d5e7b21311f38"
  },
  "json": null,
  "origin": "14.37.8.141",
  "url": "https://httpbin.org/post"
}

########### Response to Object (WebClient) ###########
HttpResponse(args={}, headers={Accept=*/*, Accept-Encoding=gzip, Host=httpbin.org, User-Agent=ReactorNetty/1.0.38, X-Amzn-Trace-Id=Root=1-65409adb-4efe9c325a44763652475ff6}, origin=14.37.8.141, url=https://httpbin.org/get)
Plain Text
복사

동기&비동기, 블로킹&논블로킹

	블로킹 (Blocking)	논블로킹 (Non-Blocking)
동기식	작업이 완료될 때까지 기다리며 다른 작업을 하지 않음	작업이 완료될 때까지 기다리지만 다른 작업을 할 수 있음
비동기식	작업을 요청한 후 다른 작업을 하지 않음	작업을 요청한 후 다른 작업을 할 수 있음

비동기란?

작업을 요청한 후 그 작업이 완료될 때까지 기다리지 않고, 다른 작업을 계속할 수 있는 방식입니다. 작업이 완료되면 콜백 함수나 이벤트를 통해 결과를 알려줍니다.

논블로킹이란?

작업을 요청할 때, 그 작업이 즉시 완료되지 않더라도 현재 작업을 멈추지 않고 다른 작업을 계속할 수 있는 방식입니다. 즉, 작업이 완료될 때까지 기다리지 않고 바로 다음 작업을 수행할 수 있습니다.

동기식 논블로킹이 가능한가?

일반적으로는 동기식 논블로킹 조합은 실무에서 거의 사용되지 않습니다. 동기식 호출이 논리적으로 블로킹을 수반하는 특성이 있기 때문입니다. 그러나 이론적으로는 다음과 같은 방법으로 동기식 논블로킹을 구현할 수 있습니다

•

폴링(Polling): 일정 간격으로 작업 상태를 체크하여 완료되었는지 확인하는 방법입니다. 이는 특정 주기로 작업 완료 여부를 확인하고, 완료되지 않았다면 바로 제어권을 반환하는 방식이므로 논블로킹처럼 동작할 수 있습니다.

•

바쁜 대기(Busy-waiting): CPU 자원을 활용해 무한 루프를 돌며 결과를 기다리되, 작업이 완료되지 않으면 다른 로직으로 제어를 넘기지 않는 방식입니다.

하지만, 이러한 방법은 CPU 리소스를 낭비할 수 있으므로 효율적이지 않으며, 동기적 논블로킹의 필요성이 큰 경우에는 비동기 논블로킹 방식을 더 선호하게 됩니다.

Github (소스코드)

github.com

https://github.com/ALOHA-CLASS/SpringBoot_TJE/tree/main/spring-http