[Spring] HTTP 요청 파라미터(RequestParam, PathVariable, ModelAttribute, RequestBody, ResponseBody, RestController, HttpEntity) - 쿼리 파라미터, HTML Form

 

안녕하세요 이번 포스팅은 HTTP 요청 파라미터에 대해 알아보겠습니다!!!

 

서블릿에서 학습했던 HTTP 요청 데이터를 조회하는 방법을 다시 떠올려봅시다.

그리고 서블릿으로 학습했던 내용을 스프링이 얼마나 깔끔하고 효율적으로 바꾸어주는지 알아보고 HTTP 요청 메시지를 통해 클라이언트에서 서버로 데이터를 전달하는 방법을 알아보겠습니다.

 

클라이언트에서 서버로 요청 데이터를 전달할 때는 주로 다음 3가지 방법을 사용합니다.

 

1. GET - 쿼리 파라미터

- /url?username-hello&age=20

- 메시지 바디 없이 URL의 쿼리 파라미터에 데이터를 포함해서 전달

- 예) 검색, 필터, 페이징 등에서 많이 사용하는 방식

2. POST - HTML Form

- content-type : application/x-www-form-urlencoded

- 메시지 바디에 쿼리 파라미터 형식으로 전달 username=hello&age=20

- 예) 회원 가입, 상품 주문, HTML Form 사용

3. HTTP message body에 데이터를 직접 담아서 요청

- HTTP API에서 주로 사용, JSON, XML, TEXT

- 데이터 형식은 주로 JSON 사용

- POST, PUT, PATCH

 

GET 쿼리 파라미터 전송

우선 request.getParameter()를 사용하면 GET POST 두 가지 요청 파라미터를 조회할 수 있습니다.

 

GET 쿼리 파라미터 전송 방식이든, POST HTML Form 전송 방식이든 둘 다 형식이 같으므로 구분 없이 조회할 수 있습니다.

 

지금부터 스프링으로 요청 파라미터를 조회하는 방법을 단계적으로 알아보겠습니다.

 

ReuqestParamController

 

import hello.springmvc.basic.HelloData;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Map;

@Slf4j
@Controller
public class RequestParamController {
     /**
     * 반환 타입이 없으면서 이렇게 응답에 값을 직접 집어넣으면, view 조회X
     */
     @RequestMapping("/request-param-v1")
     public void requestParamV1(HttpServletRequest request, HttpServletResponse 
    response) throws IOException {
         String username = request.getParameter("username");
         int age = Integer.parseInt(request.getParameter("age"));
         log.info("username={}, age={}", username, age);
         response.getWriter().write("ok");
     }
}

여기서는 단순히 HttpServletRequest가 제공하는 방식으로 요청 파라미터를 조회했습니다.

 

 

참고

Jar를 사용하면 webapp 경로를 사용할 수 없습니다. 이제부터 정적 리소스도 클래스 경로에 함께 포함해야 합니다.

 

HTTP 요청 파라미터 - @RequestParam

 

스프링이 제공하는 @RequestParam을 사용하면 요청 파라미터를 매우 편리하게 사용할 수 있습니다.

 

requestParamV2

/**
 * @RequestParam 사용
 * - 파라미터 이름으로 바인딩
 * @ResponseBody 추가
 * - View 조회를 무시하고, HTTP message body에 직접 해당 내용 입력
 */
@ResponseBody
@RequestMapping("/request-param-v2")
public String requestParamV2(
     @RequestParam("username") String memberName,
     @RequestParam("age") int memberAge) {
     
     log.info("username={}, age={}", memberName, memberAge);
     return "ok";
}

 

 

requestParamV3

 

/**
 * @RequestParam 사용
 * HTTP 파라미터 이름이 변수 이름과 같으면 @RequestParam(name="xx") 생략 가능
 */
@ResponseBody
@RequestMapping("/request-param-v3")
public String requestParamV3(
     @RequestParam String username,
     @RequestParam int age) {
     
     log.info("username={}, age={}", username, age);
     return "ok";
}

