[스프링 MVC 1편] #6. 스프링 MVC - 기본 기능 (2)

[seyxxn]

6_스프링 MVC - 기본 기능 (2)

HTTP 요청 - 기본, 헤더 조회

애노테이션 기반의 스프링 컨트롤러는 다양한 파라미터를 지원
HTTP 헤더 정보를 조회하는 방법을 알아보자

• RequestHeaderController

package hello.springmvc.basic.request;

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpMethod;
import org.springframework.util.MultiValueMap;
import org.springframework.web.bind.annotation.CookieValue;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Locale;

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

    }
}

• HttpServletRequest

  • HTTP의 Request 정보를 서블릿에세 전달하기 위해 사용하는 객체

• HttpServletResponse

  • 요청을 보낸 클라이언트레에 응답을 보내기 위해 서블릿에게 전달하는 객체

• HttpMethod

  • HTTP 메서드를 조회

• Locale

  • Locale 정보를 조회

• @RequestHeader MultiValueMap<String, String> headerMap

  • 모든 HTTP 헤더를 MultiValueMap 형식으로 조회

• @RequestHeader("host") String host

  • 특정 HTTP 헤더를 조회
  • 속성
    • 필수 값 여부 : required
    • 기본 값 속성 : defaultValue

• @CookieValue(value="myCookie", requied=false) String cookie

  • 특정 쿠키를 조회
  • 속성
    • 필수 값 여부 : required
    • 기본 값 : defaultValue

• 실행 결과
  

MultiValueMap

• Map과 유사하나, 하나의 키 값에 여러 값을 받을 수 있음
• HTTP header, HTTP 쿼리 파라미터와 같이 하나의 키에 여러 값을 받을 때 사용

MultiValueMap<String, String> map = new LinkedMultiValueMap();
map.add("keyA", "value1");
map.add("keyA", "value2");

// [value1,value2]
List<String> values = map.get("keyA");

HTTP 요청 파라미터 - 쿼리 파라미터, HTML Form

HTTP 요청 데이터 조회 - 개요

HTTP 요청 메세지를 통해 클라이언트에서 서버로 데이터를 전달하는 방법은 크게 3가지

1. GET - 쿼리 파라미터

• /url?username=helo&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

요청 파라미터 - 쿼리 파라미터, HTML Form

• HttpServletRequest의 request.getParameter()를 사용하면 다음 2가지 요청 파라미터를 조회할 수 있다

GET, 쿼리 파라미터 전송

http://localhost:8080/request-param?username=hello&age=20

POST, HTML Form 전송

POST /request-param ...
content-type: application/x-www-form-urlencoded

username=hello&age=20

• 위의 두 방식(GET 쿼리 파라미터 전송, POST HTML Form 전송) 모두 형식이 같으므로 구분 없이 조회할 수 있다.
• 이것을 요청 파라미터 조회라고 함

Spring으로 요청 파라미터 조회

• RequestParamController : requestParamV1

package hello.springmvc.basic.request;

import hello.springmvc.basic.HelloData;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import java.io.IOException;
import java.util.Map;
import java.util.Objects;

@Slf4j
@Controller
public class RequestParamController {

    // 반환 타입이 없으면서(void) 이렇게 응답에 값을 직접 집어넣으면, view 조회 X
    @RequestMapping("/request-param-v1")
    public void requestParamV1(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String username = request.getParameter("username");
        // 단순히 HttpServletRequest가 제공하는 방식으로 요청 파라미터 조회
        int age = Integer.parseInt(request.getParameter("age"));
        log.info("username={}, age={}", username, age);

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

}

• request.getParameter()
  • 여기에서는 단순히 HttpServletRequest가 제공하는 방식으로 요청 파라미터를 조회했다

HTTP 요청 파라미터 - @RequestParam

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

• RequestParamController : requestParamV2

    @ResponseBody // return 하는 문자를 그대로 HTTP 응답 메세지에 넣어서 반환함 (RestController와 같은 효과)
    @RequestMapping("/request-param-v2")
    public String requestParamV2(
            @RequestParam("username") String memberName,
            @RequestParam("age") int memberAge){
        log.info("username={}, age={}", memberName, memberAge);

        return "ok";
    }

• @RequestParam

  • 파라미터 이름으로 바인딩

• @ResponseBody

