Spring MVC 기본 기능 - 요청 매핑 @RequestMapping, @RequestParam

요청 매핑

MappingController.java

@RequestMapping 축약 - @GetMapping, @PostMapping 등등 ..

@RestController
public class MappingController {

    private Logger log = LoggerFactory.getLogger(getClass());

    /**
    편리한 @RequestMapping 축약 어노테이션
    @GetMapping
    @PostMapping
    @DeleteMapping
    @PatchMapping
    @PutMapping
     */
    @GetMapping(value = "/hello-basic")
    public String helloBasic() {
        log.info("helloBasic");
        return "ok";
    }

@RestController 
: @Controller는 반환 값이 String 이면 뷰 이름으로 인식해서 뷰를 찾고 뷰를 렌더링 하는 반면 @RestController는 반환 값으로 뷰를 찾는 게 아니라, String을 HTTP 바디에 바로 입력합니다.

@RequestMapping("/hello-basic")
: /hello-basic URL이 호출되면 이 메소드가 실행되도록 매핑했습니다.
대부분의 속성을 배열[]로 제공하기 때문에 다중 설정 또한 가능합니다.

메소드 또한 축약 어노테이션을 사용해서 지정할 수 있습니다.
@GetMapping : GET 요청일 경우만 호출  (= @RequestMapping(value="", method = RequestMethod.GET)
@PostMapping : Post 요청일 경우만 호출  
@DeleteMapping : Delete 요청일 경우만 호출 
@PatchMapping : Patch 요청일 경우만 호출 
@PutMapping : Put 요청일 경우만 호출 

Logic : /hello-basic URL 호출 ▶︎ helloBasic() 메소드 실행 ▶︎ helloBasic log ▶︎ HTTP 바디에 "ok" 리턴 

 

@PathVariable 경로 변수

/**
@PathVariable
 */

@GetMapping("/mapping/{userId}/{orderId}")
public String mappingPath(@PathVariable("userId") String userId, @PathVariable("orderId") String orderId) {
    log.info("mappingPath userId ={}, orderId={}", userId, orderId);

    return "Ok";
}

@PathVariable
: 메소드 내부에 @PathVariable를 사용해 경로변수를 설정할 수 있습니다.

❗️@PathVariable 변수 이름과 매핑된 URL 변수 이름이 같다면 @PathVariable을 생략할 수 있습니다.
* @PathVariable("userId") String userId, @PathVariable("orderId") String orderId ▶︎ @PathVariable String userId, @PathVariable String orderId

@RequestMapping - 특정 파라미터 조건 매핑 (params)

/**
 * 파라미터로 추가 매핑
 * params="mode",
 * params="!mode"
 * params="mode=debug"
 * params="mode!=debug" (! = )
 * params = {"mode=debug","data=good"}
 */
@GetMapping(value = "/mapping-param", params = "mode=debug")
public String mappingParam() {
    log.info("mappingParam");
    return "ok";
}

 특정 파라미터가 있거나 없는 조건을 추가할 수 있습니다. 잘 사용하진 않습니다.

실행 : localhost:8080/mapping-param?mode=debug

@RequestMapping - 특정 헤더 조건 매핑 (header)

/**
 *특정 헤더로 추가 매핑
 * headers="mode",
 * headers="!mode"
 * headers="mode=debug"
 * headers="mode!=debug" (! = )
 */
@GetMapping(value = "/mapping-header", headers = "mode=debug")
public String mappingHeader() {
    log.info("mappingHeader");
    return "ok";
}

파라미터와 유사하지만 HTTP 헤더를 사용합니다.
테스트 하기 위해서는 Postman을 사용해야 합니다.

 

header 조건 추가 하지 않고 Send / header 조건 추가하고 Send

@RequestMapping - 헤더 기반 추가 매핑 Media Type (consumes)

/**
 * Content-Type 헤더 기반 추가 매핑 Media Type
 * consumes="application/json"
 * consumes="!application/json"
 * consumes="application/*"
 * consumes="*\/*"
 * MediaType.APPLICATION_JSON_VALUE
 */
@PostMapping(value = "/mapping-consume", consumes = "application/json")
public String mappingConsumes() {
    log.info("mappingConsumes");
    return "ok";
}

HTTP 요청의 Content-Type 헤더를 기반으로 미디어 타입으로 매핑합니다.
만약 맞지 않으면 HTTP 415 상태코드(Unsupported Media Type)를 리턴합니다.

HTTP 헤더에 Content-type을 설정하기 전 / 후 

 

Accept 헤더 기반 Media Type 콘텐츠 네고시에이션 ( produces )

Accpet 헤더를 통해 클라이언트는 서버로부터 받고자 하는 데이터 형식을 지정할 수 있었습니다.

https://rlaehddnd0422.tistory.com/45

HTTP 표현 헤더

/**
 * Accept 헤더 기반 Media Type ( 콘텐츠 네고시에이션 )
 * produces = "text/html"
 * produces = "!text/html"
 * produces = "text/*"
 * produces = "* \/*"
*/
@PostMapping(value = "/mapping-produce", produces = "text/html")
public String mappingProduces() {
    log.info("mappingProduces");
    return "ok";
}

HTTP 요청의 Accept 헤더를 기반으로 미디어 타입으로 매핑합니다.
만약 맞지 않으면 HTTP 406 상태코드(Not Acceptable)를 반환합니다.

produces 파라미터 예시

  produces = "text/plain"
  produces = {"text/plain", "application/*"}
  produces = MediaType.TEXT_PLAIN_VALUE
  produces = "text/plain;charset=UTF-8"

---

요청 매핑 - API 예시

@RestController // @Controller + @ResponseBody
@RequestMapping("/mapping/users")
public class MappingClassController {

    /**
     * 회원 관리 API
     *
     * 회원 목록 조회: GET /users
     * 회원 등록: POST /users
     * 회원 조회: GET /users/{userId}
     * 회원수정: PATCH /users/{userId}
     * 회원 삭제: DELETE /users/{userId}
    */

    @GetMapping
    public String user()
    {
        return "get users";
    }

    @PostMapping
    public String addUser()
    {
        return "post user";
    }

    @GetMapping("/{userId}")
    public String findUser(@PathVariable String userId)
    {
        return "get userId=" + userId;
    }

    @PatchMapping("/{userId}")
    public String updateUser(@PathVariable String userId)
    {
        return "update userId=" + userId;
    }

    @DeleteMapping("/{userId}")
    public String deleteUser(@PathVariable String userId)
    {
        return "delete userId=" + userId;
    }
}

• @RequestMapping("/mapping/users") : 클래스 레벨에 매핑 정보를 두면 메소드 레벨에서 해당 정보를 Prefix로 사용합니다.
• 이제 매핑 방법을 이해했으니, 이제부터 HTTP 요청이 보내는 데이터들을 스프링 MVC로 어떻게 조회하는지 알아보도록 하겠습니다.

---

HTTP 요청 - 기본, 헤더 조회

어노테이션 기반의 스프링 컨트롤러는 다양한 파라미터를 지원합니다.

Request, Response에 대한 HTTP 헤더 또한 조회가 가능합니다.

코드를 통해 알아보겠습니다.

@Slf4j
@RestController
public class RequestHeaderController {

    @RequestMapping("/headers")
    public String headers(HttpServletRequest request,
                          HttpServletResponse response,
                          HttpMethod httpMethod,
                          Locale locale,
                          @RequestHeader MultiValueMap<String, String> headerMap,
                          @RequestHeader("host") String host,
                          @CookieValue(value = "myCookie", required = false) String cookie)
    {
        log.info("request={}", request);
        log.info("response={}", response);
        log.info("httpMethod={}", httpMethod);
        log.info("locale={}", locale);
        log.info("headerMap={}", headerMap);
        log.info("header host={}", host);
        log.info("myCookie={}", cookie);

        return "ok";

    }
}

HTTP 헤더를 조회하고 싶을 때는  메소드 파라미터에 조회하고 싶은 정보를 입력하면 됩니다.

스프링 컨트롤러에서는 ArgumentResolver라는 툴을 이용해 파라미터를 이렇게 유연하게 처리해줍니다.

ArgumentResolver에 대해서는 뒤에서 다루도록 하겠습니다.

 

HTTP 헤더 log 정보

• HttpServletRequest, HttpServletResponse 
• HttpMethod : HTTP 메소드를 조회합니다 (org.springframework.http.HttpMethod)
• Locale : Locale 정보를 조회합니다.
• @RequestHeader MultiValueMap<String, String > headerMap : 모든 HTTP 헤더를 MultiValueMap 형식으로 조회합니다.
  • MultiValueMap은  키의 중복이 허용된다. 즉, 하나의 키는 여러가지 value를 가질 수 있음.
  • https://taehoung0102.tistory.com/182

자바 Map 과 MultiValueMap의 대해서

 

• @RequestHeader("host") String host : 특정 HTTP 헤더를 조회합니다.
  • 필수 값 여부 : required 로 지정
  • 기본 값 : defaultValue
• @CookieValue(value="myCookie", required = false ) String Cookie : 특정 쿠키를 조회합니다.
  • 필수 값 여부 : required
  • 기본 값 : defaultValue

---

1 , 2.  HTTP 요청 파라미터 - 쿼리 파라미터(GET) , HTML Form(POST)

HTTP 요청 메시지를 통해 클라이언트에서 서버로 데이터를 전달하는 방법에는 3가지 방법이 있었습니다.

1. 쿼리 파라미터를 통한 전송(GET)

• /url?username=hello&age=20
• 메시지 바디 없이 순수 쿼리 파라미터에 데이터를 포함해서 전달하는 방식
• 주로 검색, 필터, 페이징등에서 쓰는 방식

2. HTML Form 을 통한 전송(POST)

• content-type : application/x-www-form-urlencoded
• 메시지 바디에 쿼리 파라미터 형식으로 전달 username=hello&age=20
• 회원가입이나 상품 주문 등에서 HTML Form을 통해 사용하는 방식

3. HTTP message body에 직접 데이터를 담아서 전송

• HTTP API에서 주로 사용. JSON, XML, TEXT
• 데이터 형식은 주로 JSON을 사용합니다.
• PUT, PATCH, POST 

@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);