HTTP 파라미터 이름이 변수 이름과 같으면 @RequestParam(name="xx") 생략 가능합니다.

여기서 파라미터 이름이라는 것은 쿼리 파라미터의 키 이름 혹은 Form 태그 안의 input 태그의 name 속성을 말합니다.

 

requestParamV4

 

/**
 * @RequestParam 사용
 * String, int 등의 단순 타입이면 @RequestParam 도 생략 가능
 */
@ResponseBody
@RequestMapping("/request-param-v4")
public String requestParamV4(String username, int age) {
     log.info("username={}, age={}", username, age);
     return "ok";
}

String, int, Integer 등의 단순 타입이면 @RequestParam 도 생략 가능합니다.

 

 

파라미터 필수 여부 - requestParamRequired

 

/**
 * @RequestParam.required
 * /request-param -> username이 없으므로 예외
 *
 * 주의!
 * /request-param?username= -> 빈문자로 통과
 *
 * 주의!
 * /request-param
 * int age -> null을 int에 입력하는 것은 불가능, 따라서 Integer 변경해야 함(또는 다음에 나오는
defaultValue 사용)
 */
@ResponseBody
@RequestMapping("/request-param-required")
public String requestParamRequired(
     @RequestParam(required = true) String username,
     @RequestParam(required = false) Integer age) {
     
     log.info("username={}, age={}", username, age);
     return "ok";
}

@RequestParam. required

- 파라미터 필수 여부

- 기본값이 파라미터 필수(true)입니다.

 

/request-param 요청

- username이 없다면 400 예외가 발생합니다.

 

주의-파라미터 이름만 사용

/request-param? username=

- 파라미터 이름만 있고 값이 없는 경우 빈문자로 통과됩니다.

 

주의-기본형(primitive)에 null 입력

/request-param 요청

@RequestParam(required = false) int age

 

null을 int에 입력하는 것은 불가능합니다(500 예외 발생)

따라서 null을 받을 수 있는 Integer로 변경하거나 또는 다음에 나오는 defaultValue를 사용해야 합니다.

 

기본 값 적용 - requestParamDefault

 

/**
 * @RequestParam
 * - defaultValue 사용
 *
 * 참고: defaultValue는 빈 문자의 경우에도 적용
 * /request-param?username=
 */
@ResponseBody
@RequestMapping("/request-param-default")
public String requestParamDefault(
     @RequestParam(required = true, defaultValue = "guest") String username,
     @RequestParam(required = false, defaultValue = "-1") int age) 
     
     log.info("username={}, age={}", username, age);
     return "ok";
}

 

파라미터에 값이 없는 경우 defaultValue를 사용하면 기본 값을 적용할 수 있습니다.

defaultValue는 빈 문자의 경우에도 설정한 기본 값이 적용됩니다.

/request-param? useranme=

 

파라미터를 Map으로 조회하기 - requestParamMap

 

/**
 * @RequestParam Map, MultiValueMap
 * Map(key=value)
 * MultiValueMap(key=[value1, value2, ...] ex) (key=userIds, value=[id1, id2])
 */
@ResponseBody
@RequestMapping("/request-param-map")
public String requestParamMap(@RequestParam Map<String, Object> paramMap) {
     log.info("username={}, age={}", paramMap.get("username"), paramMap.get("age"));

     return "ok";
}

파라미터를 Map, MultiValueMap으로 조회할 수 있습니다.

 

 

HTTP 요청 파라미터 - @ModelAttribute

 

실제 개발을 하면 요청 파라미터를 받아서 필요한 객체를 만들고 그 객체에 값을 넣어주어야 합니다. 그렇다면 보통 다음과 같이 코드를 작성할 것입니다.

 

 

스프링은 이 과정을 완전히 자동화해주는 @ModelAttribute 기능을 제공합니다.

 

먼저 요청 파라미터를 바인딩받을 객체를 만듭시다.

 

