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

[YuDeokRin]

5️⃣ HTTP 요청 - 기본, 헤더 조회

• HTTP 헤더 정보를 조회하는 방법 → 코드에서 설명

• 애너테이션 기반의 스프링 컨트롤러에서 지원하는 파라미터들 출력

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

➡️HTTP 헤더 정보 관련

• HttpServletRequest

• HttpServletResponse

• HttpMethod : HTTP메서드를 조회한다.

  • HttpMethod 내부

  *static* {    
  		values = *new* HttpMethod[]{GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS, TRACE};
  }

• Locale : Locale 정보를 조회한다.

  • 위 코드실행 결과 값 : locale=ko_KR

• @RequestHeader MultiValueMap<String, String> headerMap

  • 모든 HTTTP 헤더를 MultiValueMap 형식으로 조회한다.
  • MultiValueMap는 한 개의 키에 복수의 값을 넣을 수 있다.
    • ex) keyA=value1&keyA=value2

• @RequestHeader("host") String host

  • 특정 HTTP 헤더를 조회한다. → “host”
  • 속성
    • 필수 값 여부 : required
    • 기본 값 속성 : defaultValue

• @CookieValue(value = “myCookie”, required = false) String cookie

  • 특정 쿠리를 조회한다.
  • 속성
    • 필수 값 여부 : required
    • 기본 값 속성 : defaultValue

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

1️⃣HTTP 요청 데이터 조회 - 개요

• 서블릿에서 했던 것과 비교해서 스프링이 어떻게 바뀌었고 얼마나 효율적으로 바뀌었는지 알아보자.
• HTTP 요청 메시지를 통해 클라이언트에서 서버로 데이터를 전달하는 방법을 알아보자.

➡️클라이언트에서 서버로 요청 데이터를 전달할 때는 주로 3가지 방법

• GET - 쿼리 파라미터
  • /url?username=hello&age=20
  • 메시지 바디 없이, URL의 쿼리 파라미터에 데이터를 포함해서 전달
  • 예) 검색, 필터, 페이징등에서 많이 사용하는 방식
• POST - HTML Form
  • content-type: application/x-www-form-urlencoded
  • 메시지 바디에 쿼리 파리미터 형식으로 전달 username=hello&age=20
  • 예) 회원 가입, 상품 주문, HTML Form 사용
• HTTP message body에 데이터를 직접 담아서 요청
  • HTTP API에서 주로 사용, JSON, XML, TEXT
  • 데이터 형식은 주로 JSON 사용
  • POST, PUT, PATCH

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

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

• GET, 쿼리 파라미터 전송

  • Ex)

  http://localhost:8080/request-param?username=Dante&age=3

• POST, HTML Form 전송

  • Ex)

  POST /request-param ...
  
  content-type: application/x-www-form-urlencoded
  username=Datne&age=3

• GET 쿼리 파라미터 전송, POST HTML Form 전송 방식이든 둘다 형식이 같으므로 구분 없이 조회할 수 있다.→ 이것을 간단히 요청 파라미터(request parameter) 조회라 한다.

3️⃣ 스프링으로 요청 파라미터 조회하는 방법

• RequestParamController
  • request.getParameter()

@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.valueOf(request.getParameter("age"));
        log.info("username = {}, age = {}", username, age);

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

• 참고 : Jar를 사용하기 때문에 webapp 경로를 사용할 수 없다. 스프링 부트를 쓰면 정적 리소스를 클래스 경로에 함께 포함해야 한다.

7️⃣ HTTP 요청 파라미터 - @RequestParam

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

✅requestParamV2

 /**
  * @RequestParam 사용
  * - 파라미터 이름으로 바인딩
  * @ResponseBody 추가
  * - View 조회를 무시하고, HTTP message body에 직접 해당 내용 입력
  */