    PrintWriter writer = response.getWriter();
    writer.write("ok");
}

GET 방식 전송

 

POST 방식 전송

 HttpServletRequest의 request.getParameter()을 사용하면 POST, GET 방식 모두 요청 파라미터를 조회할 수 있습니다.

이것을 간단히 요청 파라미터 (request parameter) 조회라고 합니다.

 

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

---

HTTP 요청 파라미터 -@RequestParam

@RequestParam  V2 - 기본

// @RequestParam 사용 - String, int, Integer 같은 단순 타입
@ResponseBody
@RequestMapping("/request-param-v2")
public String requestParamV2(@RequestParam("username") String username,
                           @RequestParam("age") int age) throws IOException
{
    log.info("username = {}, age={}", username, age);
    return "OK";
}

이 전에서는 HttpServletRequest가 제공하는 방식으로 요청 파라미터를 조회했지만,

@RequestParam 에 파라미터를 바인딩해서 요청 파라미터를 조회할 수 있습니다.

 

@RequestParam의 name(value) 속성이 파라미터 이름으로 사용

@RequestParam("username") String memberName ➣ request.getParameter("username")

 

@RequestParam : 파라미터 이름으로 바인딩
@Responsebody : View 조회 무시, HTTP message body에 직접 해당 내용 입력