HelloData

 

import lombok.Data;
@Data
public class HelloData {
 private String username;
 private int age;
}

 

 

@ModelAttribute 적용 - modelAttributeV1

 

/**
 * @ModelAttribute 사용
 * 참고: model.addAttribute(helloData) 코드도 함께 자동 적용됨, 뒤에 model을 설명할 때
자세히 설명
 */
@ResponseBody
@RequestMapping("/model-attribute-v1")
public String modelAttributeV1(@ModelAttribute HelloData helloData) {
     log.info("username={}, age={}", helloData.getUsername(), helloData.getAge());
     return "ok";
}

마치 마법처럼 HelloData 객체가 생성되고, 요청 파라미터의 값도 모두 들어가 있습니다.

 

스프링 MVC는 @ModelAttribute가 있으면 다음을 실행합니다.

1. HelloData 객체를 생성한다.

2. 요청 파라미터의 이름으로 HelloData 객체의 프로퍼티를 찾는다. 그리고 해당 프로퍼티의 setter를 호출해서 파라미터의 값을 입력한다.

3. 예) 파라미터 이름이 username이면 setUsername() 메서드를 찾아서 호출하면서 값을 바인딩한다.

 

프로퍼티

객체에 getUsername() , setUsername() 메서드가 있으면, 이 객체는 username이라는 프로퍼티를 가지고 있습니다. username 프로퍼티의 값을 변경하면 setUsername() 이 호출되고, 조회하면 getUsername() 이 호출됩니다.

 

 

바인딩 오류

age=abc처럼 숫자가 들어가야 할 곳에 문자를 넣으면 BindException 이 발생합니다. 이런 바인딩 오류를 처리하는 방법은 검증 부분에서 다루겠습니다.

 

 

@ModelAttribute 생략 - modelAttributeV2

 

/**
 * @ModelAttribute 생략 가능
 * String, int 같은 단순 타입 = @RequestParam
 * argument resolver 로 지정해둔 타입 외 = @ModelAttribute
 */
@ResponseBody
@RequestMapping("/model-attribute-v2")
public String modelAttributeV2(HelloData helloData) {
     log.info("username={}, age={}", helloData.getUsername(), helloData.getAge());
     return "ok";
}

@ModelAttribute는 생략할 수 있습니다.

그런데 @RequestParam도 생략할 수 있으니 혼란이 발생할 수 있습니다.

 

스프링은 해당 생략 시 다음과 같은 규칙을 적용합니다.

String, int, Integer 같은 단순 타입 = @RequestParam

나머지 = @ModelAttribute(argument resolver로 지정해둔 타입 외)

 

HTTP 요청 메시지 - 단순 텍스트

요청 메시지는 HTTP message body에 데이터를 직접 담아서 요청하는 것입니다.

HTTP API에서 주로 사용하고 데이터 형식은 주로 JSON을 사용합니다. 요청 파라미터와 다르게, HTTP 메시지 바디를 통해 데이터가 직접 데이터가 넘어오는 경우는 @RequestParam, @ModelAttribute를 사용할 수 없습니다. 물론 HTML Form 형식으로 전달되는 경우는 요청 파라미터로 인정됩니다.

 

먼저 가장 단순한 텍스트 메시지를 HTTP 메시지 바디에 담아서 전송하고 읽어 봅시다.

HTTP 메시지 바디의 데이터를 InputStream을 사용해서 직접 읽을 수 있습니다.

 

RequestBodyStringController

@Slf4j
@Controller
public class RequestBodyStringController {

     @PostMapping("/request-body-string-v1")
     public void requestBodyString(HttpServletRequest request,
    		HttpServletResponse response) throws IOException {
            
         ServletInputStream inputStream = request.getInputStream();
         String messageBody = StreamUtils.copyToString(inputStream, StandardCharsets.UTF_8);
         
         log.info("messageBody={}", messageBody);
         response.getWriter().write("ok");
     }
}

