[Spring] RestTemplate 정리

RestTemplate란?

• Rest 방식 API를 호출 할 수 있는 Spring 내장 클래스다.
• Rest API 서비스를 요청 후 응답 받을 수 있도록 설계되어있으며, HTTP 프로토콜 메소드(ex: GET, POST, DELETE, PUT) 메소드 제공

 

RestTemplate의 특징

• Spring 3.0부터 지원하는 Spring HTTP 통신 템플릿
• HTTP 요청 후 JSON , XML , String과 같은 응답을 받을 수 있는 템플릿
• Blocking I/O 기반의 동기방식을 사용하는 템플릿
• RESTful 형식에 맞춰진 템플릿
• Header, Content-Type 설정해서 외부 API 호출
• Server to Server 통신에 사용

 

RestTemplate 동작 원리

1. 애플리케이션 내부에서 REST API에 요청하기 위해 RestTemplate의 메소드 호출
2. RestTemplate은 MessageConverter를 이용해서 Java Object를 request body에 담을 message(JSON etc..)로 변환
3. ClientHttpRequestFactory에서 ClientHttpRequest을 받아와 요청을 전달
4. 실질적으로 ClientHttpRequest가 HTTP 통신으로 요청을 수행함
5. RestTemplate이 에러핸들링을 진행함
6. ClientHttpResponse에서 응답 데이터를 가져와 오류가 있다면 처리한다.
7. MessageConverter를 이용해서 response body의 message를 Java Object로 변환함
8. 결과를 애플리케이션에 돌려줌

 

 

API 호출 클래스 종류

 

RestTemplate : REST API 호출 이후 응답을 받을 때까지 기다리는 동기방식

 

AsyncRestTemplate : Spring 4에 추가된 RestTemplate 비동기 방식

 

WebClient : Spring 5에 추가된 논블럭, 클라이언트 동기, 비동기 방식 지

 

 

메소드	HTTP	설명
getForObject : Object	Get	Get 방식 요청으로 결과를 객체로 반환
getForEntity : ResponseEntity	Get	Get방식 요청으로 결과를  ResponseEntity 반환
postForLocation	POST	POST방식으로  결과를 헤더에 저장된 URI로 반환
postForObject : Object	POST	POST 방식 요청으로 결과를 객체로 반환
postForEntity : ResponseEntity	POST	POST방식 요청으로 결과를 ResponseEntity로 반환
delete	DELETE	DELETE 방식 요청으로 메소드 실행
put	PUT	HTTP PUT 메소드 실행
patchForObject	PATCH	HTTP PATCH 메소드 실행
exchange : ResponseEntity	any	헤더 생성 및 어떤 요청이든 사용 가능
execute	any	Request / Response 콜백 수정할 수 있음

 

 

[RestTemplate 순서 정리]

 

0. 결과값을 담을 객체 생성

 

1. 타임아웃 설정 시 HttpComponentsClientHttpRequestFactory 객체 생성

 

2. RestTemplate 객체 생성

 

3. header 설정을 위해 HttpHeader 클래스 생성 후 HttpEntity객체에 넣어줌

 

4. 요청 URL 정의

 

5. exchange() 메소드 api 호출

 

6. 요청한 결과를 HashMap에 추가

 

public class RestAPI {

	@GetMapping("")
    public HashMap<String,Object> callAPI() {
    	
    	// 0. 결과값을 담을 객체 생성
        HashMap<String,Object> resultMap = new HashMap<>();
        try {
        
		// 1. 타임아웃 설정 시 HttpComponentsClientHttpRequestFactory 객체 생성
            
            HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
			
            factory.setConnectTimeout(5000); // 타임아웃 설정 5초
            
            factory.setReadTimeout(5000); // 타임아웃 설정 5초
            
            // Apache HttpComponets : 각 호스트(IP와 Port)당 커넥션 풀에 생성 가능한 커넥션 수
            HttpClient httpClient = HttpClientBuilder.create().setMaxConnTotal(50).setMaxConnPerRoute(20).build();
            factory.setHttpClient(httpClient);
            
            // 2. RestTemplate 객체 생성
            RestTemplate restTemplate = new RestTemplate(factory);
            
            // 3. header 설정을 위해 -> HttpHeader 클래스를 생성한 후 HttpEntity 객체에 넣어줌
            HttpHeader header = new HttpHeader();
            HttpEntity<String> entity = new HttpEntity<String>(header);
            
             // 4. 요청 URL 정의
            String url = "api 요청 URL";
            UriComponents uri = UriComponentsBuilder.fromHttpUrl(url).queryParam("파라미터명", 값).build(false);
           
            // 5. exchange() 메소드로 api 호출
            ResponseEntity<Map> response = resTemplate.exchange(uri.toString, HttpMethod.GET, entity, Map.class);
           
            // 6. 요청한 결과를 HashMap에 추가합니다.
            // HTTP Status Code
            resultMap.put("statusCode", response.getStatusCodeValue());
            // 헤더 정보
            resultMap.put("header", response.getHeaders());
            // 반환받은 실제 데이터 정보
            resultMap.put("body", response.getBody());

    } catch(Exception e) {
    	e.printStackTrace();
    }

}

 

요청 URI 설정 방법

• String 변수 사용
• StringBuffer 객체 사용
• URI 객체 사용
• UriComponents 객체 사용

[String]

// String 변수 사용해서 만들기

// 1. 요청 URL
String url = "요청 url";

// 2. 쿼리스트링 추가

url = url + "?파라미터명" + 값;
url = url + "&파라미터명" + 값;

 

[StringBuffer]

// StringBuffer 객체 만들고 -> urlBuffer.toString()으로 사용

StringBuffer urlBuffer = new StringBuffer();
urlBuffer.append("요청url").
         .append("?파라미터명=")
         .append(값)
         .append("&파라미터명=")
         .append(값);

 

[URI]

URI uri = UriComponentsBuilder.fromHttpUrl("요청URL")
                              .queryParams("파라미터명",값)
                              .queryParams("파라미터명",값)
                              .queryParams("파라미터명", URLEncoder.encode(값,"UTF-8"))
                              .build();

 

[UriComponents]

UriComponents uriComponents = UriComponentsBuilder.newInstance()
                                                  .path("요청 URL")
                                                  .queryParam("파라미터명", 값)
                                                  .queryParam("파라미터명", 값)
                                                  .build();
                                                  