@RequestMapping("/request-param-v2")
public String requestParamV2(@RequestParam("username") String username,
                               @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.getParameter(”username”)

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

✅requestParamV4

• String , int , Integer 등의 단순 타입이면 @RequestParam 도 생략 가능
• 주의
  • @RequestParam 애노테이션을 생략하면 스프링 MVC는 내부에서 required = false를 적용한다.
• 참고
  • 아래와 같이 애노테이션을 생략해도 되는데, 너무 없는 것도 약간 과하다는 센세의 생각을 말씀하셨다.
  • @RequestParam이 있으면 명확하게 요청 파라미터에서 데이터를 읽는 다는 것을 알 수 있다.

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

✅파라미터 필수 여부 -requestParamRequired

• @RequestParam.required 는 파라미터 필수 여부 설정 옵션

• /request-param-required 요청

  • username이 없으므로 400 예외가 발생한다.

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

  • /request-param-required?username=
  • 파라미터 이름만 있고 값이 없는 경우 → 빈문자로 통과한다.

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

  • /request-param 요청
  • @RequestParam(required =false) int age

• 해결법

  • null을 int에 입력하는 것은 불가능 따라서 null을 받을 수 있는 Integer같은 걸로 변경 또는 defaultValue사용

/**
  * @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,
         @RequestParam(required = false) Integer age) {
     
     log.info("username={}, age={}", username, age);
		 return "ok";
}

• 기본 값 적용 - requestParamDefault
  • 파라미터에 값이 없는 경우 defaultValue를 사용하면 기본 값을 적용할 수 있다.
  • 따라서 required는 필요가 없어진다.

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

• 파라미터를 Map으로 조회하기 - requestParamMap
  • 파라미터를 Map, MultiValueMap으로 조회할 수 있다.
  • 보통 MultiValueMap를 많이 쓴다

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

8️⃣ HTTP 요청 파라미터 - @ModelAttribute

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

@RequestParam String username;
@RequestParam int age;

HelloData data = new HelloData();
data.setUsername(username);
data.setAge(age);

스프링은 이 과정을 자동화 해주는 애너테이션이 있다. @ModelAttribute 이다.

• HelloData
  • @Data는 롬복에 있는 애너테이션으로 @Getter, @Setter, @tostring, @EqualsAndHashCode, @requiredargsconstructor를 자동으로 만들어줌

package hello.springmvc.basic;
import lombok.Data;

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

✅@ModelAttribute 적용 - modelAttributeV1

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

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

➡️프로퍼티

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

 class HelloData {
     getUsername();
     setUsername();
 }

✅@ModelAttribute 적용 - modelAttributeV2

• @ModelAttribute는 생략할 수 있다.
• @RequestParam도 생략할 수 있으니 혼란이 발생할 수 있음.
• 혼란 방지를 위해 스프링은 해당 생략시 다음과 같은 규칙을 적용함
  • String, int, Integer, 같은 단순 타입 = @RequestParam
  • 나머지 = @ModelAttribute(argument resolver를 지정해준 타입 외)

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

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

• HTTP message body에 데이터를 직접 담아서 요청
  • HTTP API에서 주로 사용, JSON, XML, TEXT
  • 데이터 형식은 주로 JSON 사용
  • POST, PUT, PATCH

요청 파라미터와 다르게, HTTP 메시지 바디를 통해 데이터가 직접 넘어오는 경우는 @RequestParam, @ModelAttribute를 사용할 수 없다.(HTML Form 형식으로 전달되는 경우는 요청 파라미터로 인정된다)

1. 가장 단순한 텍스트 메시지를 HTTP 메시지 바디에 담아서 전송하고, 읽어보자.
2. 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");
     }
}

✅Input, Output 스트림, Reader -requestBodyStringV2

• InputStream(Reader): HTTP요청 메시지 바디의 내용을 직접 조회
• OutputStream(Writer) : HTTP 응답 메시지의 바디에 직접 결과 출력

/**
 * 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");
 }

✅HttpEntity - requestBodyStringV3

• 스프링 MVC는 다음 파라미터를 지원한다.

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

• HttpEntity를 상속받은 객체들도 다음과 같은 기능을 제공한다.

  • RequestEntity
    • HttpMethod, url 정보가 추가, 요청에서 사용
  • ResponseEntity
    • HTTP 상태 코드 설정 가능, 응답에서 사용
    • return new ResponseEntity("Hello World", responseHeaders,
      HttpStatus.CREATED)

/**
* 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");
}

✅**@RequestBody - requestBodyStringV4**

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

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

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

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

➡️ @responsebody

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

1️⃣ 0️⃣ HTTP 요청 메시지 - JSON

• HTTP API에서 주로 사용하는 JSON데이터 형식을 조회하는 방법을 알아보자.

✅RequestBodyJsonController

• HttpServletRequest를 사용해서 직접 HTTP 메시지 바디에서 데이터를 읽어와서 , 문자로 변환한다.
• 문자로 된 JSON 데이터를 Jackson 라이브러리인 objectMapper를 사용해서 자바 객체로 변환한다.

/**
 * {"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");
    }
}

✅requestBodyJsonV2 - @RequestBody 문자 변환

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

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

• 문자로 변환하고 다시 json으로 변환하는 과정이 불편하다 → @ModelAttribute처럼 한번에 객체로 변환할 수 있는 방법

✅requestBodyJsonV3 - @RequestBody 객체 변환

• @RequestBody 객체 파라미터
  • @RequestBody HelloData data
  • @RequestBody` 에 직접 만든 객체를 지정할 수 있다.
• HttpEntity, @RequestBody를 사용하면 HTTP 메시지 컨버터가 HTTP 메시지 바디의 내용을 우리가 원하는 문자나 객체 등으로 변환해준다.
• HTTP 메시지 컨버터는 문자 뿐만 아니라 JSON도 객체로 변환해주는데, 우리가 방금 V2 했던 작업을 대신 처리해준다.

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

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

  • String , int , Integer 같은 단순 타입 = @RequestParam
  • 나머지 = @ModelAttribute (argument resolver 로 지정해둔 타입 외)

• 따라서 HelloData에 @RequestBody를 생략하면 @ModelAttribute가 적용되어버린다.

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

✅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

• @responsebody

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

• @RequestBody 요청

  • JSON 요청 → HTTP 메시지 컨버터 → 객체

• @responsebody 응답

  • 객체 → HTTP 메시지 컨버터 → JSON 응답

/**
* @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;
}

[seyxxn]

이번에 분량 엄청 많았는데 제일 먼저 올리셨네요 ㅎㅎ 굳입니다 !

[YuDeokRin]

장난 아닙니다 양이 ..