Postman을 사용해서 Body -> row, Text를 선택하고 메시지 바디에 데이터를 넣고 테스트를  해보면 결과를 확인할 수 있습니다.

 

Input, Output 스트림, Reader - requestBodyStringV2

/**
 * InputStream(Reader): HTTP 요청 메시지 바디의 내용을 직접 조회
 * OutputStream(Writer): HTTP 응답 메시지의 바디에 직접 결과 출력
 */
@PostMapping("/request-body-string-v2")
public void requestBodyStringV2(InputStream inputStream, Writer responseWriter)
throws IOException {
     String messageBody = StreamUtils.copyToString(inputStream,
    StandardCharsets.UTF_8);

log.info("messageBody={}", messageBody);
     responseWriter.write("ok");
}

스프링 MVC는 다음 파라미터를 지원합니다,

InputStream(Reader) : HTTP 요청 메시지 바디의 내용을 직접 조회

OutputStream(writer) : HTTP 응답 메시지의 바디에 직접 결과 출력

 

HttpEntity - requestBodyStringV3

 

/**
 * HttpEntity: HTTP header, body 정보를 편라하게 조회
 * - 메시지 바디 정보를 직접 조회(@RequestParam X, @ModelAttribute X)
 * - HttpMessageConverter 사용 -> StringHttpMessageConverter 적용
 *
 * 응답에서도 HttpEntity 사용 가능
 * - 메시지 바디 정보 직접 반환(view 조회X)
 * - HttpMessageConverter 사용 -> StringHttpMessageConverter 적용
 */
@PostMapping("/request-body-string-v3")
public HttpEntity<String> requestBodyStringV3(HttpEntity<String> httpEntity) {
     String messageBody = httpEntity.getBody();
     log.info("messageBody={}", messageBody);
     
     return new HttpEntity<>("ok");
}

 

스프링 MVC는 다음 파라미터를 지원합니다.

HttpEntity : HTTP header, body 정보를 편리하게 조회

- 메시지 바디 정보를 직접 조회

- 요청 파라미터를 조회하는 기능과 관계없음 @RequestParam X, @ModelAttribute X

 

HttpEntity는 응답에도 사용 가능

- 메시지 바디 정보 직접 반환

- 헤더 정보 포함 기능

- view 조회 X

 

HttpEntity를 상속받은 다음 객체들도 같은 기능을 제공합니다.

RequestEntity

- HttpMethod, url 정보가 추가, 요청에서 사용

 

ResponseEntity

- HTTP 상태 코드 설정 가능, 응답에서 사용

- return new ResponseEntity <String>("Hello World", responseHeaders, HttpStatus.CREATED)

 

참고

스프링 MVC 내부에서 HTTP 메시지 바디를 읽어서 문자나 객체로 변환해서 전달해주는데, 이때 HTTP 메시지 컨버터(HttpMessageConverter)라는 기능을 사용합니다. 이것은 조금 뒤에 HTTP 메시지 컨버터에서 자세 설명합니다.

 

@RequestBody - requestBodyStringV4

 

/**
 * @RequestBody
 * - 메시지 바디 정보를 직접 조회(@RequestParam X, @ModelAttribute X)
 * - HttpMessageConverter 사용 -> StringHttpMessageConverter 적용
 *
 * @ResponseBody
 * - 메시지 바디 정보 직접 반환(view 조회X)
 * - HttpMessageConverter 사용 -> StringHttpMessageConverter 적용
 */
@ResponseBody
@PostMapping("/request-body-string-v4")
public String requestBodyStringV4(@RequestBody String messageBody) {
     log.info("messageBody={}", messageBody);
     return "ok";
}

@RequestBody

@RequestBody를 사용하면 HTTP 메시지 바디 정보를 편리하게 조회할 수 있습니다. 참고로 헤더 정보가 필요하다면 HttpEntity를 사용하거나 @RequestHeader를 사용하면 됩니다.