  • View 조회를 무시하고, HTTP message body에 직접 해당 내용 입력

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

  • @RequestParam("username") String memberName
  • -> request.getParamter("username")

• RequestParamController : requestParamV3

    @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") 생략 가능

• RequestParamController : requestParamV4

    @ResponseBody
    @RequestMapping("/request-param-v3")
    public String requestParamV3(
            @RequestParam String username, // () 생략 가능 함. 단, 변수명이 동일해야 함
            @RequestParam int age){
        log.info("username={}, age={}", username, age);
        return "ok";
    }

• String, int, Integer 등의 단순 타입이면 @RequestParam도 생략 가능

참고
이렇게 애노테이션을 완전히 생략해도 되지만, 스프링 MVC는 내부에서 required=false를 적용

파라미터 필수 여부

• RequestParamController : requstParamRequired

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

• @RequestParam.required
  • 파라미터 필수 여부
  • 기본 값이 파라미터 필수(true)
• /request-param-required 요청
  • username이 없어서 400 예외 발생
    

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

/request-param-required?username=

• 파라미터 이름만 있고, 값이 없는 경우 -> 빈 문자로 통과

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

• /request-param 요청
• @RequestParam(requied = false) int age
• null을 int에 입력하는 것은 불가능 (500 에러 발생). 따라서 null을 받을 수 있는 Integer로 변경하거나, 또는 defaultValue 사용
  

기본 값 적용

• RequestParamController : requesetParamDefault

