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

6om1n · 2024-06-28T14:48:00Z

6om1n
Jun 28, 2024
Maintainer

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

HttpMethod : HTTP 메서드를 조회한다. org.springframework.http.HttpMethod

Locale : Locale 정보를 조회한다.

@RequestHeader MultiValueMap<String, String> headerMap

모든 HTTP 헤더를 MultiValueMap 형식으로 조회한다.

@RequestHeader("host") String host

특정 HTTP 헤더를 조회한다.

속성 : 필수 값 여부 - required , 기본 값 속성 - defaultValue

@CookieValue(value = "MyCookie", required = false) String cookie

특정 쿠키를 조회한다.

속성 : 필수 값 여부 - required , 기본 값 - defaultValue

MultiValueMap

Map 과 유사한데, 하나의 키에 여러 값을 받을 수 있다.

HTTP headerm HTTP 쿼리 파라미터와 같이 하나의 키에 여러 값을 받을 때 사용한다.

keyA=vaule&keyA=value2

@Slf4j 는 아래와 같은 코드를 자동으로 생성해서 로그를 선언해준다.
개발자는 편리하게 log 라고 사용하면 된다.

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

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

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

HttpServletRequest 의 request.getParameter() 를 사용ㅇ하면 다음 두 가지 요청 파라미터를 조회할 수 있다.
GET, 쿼리 파라미터 전송

예시 ) content-type: application/x-www-form-urlencoded

POST, HTML Form 전송

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

 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;

@Slf4j
@Controller
public class RequestParamController {

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

    }
}

반환 타입이 없으면서 이렇게 응답에 값을 직접 넣으면, view로 조회 되지 않는다.

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

Post Form 페이지 생성
리소스는 /resources/static 아래에 두면 스프링 부트가 자동으로 인식한다.
main/resources/static/basic/hello-form.html

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<form action="/request-param-v1" method="post">
    username: <input type="text" name="username" />
    age: <input type="text" name="age" />
    <button type="submit">전송</button>
</form>
</body>
</html>

✏️ HTTP 요청 파라미터 - `@RequestParam`

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

🔍 `requestparamV2`

 @ResponseBody
    @RequestMapping("request-param-v2")
    public String requestParamV2 (
        @RequestParam("username") String memberName,
        @RequestParam("age") int memberAge) {

        log.info("username={}, age={}", memberName, memberAge);
        return "ok";
    }

원래는 @Controller 이면서 String이면 뷰리졸버로 "ok" 라는 뷰를 찾게된다.

@RequestParam : 파라미터 이름으로 바인딩

@ResponseBody : View 조회를 무시하고, HTTP message body 에 직접 해당 내용 입력 -> @RestController 와 같은 의미이다.

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

@RequestParam("username") String memberName

request.getParameter("username")

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

🔍 `requestparamV4`

 @ResponseBody
    @RequestMapping("request-param-v4")
    public String requestParamV4 (String username, int age) {

        log.info("username={}, age={}", username, age);
        return "ok";
    }

@RequestParam 사용

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

이와 같이 다 없애서 사용할 수 있지만, 요청 파라미터의 이름과 맞아야한다.

@RequestParam 애노테이션을 생략하면 required=false 를 적용한다.

🔍 파라미터 필수 여부 - `requestparamRequired`

 @ResponseBody
    @RequestMapping("request-param-required")
    public String requestParamRequired(
            @RequestParam(required = true) String username,
            @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= 인 경우 파라미터 이름만 있고 값이 없는 경우는 빈문자로 통과된다.

만약 코드를 @RequestParam(required=false) int age 로 수정했을 경우

위의 경우 파라미터에 값이 없는 경우에는 null을 int 기본형에 입력하는 것이 불가능하다. (500 예외 발생)

따라서 null 을 받을 수 있는 Integer로 변경하거나, defaultValue 를 사용해야한다.

🔍 기본 값 적용 - `requestparamDefault`

    @ResponseBody
    @RequestMapping("request-param-default")
    public String requestParamDefalut(
            @RequestParam(required = true, defaultValue = "guest") String username,
            @RequestParam(required = false, defaultValue = "-1") int age) {

        log.info("username={}, age={}", username, age);
        return "ok";
    }

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

이미 기본 값이 있기 때문에 required 는 의미가 없다.

빈 문자인 경우에도, 값을 입력해주지 않은 경우에도 설정한 기본 값이 적용된다.

🔍 파라미터를 Map 으로 조회하기 - `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 을 사용하자.

하지만, 보통 파라미터 값은 1개를 넣는다.

✏️ HTTP 요청 파라미터 - `@ModelAttribute`

실제 개발을 하다보면, 요청 파라미터를 받아서 필요한 객체를 만들고, 그 객체에 값을 넣어주어야 한다.

@RequestParam String username;
@RequestParam int age;

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

스프링은 이 과정을 완전히 자동화해주는 @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` 적용 - modelAttributeV1

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

위와 같이 코드를 작성했더니, HelloData 객체가 생성되고, 요청 파라미터의 값도 모두 들어가 있다.

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

HelloData 객체를 생성한다.

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

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

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

🔍 `@ModelAttribute` 생략 - modelAttributeV2

    @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

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

요청 파라미터와 다르게, HTTP 메시지 바디를 통해 데이터가 직접 넘어오는 경우는 @RequestParam , @ModelAttribute 를 사용할 수 없다.
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 을 사용해서 테스트를 할 때

POST http://localhost:8080/request-body-string-v1

Body -> row, text 선택

🔍 Input, Output 스트림, Reader - 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");
    }

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

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