v2 GET

v2 POST

v2 log

@RequestParam V3 - value 생략

/**
 * @PathVaraiable 과 마찬가지로
 * @RequestParam 또한 value 와 변수 이름이랑 같으면 value 생략 가능
 */

@ResponseBody
@RequestMapping("/request-param-v3")
public String requestParamV3(@RequestParam String username,
                             @RequestParam int age) throws IOException
{
    log.info("username = {}, age={}", username, age);
    return "OK";
}

@PathVariable과 마찬가지로 @RequestParam에서도 변수이름과 value가 같으면 value를 생략할 수 있습니다.

@RequestParam V4 - @RequestParam 생략

/**
 *
 * @param username
 * @param age
 * @return
 * @throws IOException
 *
 * @RequestParam도 생략 가능. 근데 권장하진 않음.
 */
@ResponseBody
@RequestMapping("/request-param-v4")
public String requestParamV4(String username, int age) throws IOException
{
    log.info("username = {}, age={}", username, age);
    return "OK";
}

심지어 String, int, Integer와 같은 단순 타입일 경우에는 @RequestParam도 생략할 수 있습니다. 근데 명시적이지 않아 읽는 사람이 읽기 어려울 수 있어요. 권장하진 않습니다.

 

@RequestParam - required 옵션 , defaultValue 옵션