 // 동적주소를 사용한다면?
 
 
 UriComponents uriComponents = UriComponentsBuilder.newInstance()
                                                   .scheme("http")
                                                   .host("요청URL")
                                                   .path("/{language}/{type}")
                                                   .queryParam("파라미터명",값)
                                                   .queryParam("파라미터명",값)
                                                   .build()
                                                   .expand("java", "example")
                                                   .encode();

 

Header 만들기

Spring Framework에서 제공하는 HttpHeaders 클래스에 추가 -> 만들어진 Header는 HttpEntity 클래스에 추가하여 사용

// 1. HttpHeaders 객체 생성
HttpHeaders headers = new HttpHeaders();
 
// 2. 헤더 설정 : ContentType, Accept 설정
headers.setContentType(new MediaType("application","json",Charset.forName("UTF-8")));
headers.setAccept(Arrays.asList(new MediaType[] { MediaType.APPLICATION_JSON }));
 
 
// 3. 헤더 설정 : Key, Value 쌍으로 설정
headers.set("헤더이름", "값");
 
// HTTP 요청할 떄 생성한 Header 설정
ResponseEntity<String> responseEntity = restTemplate.exchange("요청 URL"
                                    , HttpMethod.GET, new HttpEntity<>(headers), String.class);

 

Get 방식 예시

• getForEntity("요청 URL", 응답내용 매핑 객체)
• exchange("요청 URL", HttpMethod.GET, 응답내용 매핑 객체)

// 타임아웃설정

HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
factory.setConnectTimeout(5000); // 타임아웃 5초
factory.setReadTimeout(5000); // 타임아웃 5초


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

// 요청 URL 및 쿼리스트링 설정
URI url = UriComponentsBuilder.fromHttpUrl("요청url")
                              .queryParams("파라미터명", 값)
                              .queryParams("파라미터명", 값)
                              .queryParams("파라미터명", URLEncoder.encode(값,"UTF-8"))
                              .build();
// Get 요청 
ResponseEntity<String> response = restTemplate.exchange(url.toString(), HttpMethod.GET, entity, String.class);
 
 // HTTP GET 요청에 대한 응답 확인
System.out.println("status : " + response.getStatusCode());
System.out.println("body : " + response.getBody());

 

Post 방식 예시

• postForEntity("요청URL", 응답내용 매핑 객체)
• exchange("요청 URL", HttpMethod.POST, 응답내용 매핑 객체)

// 타임아웃 설정
HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
factory.setConnectTimeout(5000); // 타임아웃 설정 5초
factory.setReadTimeout(5000); // 타임아웃 설정 5초
 
// RestTemplate 객체 생성
RestTemplate restTemplate = new RestTemplate(factory);

//Header 및 Body 설정

HttpHeader headers = new HttpHeader();
headers.set("헤더이름", "값");
MultiValueMap<String,String> body = new LinkedMultiValueMap<String,String>();
body.add("키", "값");

// 이제 Header와 body를 담아줘야함
HttpEntity<MultiValueMap<String,String>> entity = new HttpEntity<>(body,headers);

// HTTP POST 요청
ResponseEntity<String> response = restTemplate.exchange("요청 URL", HttpMethod.POST, entity, String.class);
 
// HTTP POST 요청에 대한 응답 확인
System.out.println("status : " + response.getStatusCode());
System.out.println("body : " + response.getBody());

 

 

RestTemplate Builder

• Builder 패턴을 이용해서 RestTemplate로 HTTP요청을 할 수 있도록 만든 Util 클래스
  • Http 요청 후 status, header, body를 key로 가진 HashMap<String,Object> 형태 반환

//GET 요청
HashMap<String,Object> result = new HttpUtil()
        .url("https://www.naver.com")
        .method("get")
        .queryString("파라미터명", "값")
        .build();
        
// POST 방식
HashMap<String,Object> result = new HttpUtil()
        .url("https://www.naver.com")
        .method("post")
        .contentType("application", "json", "UTF-8")
        .header("헤더이름","값")
        .body("파라미터명","값")
        .build();

 

 

 

 

 

참고문헌

[Spring]스프링 RestTemplate : 네이버 블로그 (naver.com)

[Spring]스프링 RestTemplate

[spring] 스프링에서 사용하는 RestTemplate - http 라이브러리 :: 쏘니의 개발블로그 (tistory.com)

[spring] 스프링에서 사용하는 RestTemplate - http 라이브러리