🔍 HttpEntity - 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<String>("ok");
    }

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)

🔍 RequestBody - reqeustBodyStringV4

    @ResponseBody
    @PostMapping("/request-body-string-v4")
    public HttpEntity<String> requestBodyStringV4(@RequestBody String messageBody) {
        log.info("messageBody={}", messageBody);
        return new HttpEntity<String>("ok");
    }

@RequestBody

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

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

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

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

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

@ResponseBody

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

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

✏️ HTTP 요청 메시지 - JSON

HTTP API에서 주로 사용하는 JSON 데이터 형식을 조회해보자.

🔍 RequestBodyJsonController

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 를 사용해서 자바 객체로 변환한다.

Postman 으로 테스트

POST http://localhost:8080/request-body-json-v1

raw, JSON, content-type : application/json

{"username":"hello" , "age":20}

🔍 requestBodyJsonV2 - `@RequestBody`문자 변환

 @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 를 통해서 자바 객체로 변환한다.

🔍 requestBodyJsonV3 - `@RequestBody` 객체 변환

V2 에서 문자로 변환하고 다시 json으로 변환하는 과정이 불편해서 @ModelAttribute 처럼 한 번에 객체로 변환하기

 @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 에 직접 만든 객체를 지정할 수 있다.

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

HTTP 메시지 컨버터는 문자 뿐만 아니라 JSON 도 객체로 변환해주는데, 우리가 방금 V2 에서 했던 작업을 대신 처리해준다.

@RequestBody 는 생략 불가능

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

🔍 requestBodyJsonV45

    @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편 - 백엔드 웹 개발 핵심 기술

seyxxn · 2024-06-28T15:36:07Z

seyxxn
Jun 28, 2024
Maintainer

화이팅 !!! ~~~

0 replies

Navigation Menu

Uh oh!

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

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{editor}}'s edit

{{editor}}'s edit

Uh oh!

Replies: 1 comment

Uh oh!

{{title}}

Uh oh!

Select a reply

Uh oh!

Uh oh!

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

Uh oh!

Uh oh!

6om1n Jun 28, 2024 Maintainer

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

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

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

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

✏️ HTTP 요청 파라미터 - @RequestParam

🔍 requestparamV2

🔍 requestparamV3

🔍 requestparamV4

🔍 파라미터 필수 여부 - requestparamRequired

🔍 기본 값 적용 - requestparamDefault

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

✏️ HTTP 요청 파라미터 - @ModelAttribute

🔍 @ModelAttribute 적용 - modelAttributeV1

🔍 @ModelAttribute 생략 - modelAttributeV2

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

🔍 RequestBodyStringController

🔍 Input, Output 스트림, Reader - requestBodyStringV2

🔍 HttpEntity - requestBodyStringV3

🔍 RequestBody - reqeustBodyStringV4

✏️ HTTP 요청 메시지 - JSON

🔍 RequestBodyJsonController

🔍 requestBodyJsonV2 - @RequestBody문자 변환

🔍 requestBodyJsonV3 - @RequestBody 객체 변환

🔍 requestBodyJsonV4 - HttpEntity

🔍 requestBodyJsonV45

🔗출처

Replies: 1 comment

Uh oh!

seyxxn Jun 28, 2024 Maintainer

6om1n
Jun 28, 2024
Maintainer

✏️ HTTP 요청 파라미터 - `@RequestParam`

🔍 `requestparamV2`

🔍 `requestparamV3`

🔍 `requestparamV4`

🔍 파라미터 필수 여부 - `requestparamRequired`

🔍 기본 값 적용 - `requestparamDefault`

🔍 파라미터를 Map 으로 조회하기 - `requestparamMap`

✏️ HTTP 요청 파라미터 - `@ModelAttribute`

🔍 `@ModelAttribute` 적용 - modelAttributeV1

🔍 `@ModelAttribute` 생략 - modelAttributeV2

🔍 `RequestBodyStringController`

🔍 requestBodyJsonV2 - `@RequestBody`문자 변환

🔍 requestBodyJsonV3 - `@RequestBody` 객체 변환

seyxxn
Jun 28, 2024
Maintainer