// required 옵션
@ResponseBody
@RequestMapping("/request-param-required")
public String requestParamRequired(
        @RequestParam(required = true) String username,
        @RequestParam(required = false) Integer age) {  // Integer 는 null 지원
    log.info("username={}, age={}", username, age);
    return "OK";
}

// defaultValue 옵션
// 빈 문자("")까지 defaultValue로 처리
@ResponseBody
@RequestMapping("/request-param-default")
public String requestParamDefault(
        @RequestParam(required = true, defaultValue = "guest") String username,
        @RequestParam(required = false, defaultValue = "1") Integer age) {
    log.info("username={}, age={}", username, age);
    return "OK";
}

• required 옵션을 true로 설정한 파라미터는 요청 시 필수적으로 있어야 합니다.
• 주의 : 빈 문자("")도 통과함 (?username=""&age=20)
• defaultValue 옵션을 설정한 파라미터는 요청 시 입력하지 않으면 defaultValue로 설정됩니다.
• defaultValue를 true로 설정한 경우 required 옵션은 의미가 사라집니다 ( 디폴트로 값이 설정되므로 )
• defaultValue는 빈 문자의 경우에도 설정한 기본 값이 적용됩니다.

@RequestParam - Map, MultiMap을 통한 파라미터 조회

/**
 *
 * @param paramMap
 * @return
 */
@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";
}


/**
 *
 * @param paramMultiMap
 * @return
 */
@ResponseBody
@RequestMapping("/request-param-Multimap")
public String requestParamMap(@RequestParam MultiValueMap<String, Object> paramMultiMap)
{
    log.info("username={}, age={}", paramMultiMap.get("username"), paramMultiMap.get("age"));
    return "OK";
}

 

파라미터가 여러값을 가지는 경우 MultiMap 사용

MultiMap log

• 요청 파라미터를 Map, MultiMap을 통해 조회할 수 있습니다.
• 요청 파라미터의 값이 1개가 확실하다면 Map 을 사용해도 되지만, 그렇지 않다면 MultiValueMap 을 사용하도록 합시다.

---

HTTP 요청 파라미터 -@ModelAttribute

 

먼저 요청 파라미터를 바인딩할 객체를 만들겠습니다.

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

@Data - Lombok 라이브러리의 어노테이션으로 @Setter, @Getter, @Tostring, @EqualsAndHashCode, @RequiredArgsConstructor를 포함하고 있습니다.

 

 

실제 개발을 할때에는 요청 파라미터를 받아, 객체를 만들고, 그 객체에 값을 넣어주어야 합니다. 보통 다음과 같이 작성합니다.