이렇게 메시지 바디를 직접 조회하는 기능은 요청 파라미터를 조회하는 @RequestParam, @ModelAttribute와는 전혀 관계가 없습니다.

 

요청 파라미터 vs HTTP 메시지 바디

- 요청 파라미터를 조회하는 기능 : @RequestParam, @ModelAttribute

- HTTP 메시지 바디를 직접 조회하는 기능 : @RequestBody

 

@ResponseBody

@ResponseBody를 사용하면 응답 결과를 HTTP 메시지 바디에 직접 담아서 전달할 수 있습니다.

물론 이 경우에도 view를 사용하지 않습니다.

 

HTTP 요청 메시지 - JSON

 

이번에는 HTTP API에서 주로 사용하는 JSON 데이터 형식을 조회해보겠습니다.

 

기존 서블릿에서 사용했던 방식과 비슷하게 시작해보겠습니다.

 

RequestBodyJsonController

 

import com.fasterxml.jackson.databind.ObjectMapper;
import hello.springmvc.basic.HelloData;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Controller;
import org.springframework.util.StreamUtils;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

/**
 * {"username":"hello", "age":20}
 * content-type: application/json
 */
@Slf4j
@Controller
public class RequestBodyJsonController {
     private ObjectMapper objectMapper = new ObjectMapper();
     
     @PostMapping("/request-body-json-v1")
     public void requestBodyJsonV1(HttpServletRequest request,
    HttpServletResponse response) throws IOException {
         ServletInputStream inputStream = request.getInputStream();
         String messageBody = StreamUtils.copyToString(inputStream,
        StandardCharsets.UTF_8);
        
         log.info("messageBody={}", messageBody);
         
         HelloData data = objectMapper.readValue(messageBody, HelloData.class);
         log.info("username={}, age={}", data.getUsername(), data.getAge());
         
         response.getWriter().write("ok");
     }
}

HttpServletRequest를 사용해서 직접 HTTP 메시지 바디에서 데이터를 읽어와서 문자로 변환합니다.

문자로 된 JSON 데이터를 Jackson 라이브러리인 objectMapper를 사용해서 자바 객체로 변환합니다.

 

 

requestBodyJsonV2- @RequestBody 문자 변환

 

/**
 * @RequestBody
 * HttpMessageConverter 사용 -> StringHttpMessageConverter 적용
 *
 * @ResponseBody
 * - 모든 메서드에 @ResponseBody 적용
 * - 메시지 바디 정보 직접 반환(view 조회X)
 * - HttpMessageConverter 사용 -> StringHttpMessageConverter 적용
 */
@ResponseBody
@PostMapping("/request-body-json-v2")
public String requestBodyJsonV2(@RequestBody String messageBody) throws
IOException {
     HelloData data = objectMapper.readValue(messageBody, HelloData.class);
     log.info("username={}, age={}", data.getUsername(), data.getAge());
     
     return "ok";
}

이전에 학습했던 @RequestBody를 사용해서 HTTP 메시지에서 데이터를 꺼내고 messageBody에 저장합니다.

문자로 된 JSON 데이터인 messageBody를 objectMapper를 통해서 자바 객체로 변환합니다.

 

여기서 문자로 변환하고 다시 json으로 변환하는 과정이 불편한데 이것을 해결할 수 있는 방법이 있습니다.

 

 

requestBodyJsonV3 - @RequestBody 객체 변환

 

/**
 * @RequestBody 생략 불가능(@ModelAttribute 가 적용되어 버림)
 * HttpMessageConverter 사용 -> MappingJackson2HttpMessageConverter (contenttype: application/json)
 *
 */
@ResponseBody
@PostMapping("/request-body-json-v3")
public String requestBodyJsonV3(@RequestBody HelloData data) {
     log.info("username={}, age={}", data.getUsername(), data.getAge());
     return "ok";
}

 

@RequestBody 객체 파라미터

- @RequestBody HelloData data

- @RequestBody에 직접 만든 객체를 지정할 수 있습니다.

 