    /**
     * @RequestParam
     * - defaultValue 사용
     *
     * 참고: defaultValue는 빈 문자의 경우에도 적용
     * /request-param-default?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를 사용하면 기본 값을 적용할 수 있다. 이미 기본 값이 있기 때문에 required는 의미가 없다.
• defaultValue는 빈 문자의 경우에도 설정한 기본 값이 적용

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

• RequestParamController : requestParamMap

    @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으로 조회할 수 있다
• @RequestParam Map
  • Map(key=value)
• @RequestParam MultiValueMap
  • MultiValueMap(key=[value1, value2, ...] ex) (key=userIds, value=[id1, id2])
• 파라미터의 값이 1개가 확실하다면 Map을 사용해도 되지만, 그렇지 않다면 MultiValueMap을 사용

HTTP 요청 파라미터 - @ModelAttribute

실제 개발을 하면 요청 파라미터를 받아, 필요한 객체를 만들고, 그 객체에 값을 넣어주어야 한다.
스프링은 이러한 과정을 완전히 자동화해주는 @ModelAttribute 기능을 제공한다

• HelloData

package hello.springmvc.basic;

import lombok.Data;

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

• @Data
  • @Getter, @Setter, @ToString, @EqualsAndHashCode, @RequiredArgsConstructor 를 자동으로 적용

@ModelAttribute 적용

• RequestParamController : modelAttributeV1

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

        // log.info("helloData={}", helloData);

        return "ok";
    }

• 이렇게하면, 마치 마법처럼 HelloData 객체가 생성되고, 요청 파라미터의 값도 모두 들어가 있다.
• 스프링 MVC는 @ModelAttribute가 있으면 다음을 실행
  • HelloData 객체를 생성
  • 요청 파라미터의 이름으로 HelloData 객체의 프로퍼티를 찾는다. 그리고 해당 프로퍼티의 setter를 호출해서 파라미터 값을 입력(바인딩)
  • 예) 파라미터의 이름이 username이면, setUsername() 메서드를 찾아서 호출하면서 값을 입력

@ModelAttribute 생략

• RequestParamController : modelAttributeV2

    @ResponseBody
    @RequestMapping("/model-attribute-v2")
    public String modelAttributeV2(HelloData helloData){ // @ModelAttribute 애노테이션 생략
        log.info("username={}, age={}", helloData.getUsername(), helloData.getAge());

        return "ok";
    }

• @ModelAttribute는 생략 가능
  • 하지만, @RequestParam도 생략할 수 있으니 혼란이 발생할 수 있다

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

요청 파라미터와 다르게, HTTP 메시지 바디를 통해 데이터가 직접 넘어오는 경우에는 @RequesetParam, @ModelAttribute를 사용할 수 없다

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

• RequestBodyStringController : requestBodyStringV2

    @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 응답 메시지의 바디에 직접 결과 출력

• RequestBodyStringController : requestBodyStringV3

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

• 스프링 MVC는 다음 파라미터를 지원
  • HttpEntity: HTTP header, body 정보를 편리하게 조회
    • 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)라는 기능을 사용

• RequestBodyStringController : requestBodyStringV4

    // 많이 사용하는 방법
    @ResponseBody
    @PostMapping("/request-body-string-v4")
    public String requestBodyStringV4(@RequestBody String messageBody){
        log.info("messageBody={}", messageBody);

        return "ok";
    }

• @RequestBody
  • HTTP 메시지 바디 정보를 편리하게 조회할 수 있음
  • 헤더 정보가 필요하면 HttpEntity를 사용하거나 @RequestHeader를 사용하면 됨
  • 이렇게 메시지 바디를 직접 조회하는 기능은 요청 파라미터를 조회하는 @RequestParam, @ModelAttribute와는 전혀 관련 X

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

• 요청 파라미터를 조회하는 기능 : @RequestParam, @ModelAttribute
• HTTP 메시지 바디를 직접 조회하는 기능 : @RequestBody

@responsebody

• @ResponseBody를 사용하면 응답 결과를 HTTP 메시지 바디에 직접 담아서 전달할 수 있음
• 이 경우에도 view를 사용하지 않음

HTTP 요청 메세지 - JSON

HTTP API에서 주로 사용하는 JSON 데이터 형식 조회

• RequestBodyJsonController : requestBodyJsonV1

package hello.springmvc.basic.request;

import com.fasterxml.jackson.databind.ObjectMapper;
import hello.springmvc.basic.HelloData;
import jakarta.servlet.ServletInputStream;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpEntity;
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 java.io.IOException;
import java.nio.charset.StandardCharsets;

@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 helloData = objectMapper.readValue(messageBody, HelloData.class);
        log.info("username={}, age={}", helloData.getUsername(), helloData.getAge());

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

}

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

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

• RequestBodyJsonController : requestBodyJsonV2

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

        return "ok";
    }

• 이전에 학습했던 @RequestBody를 사용해서 HTTP 메시지에서 데이터를 꺼내고 messageBody에 저장
• 문자로 된 JSON 데이터인 messageBody를 objectMapper를 통해 자바 객체로 변환

문자로 변환하고, 다시 JSON으로 변환하는 과정이 불편하다. @ModelAttribute 처럼 한 번에 객체로 변환할 수는 없을까?

• RequestBodyJsonController : requestBodyJsonV3

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

        return "ok";
    }

@RequestBody 객체 파라미터

• @RequestBody HelloData data
• @RequestBody에 직접 만든 객체를 지정할 수 있따

@RequestBody는 생략 불가능

• 스프링은 @ModelAttribute, @RequestParam과 같은 해당 애노테이션을 생략 시, 다음과 같은 규칙을 적용시킨다

  • String, int, Integer 같은 단순 타입 = @RequestParam
  • 나머지 = @ModelAttribute

• 따라서, 이 경우에는 HelloData에 @RequestBody를 생략하면, @ModelAttribute가 적용된다.

  • HelloData data -> @ModelAttribute HelloData data
  • 따라서 생략하면 HTTP 메시지 바디가 아니라 요청 파라미터를 처리하게 된다

• RequestBodyJsonController : requestBodyJsonV4

    @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";
    }

• RequestBodyJsonController : requestBodyJsonV5

    /**
     * @RequestBody 생략 불가능(@ModelAttribute 가 적용되어 버림)
     * HttpMessageConverter 사용 -> MappingJackson2HttpMessageConverter (content-type: 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;
    }

• @ResponseBody
  • 응답의 경우에도 @ResponseBody를 사용하면 해당 객체를 HTTP 메시지 바디에 직접 넣어줄 수 있다. 물론 이 경우에도 HttpEntity를 사용해도 된다
• @RequestBody 요청
  • JSON 요청 -> HTTP 메시지 컨버터 -> 객체
• @ResponseBody 응답
  • 객체 -> HTTP 메시지 컨버터 -> JSON 응답

🔗 출처

• 김영한 - 스프링 MVC 1편 - 백엔드 웹 개발 핵심 기술