@ResponseBody
@RequestMapping("/model-attribute-v0")
public String modelAttributeV0(@RequestParam String username, @RequestParam int age)
{
    HelloData data = new HelloData();
    data.setAge(age);
    data.setUsername(username);
    log.info("username = {} , age = {} ", username, age);

    return "ok";
}

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

 

 

@ModelAttribute V1 

@ResponseBody
@RequestMapping("/model-attribute-v1")
public String modelAttributeV1(@ModelAttribute HelloData helloData)
{
    log.info("username = {} , age = {} ", helloData.getUsername(), helloData.getAge());
    log.info("data = {}",helloData);

    return "ok";
}

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

 

1.  HelloData 객체 생성

2.  요청 파라미터의 이름으로 HelloData 객체의 property( username, age )를 찾습니다.

3.  그리고 해당 프로퍼티의 setter를 호출해서 파라미터의 값을 입력(바인딩)해서 객체에 값을 주입합니다.

ex) username -> setUsername() 메소드 찾아서 값 주입

 

❗️바인딩 오류 : age=abc 처럼 숫자가 들어가야 할곳에 문자가 들어가면 BindException 예외 발생. 이런 바인딩 오류를 처리하는 방법은 검증 부분에서 다루겠습니다. 우선 패스

 

@ModelAttribute 생략 

// @ModelAttribute 또한 생략 가능.
// 하지만 @RequestParam 도 생략 가능하기 때문에 혼란이 발생할 수 있다.
// 권장하지 않음.
@ResponseBody
@RequestMapping("/model-attribute-v2")
public String modelAttributeV2(HelloData helloData)
{
    log.info("username = {} , age = {} ", helloData.getUsername(), helloData.getAge());
    log.info("data = {}",helloData);

    return "ok";
}

---

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

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

 

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

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

@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("message body = {}", messagebody);

    PrintWriter writer = response.getWriter();
    writer.write("ok");
}

 

Body : Text-raw

 

log

 

이제 스프링 MVC가 지원하는 파라미터를 사용해 메시지 바디를 읽어보겠습니다.

 

InputStream, OuputStream(Writer) 사용한 메시지 바디 출력

/**
 * @param inputStream    : HTTP 요청 메시지 바디의 내용을 직접 조회
 * @param responseWriter : HTTP 응답 메시지의 바디에 직접 결과 출력
 * @return
 * @throws IOException
 */
@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 응답 메시지의 바디에 직접 결과 출력

v2 Post 전송

 

log 출력

 

HttpEntity를 통한 메시지 바디 조회

    /**
     * HttpEntity 패키지 사용
     * @param httpEntity
     * @return
     * @throws IOException
     */
    @PostMapping("/request-body-string-v3")
    public HttpEntity<String> requestBodyStringV3(HttpEntity<String> httpEntity) throws IOException {

        String messagebody = httpEntity.getBody();
        log.info("messageBody = {}", messagebody);

        return new HttpEntity<String>("ok");

//        return new ResponseEntity<>("ok", HttpStatus.CREATED);
    }

 

HttpEntity 는 HTTP 헤더, body 정보를 편리하게 조회할 수 있도록 도와주는 객체입니다.

요청뿐만 아니라 응답에서도 HttpEntity를 사용할 수 있습니다.

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

• HttpEntity: HTTP header, body 정보를 편리하게 조회
  • 메시지 바디 정보를 직접 조회
  • 요청 파라미터를 조회하는 기능과 관계 없음 @RequestParam X, @ModelAttribute X
• HttpEntity는 응답에도 사용 가능
  • 메시지 바디 정보 직접 반환
  • 헤더 정보 포함 가능
  • view 조회X

RequestEntity, ResponseEntity는 HttpEntity를 상속받은 객체로 

RequestEntity는 HttpMethod, url 정보가 추가되어 , request에서 사용합니다.

ResponseEntity는 HTTP 상태코드를 설정할 수 있고, response에서 사용합니다.

 