HttpEntity, @RequestBody를 사용하면 HTTP 메시지 컨버터가 HTTP 메시지 바디의 내용을 우리가 원하는 문자나 객체 등으로 변환해줍니다.

HTTP 메시지 컨버터는 문자뿐만 아니라 JSON도 객체로 변환해주는데, 우리가 방금 V2에서 했던 작업을 대신 처리해줍니다. 자세한 내용은 뒤의 HTTP 메시지 컨버터에서 다루겠습니다.

 

@RequestBody는 생략 불가능

@ModelAttribute에서 학습한 내용을 떠올려봅시다.

 

스프링은 @ModelAttribute , @RequestParam 해당 생략 시 다음과 같은 규칙을 적용합니다.

String , int , Integer 같은 단순 타입 = @RequestParam

나머지 = @ModelAttribute (argument resolver로 지정해둔 타입 외)

 

따라서 이 경우 HelloData에 @RequestBody를 생략하면 @ModelAttribute 가 적용되어버립니다.

HelloData data ->  @ModelAttribute HelloData data

따라서 생략하면 HTTP 메시지 바디가 아니라 요청 파라미터를 처리하게 됩니다.

 

주의

HTTP 요청 시에 content-type이 application/json인지 꼭! 확인해야 합니다. 그래야 JSON을 처리할 수 있는 HTTP 메시지 컨버터가 실행됩니다.

 

물론 앞서 배운 것과 같이 HttpEntity를 사용해도 됩니다.

 

requestBodyJsonV4-HttpEntity

 

@ResponseBody
@PostMapping("/request-body-json-v4")
public String requestBodyJsonV4(HttpEntity<HelloData> httpEntity) {
     HelloData data = httpEntity.getBody();
     log.info("username={}, age={}", data.getUsername(), data.getAge());
     
     return "ok";
}

 

requestBodyJsonV5

 

/**
 * @RequestBody 생략 불가능(@ModelAttribute 가 적용되어 버림)
 * HttpMessageConverter 사용 -> MappingJackson2HttpMessageConverter (contenttype: application/json)
 *
 * @ResponseBody 적용
 * - 메시지 바디 정보 직접 반환(view 조회X)
 * - HttpMessageConverter 사용 -> MappingJackson2HttpMessageConverter 적용
(Accept: application/json)
 */
@ResponseBody
@PostMapping("/request-body-json-v5")
public HelloData requestBodyJsonV5(@RequestBody HelloData data) {

     log.info("username={}, age={}", data.getUsername(), data.getAge());
     
     return data;
}

 

@ResponseaBody

응답의 경우에도 @ResponseBody를 사용하면 해당 객체를 HTTP 메시지 바디에 직접 넣어줄 수 있습니다.

물론 이 경우에도 HttpEntity를 사용해도 됩니다.

 

 

HTTP 응답 - 정적 리소스, 뷰 템플릿

응답 데이터는 이미 앞에서 일부 다룬 내용들이지만, 응답 부분에 초점을 맞추어서 정리해보겠습니다. 스프링(서버)에서 응답 데이터를 만드는 방법은 크게 3가지입니다.

 

1. 정적 리소스

- 웹 브라우저에 정적인 HTML, css, js을 제공할 때는 정적 리소스를 사용합니다.

2. 뷰 템플릿 사용

- 웹 브라우저에 동적인 HTML을 제공할 때는 뷰 템플릿을 사용합니다.

3. HTTP 메시지 사용

- HTTP API를 제공하는 경우에는 HTML이 아니라 데이터를 전달해야 하므로, HTTP 메시지 바디에 JSON 같은 형식으로 데이터를 실어 보냅니다.

 

정적 리소스

스프링 부트는 클래스 패스의 다음 디렉터리에 있는 정적 리소스를 제공합니다.

 

src/mian/resources는 리소스를 보관하는 곳이고, 또 클래스패스의 시작 경로입니다. 따라서 다음 디렉토리에 리소스를 넣어두면 스프링 부트가 정적 리소스로 서비스를 제공합니다.

 

정적 리소스 경로

src/main/resources/static

 

다음 경로에 파일이 들어있으면

src/main/resources/static/basic/hello-form.html

 

웹 브라우저에서 다음과 같이 실행하면 됩니다.

http://localhost:8080/basic/hello-form.html

 

정적 리소스는 해당 파일을 변경 없이 그대로 서비스하는 것입니다.

 

뷰 템플릿

뷰 템플릿을 거쳐서 HTML이 생성되고, 뷰가 응답을 만들어서 전달합니다.

일반적으로 HTML을 동적으로 생성하는 요도로 사용하지만, 다른 것들도 가능합니다.

 

스프링 부트는 기본 뷰 템플릿 경로를 제공합니다.

 

뷰 템플릿 경로

src/main/resources/templates

 

뷰 템플릿 생성

src/main/resources/templates/response/hello.html

 

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
 <meta charset="UTF-8">
 <title>Title</title>
</head>
<body>
<p th:text="${data}">empty</p>
</body>
</html>

 

ResponseViewController - 뷰 템플릿을 호출하는 컨트롤러

 

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class ResponseViewController {
     @RequestMapping("/response-view-v1")
     public ModelAndView responseViewV1() {
         ModelAndView mav = new ModelAndView("response/hello")
         		.addObject("data", "hello!");
                
         return mav;
     }
     
     @RequestMapping("/response-view-v2")
     public String responseViewV2(Model model) {
         model.addAttribute("data", "hello!!");
         
         return "response/hello";
     }
     
     @RequestMapping("/response/hello")
     public void responseViewV3(Model model) {
     	model.addAttribute("data", "hello!!");
     }
}

 

String을 반환하는 경우 - View or HTTP 메시지

@ResponseBody가 없으면 response/hello로 뷰 리졸버가 실행되어서 뷰를 찾고, 렌더링 합니다.

@ResponseBody가 있으면 뷰 리졸버를 실행하지 않고, HTTP 메시지 바디에 직접 response/hello라는 문자가 입력됩니다.

 

여기서는 뷰의 논리 이름인 response/hello를 반환하면 다음 경로의 뷰 템플릿이 렌더링 되는 것을 확인할 수 있습니다.

실행 : templates/resopnse/hello.html

 

Void를 반환하는 경우

@Controller를 사용하고 HttpServletResponse, OutputStream(Writer) 같은 HTTP 메시지 바디를 처리하는 파라미터가 없으면 요청  URL을 참고해서 논리 뷰 이름으로 사용합니다.

요청 URL : /response/hello

실행 : templates/response/hello.html

 

참고로 이 방식은 명시성이 너무 떨어지고 이렇게 딱 맞는 경우도 많이 없어서 권장하지 않는다고 합니다.

 

HTTP 메시지

@ResponseBody, HttpEntity를 사용하면, 뷰 템플릿을 사용하는 것이 아니라, HTTP 메시지 바디에 직접 응답 데이터를 출력할 수 있습니다.

 

Thymeleaf 스프링 부트 설정

 

다음 라이브러리를 추가합니다.

 

스프링 부트가 자동으로 ThymeleafViewResolver와 필요한 스프링 빈들을 등록합니다.

그리고 다음 설정도 사용합니다. 이 설정은 기본 값이기 때문에 변경이 필요할 때만 설정하면 됩니다.

 

 

HTTP 응답 - HTTP API, 메시지 바디에 직접 입력

 

HTTP API를 제공하는 경우에는 HTML이 아니라 데이터를 전달해야 하므로, HTTP 메시지 바디에 JSON 같은 형식으로 데이터를 실어 보냅니다. HTTP 요청에서 응답까지 대부분 다루었으므로 정리를 해보겠습니다.

 

참고