@RequestBody를 사용한 메시지 바디 조회

/**
 * @RequestBody 사용 - 실무에서 가장 많이 사용하는 방식
 * @param messageBody
 * @return
 */
@ResponseBody
@PostMapping("/request-body-string-v4")
public String requestBodyStringV4(@RequestBody String messageBody)
{
    log.info("message body = {}",messageBody);
    return "OK";
}

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

 

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

 

요청 파라미터 조회 : @RequestParam, @ModelAttribute

메시지 바디 조회 : @RequestBody

 

3. HTTP 요청 메시지 - JSON

단순 텍스트형식의 메시지바디와 Json형식의 메시지 바디 조회는 크게 다르지 않습니다.

 

우선 MVC 적용 이전의 Json 형식의 메시지 바디 조회 방법은

@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());

    PrintWriter writer = response.getWriter();
    writer.write("Ok");
}

 이렇게 inputStream으로 messagebody를 읽어 문자로 변환한 뒤 문자로 된 json 데이터를 jackson 라이브러리인 objectMapper를 사용해 자바 객체로 변환해 주었었습니다.

 

단순 텍스트와 마찬가지로 JSON에서도 @RequestBody를 사용합니다.

 

HttpServletRequest ▶︎ @RequestBody 

// V2
// @RequestBody (생략 불가능, 생략 시 @ModelAttribute가 적용되어 버림)
@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를 통해 자바 객체로 변환.

 

messgae body -> 문자 변환 -> json 변환 -> 객체로 변환 

 

문자로 변환하고 다시 json으로 변환하는 과정이 좀 귀찮은데 줄일 수 없을까?

줄일 수 있습니다.

 

❗️@RequestBody는 생략이 불가능합니다.

스프링은 @ModelAttribute, @RequestParam과 같은 어노테이션을 생략할 때 아래 규칙을 적용합니다.

• String , Integer, int 와 같은 단순 타입 = @RequestParam
• 그 외의 타입 = @ModelAttribute ( argument resolver로 지정해둔 타입을 제외한 모든 타입)

따라서 이 경우 HelloData에 @RequestBody를 생략하면 @ModelAttribute가 적용되어 버리기 때문에 메시지 바디가 아닌 요청 파라미터를 처리하게 됩니다!

@RequestBody에 String이 아닌 객체 파라미터 사용

// V3
// @RequestBody에 객체를 파라미터로 지정할 수 있다.
@ResponseBody
@PostMapping("/request-body-json-v3")
public String requestBodyJsonV3(@RequestBody HelloData data)
{
    log.info("username = {}, age = {}",data.getUsername(),data.getAge());
    return "OK";
}

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

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

 

HttpEntity를 사용한 ver.

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

 

@ResponseBody에 String이 아닌 객체 리턴할 경우

@ResponseBody
@PostMapping("/request-body-json-v5")
public HelloData requestBodyJsonV5(@RequestBody HelloData data)
{
    log.info("username = {}, age = {}", data.getUsername(),data.getAge());
    return data;
}

객체 정보가 JSON 형태로 메시지 바디에 리턴됩니다. 물론 마찬가지로 HttpEntity를 사용해도 됩니다.

 

@RequestBody 요청 : JSON 요청 -> HTTP 메시지 컨버터 -> 객체

@ResponseBody 응답 : 객체 -> HTTP 메시지 컨버터 -> JSON 응답

 

 

 

 

 

이번 포스팅에서는 Request 매핑에 대해 알아보았습니다.

다음 포스팅에서는 Response 매핑과 HTTP 메시지 컨버터에 대해 알아보겠습니다. 감사합니다.

---

<참고 자료>

https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-mvc-1/dashboard

스프링 MVC 1편 - 백엔드 웹 개발 핵심 기술 - 인프런 | 강의

https://rlaehddnd0422.tistory.com/45

HTTP 표현 헤더