HTML이나 뷰 템플릿을 사용해도 HTTP 응답 메시지 바디에 HTML 데이터가 담겨서 전달됩니다. 여기서 설명하는 내용은 정적 리소스나 뷰 템플릿을 거치지 않고, 직접 HTTP 응답 메시지를 전달하는 경우를 말한다.

 

ResponseBodyController

 

import hello.springmvc.basic.HelloData;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Slf4j
@Controller
//@RestController
public class ResponseBodyController {

 @GetMapping("/response-body-string-v1")
 public void responseBodyV1(HttpServletResponse response) throws IOException {
 
 	response.getWriter().write("ok");
 }
 
 /**
 * HttpEntity, ResponseEntity(Http Status 추가)
 * @return
 */
 @GetMapping("/response-body-string-v2")
 public ResponseEntity<String> responseBodyV2() {
 	return new ResponseEntity<>("ok", HttpStatus.OK);
 }
 
 @ResponseBody
 @GetMapping("/response-body-string-v3")
 public String responseBodyV3() {
 	return "ok";
 }
 
 @GetMapping("/response-body-json-v1")
 public ResponseEntity<HelloData> responseBodyJsonV1() {
     HelloData helloData = new HelloData();
     helloData.setUsername("userA");
     helloData.setAge(20);
     
     return new ResponseEntity<>(helloData, HttpStatus.OK);
 }
 
 @ResponseStatus(HttpStatus.OK)
 @ResponseBody
 @GetMapping("/response-body-json-v2")
 public HelloData responseBodyJsonV2() {
     HelloData helloData = new HelloData();
     helloData.setUsername("userA");
     helloData.setAge(20);
     
     return helloData;
 }
}

responseBodyV1

서블릿을 직접 다룰 때처럼 HttpServletResponse 객체를 통해서 HTTP 메시지 바디에 직접 ok 응답 메시지를 전달합니다.

response.getWriter(). write("ok")

 

responseBodyV2

ResponseEntity 엔티티는 HttpEntity를 상속받았는데, HttpEntity는 HTTP 메시지의 헤더, 바디 정보를 가지고 있습니다. ResponseEntity는 여기에 더해서 HTTP 응답 코드를 설정할 수 있습니다.

 

HttpStatus.CREATED로 변경하면 201 응답이 나가는 것을 확인할 수 있습니다.

 

responseBodyV3

@ResponseBody를 사용하면 view를 사용하지 않고, HTTP 메시지 컨버터를 통해서 HTTP 메시지를 직접 입력할 수 있습니다. ResponseEntity 도 동일한 방식으로 동작합니다.

 

responseBodyJsonV1

ResponseEntity를 반환합니다. HTTP 메시지 컨버터를 통해서 JSON 형식으로 변환되어서 반환됩니다.

 

responseBodyJsonV2

ResponseEntity는 HTTP 응답 코드를 설정할 수 있는데, @ResponseBody를 사용하면 이런 것을 설정하기 까다롭습니다.

@ResponseStatus(HttpStatus.OK) 애노테이션을 사용하면 응답 코드도 설정할 수 있습니다.

물론 애노테이션이기 때문에 응답 코드를 동적으로 변경할 수는 없습니다.

프로그램 조건에 따라서 동적으로 변경하려면 ResponseEntity를 사용하면 됩니다.

 

RestController

@Controller 대신에 @RestController 애노테이션을 사용하면, 해당 컨트롤러에 모두 @ResponseBody 가 적용되는 효과가 있습니다.

따라서 뷰 템플릿을 사용하는 것이 아니라, HTTP 메시지 바디에 직접 데이터를 입력합니다.

이름 그대로 Rest API(HTTP API)를 만들 때 사용하는 컨트롤러입니다.

참고로 @ResponseBody는 클래스 레벨에 두면 전체에 메서드에 적용되는데, @RestController 에노 테이션 안에 @ResponseBody 가 적용되어 있습니다.

 

다음 포스팅에서는 HTTP 메시지 컨버터에 대해서 알아보겠습니다!!