[Spring Web MVC] 요청 정보 다루기

 

 

 

	@GetMapping("/mapping/{userId}")
    public String mappingPath(@PathVariable("userId") String id){
        log.info("logging... {}", id);
        return "chk";
    }

 

 

URL 경로에 변수를 넣어 템플릿 형식으로 설정할 수 있고, @PathVariable 애너테이션으로 그 값을 꺼내 메서드에서 사용할 수 있다. (경로 변수)

 

 

 

	@GetMapping("/mapping/users/{userId}/order/{orderID}")
    public String mappingPath(@PathVariable("userId") String id, @PathVariable("orderID") String order){
        log.info("logging... {} {}", id, order);
        return "chk";
    }

 

 

다중 매핑도 지원한다.

 

 

@GetMapping(value ="/mapping/", params = "mode=debug")
    public String mappingTest(){
        log.info("logging..");
        return "chk";
    }

 

해당 URL 요청이 들어왔을 때 특정 파라미터가 있어야 요청이 수락되도록 할 수 있다. 

(사실 경로 변수 방식을 더 많이 사용한다.)

 

params 대신 headers를 사용하면 특정 헤더가 있어야지만 요청이 수락된다.

 

params 대신 consumes를 사용하면 해당 요청의 content-type이 consumes로 등록한 값과 일치할 때 요청이 수락된다.

사실 headers를 사용해서 값을 조금 조작해도 되는데, consumes로 등록 시 내부적으로 좀 더 처리하는 작업이 있다.

 

params 대신 produces를 사용하면 해당 요청의 accept 값이 produces로 등록한 값과 일치할 때 요청이 수락된다.

 

 

 

---

 

 

 

회원 관리 API를 설계해보자.

 

회원 목록 조회: GET /users

회원 등록: POST /users

회원 조회: GET /users/{userId}

회원 수정: PATCH /users/{userId}

회원 삭제: DELETE /users/{userId}

 

 

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


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


}

 

 

URL 매핑만 처리한다고 하면 이렇게 작성하면 된다.

 

 

 

@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 = true) 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 헤더 관련 정보를 조회하는 방법을 살펴보자.

 

 

Request와 Response는 이미 많이 봤고..

 

HttpMethod : 요청 메서드를 조회한다.

 

Locale : Locale 정보를 조회한다. (지역)

 

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

여기서 MultiValueMap은 Map 자료구조와 유사한데, 하나의 키에 여러 가지 값을 받을 수 있는 자료구조이다.

같은 헤더에 같은 값이 들어가는 경우 사용한다. (키로 조회 시 리스트가 반환된다.)

 

@RequestHeader("host") : 특정 HTTP 헤더를 조회한다.

 

@CookieValue(...) : 특정 쿠키를 조회한다.

 

이 외에도 다양한 파라미터를 받을 수 있으니, 스프링 공식 문서를 참고하자.

 

 

 

---

 

 

 

@Controller
@Slf4j
public class RequestParamController {
    @RequestMapping("/request-param-v1")
    public void requestParam1(HttpServletRequest request, HttpServletResponse response)throws IOException {
        String username = request.getParameter("username");
        int age = Integer.parseInt(request.getParameter("age"));

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

        PrintWriter writer = response.getWriter();

        writer.write("check");
    }
}

 

 

클라이언트에서 서버로 데이터를 전송할 때는 쿼리 파라미터 / HTML Form / HTTP 메세지 바디 방식을 사용했었는데, 이 중에서 쿼리 파라미터와 HTML Form을 통해 전송하는 경우는 getParameter 메서드를 통해 서버에서 요청 데이터를 가져올 수 있었다.

 

 

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

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


    }

 

 

@RequestParam 애너테이션을 통해 getParameter() 메서드를 사용하지 않고도 데이터를 읽을 수 있다.

여기서 @ResponseBody 애너테이션은 반환값을 HTTP 응답 본문(body)으로 보낼 때 사용한다. 

 

 

 

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

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


    }

 

 

지금처럼 파라미터 이름과 변수명이 같으면 파라미터 이름을 생략해서 사용할 수 있다.

 

 

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

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

 

 

파라미터의 이름과 변수명이 같으면 @RequestParam 애너테이션도 생략할 수 있다.

이 때 타입은 String int 등 단순 타입이어야 한다.

 

그런데 너무 생략해도 코드를 이해하기 쉽지 않을 수 있으니 적당히 사용하자.

 

 

 

    @ResponseBody
    @RequestMapping("/request-param-required")
    public String requestParamRequired(
            @RequestParam(required = true) String username,
            @RequestParam(required = false) Integer age){

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

 

 

@RequestParam 애너테이션에 required 옵션을 추가해서 요청 메세지에 해당 요소가 들어올 경우만 요청을 수락하도록 할 수 있다. (기본값 true)

 

여기서 int 대신 Integer를 사용했는데, false로 설정 시 null 이 들어가야 하지만 Primitive 타입에는 null을 넣을 수 없어 null을 사용할 수 있는 래퍼 클래스로 설정해야 한다. 

 

 

    @ResponseBody
    @RequestMapping("/request-param-required")
    public String requestParamRequired(
            @RequestParam(required = true) String username,
            @RequestParam(required = false, defaultValue = "231") int age){

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

 

 

defaultValue를 지정해 값이 들어오지 않을 경우 기본값을 설정할 수 있다.

이렇게 하면 int를 그대로 사용할 수 있다.

 

 

    @ResponseBody
    @RequestMapping("/request-param-map")
    public String requestParamMap(@RequestParam Map<String, Object> paramMap){

        log.info("{} {}", paramMap.get("username"), paramMap.get("age"));
        return "dafd";
    }

 

 

파라미터로 Map 또는 MultiValueMap을 주면 모든 파라미터를 조회할 수 있다.

 

 

 

---

 

 

 

요청 파라미터를 받아서 응답에 필요한 객체를 만들고 그 객체에 값을 넣어줘야 한다.

 

    @ResponseBody
    @RequestMapping("/model-attribute-v1")
    public String modelAttribute(
            @RequestParam String username,
            @RequestParam int age){

        HelloData helloData = new HelloData();
        helloData.setAge(32);
        helloData.setUsername("asdf");

        

        return "32";
    }

 

이런 식으로.. 요청 파라미터에서의 데이터를 저장할 객체를 만들어야 했다.

 

 

    @ResponseBody
    @RequestMapping("/model-attribute-v1")
    public String modelAttribute(@ModelAttribute HelloData helloData){
        
        return "32";
    }

 

@ModelAttribute 애너테이션을 사용하면 모델 객체를 알아서 생성하고 요청 파라미터의 값도 알아서 채워준다.

 

1. 객체 생성

2. 요청 파라미터의 이름으로 해당 객체의 프로퍼티(setter, getter)를 찾아 값을 바인딩한다. 

 

요청 시 타입이 어긋나면 BindException을 뱉는다.

 

 

    @ResponseBody
    @RequestMapping("/model-attribute-v1")
    public String modelAttribute(HelloData helloData){

        return "32";
    }

 

사실 @ModelAttribute 애너테이션은 생략할 수 있다.

그런데 @RequestParam도 생략할 수 있지 않았나? 좀 헷갈릴 것 같은데...

 

생략 시 규칙이 적용된다.

String int 등 단순 타입은 @RequestParam을 사용하고, 나머지 타입은 @ModelAttribute를 사용한다. 

나머지 타입 중 argument resolver로 지정해 둔 타입은 @ModelAttribute 가 적용되지 않는데..

 

@RequestParam 은 요청 파라미터를 받는 작업을 수행하고, 바인딩은 스스로 해야 한다.

@ModelAttribute 는 요청 파라미터를 받아서 객체 생성부터 바인딩, 모델에 담기까지의 작업을 모두 처리한다.

 

이 정도로 이해하자.

 

 

 

 

---

 

 

 

메세지 바디를 통해 직접 데이터가 넘어오는 경우는 @RequestParam 과 @ModelAttribute 애너테이션을 사용할 수 없다.

 

 

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

 

 

가장 단순한 방법으로 InputStream 으로 메세지 바디의 데이터를 직접 읽어올 수 있다.

 

 

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

 

파라미터 값으로 InputStream을 바로 받아올 수 있다. (Writer도 마찬가지)

String 은 바이트 코드이기 때문에 Charset을 지정해 줘야 한다. (미지정 시 OS에서 기본값으로 설정된 Charset으로 설정됨)

 

 

    @PostMapping("/request-body-string-v3")
    public HttpEntity<String> requestBodyStringV3(HttpEntity<String> httpEntity) throws IOException {

        String body = httpEntity.getBody();
        log.info("messagebody {}", body);
        return new HttpEntity<>("check");
    }

 

더 간소화 할 수 있다.

HttpEntity는 HTTP 헤더, 바디 등 여러 정보를 편하게 조회할 수 있도록 해 준다.

메세지 바디 정보를 바로 조회할 수 있고, 이전처럼 요청 파라미터를 조회하는 기능과는 전혀 연관관계가 없다.

 

리턴 타입으로 HttpEntity<String>을 사용해 응답에도 HttpEntity를 사용할 수 있다.

메세지 바디 정보를 직접 반환하고, 뷰를 조회하지 않는다. 

 

HttpEntity를 상속받은 RequestEntity, ResponseEntity를 사용해 요청과 응답에서 사용할 수도 있다.

 

 

    @ResponseBody
    @PostMapping("/request-body-string-v4")
    public String requestBodyStringV4(@RequestBody String messageBody) throws IOException {

        log.info("messagebody {}", messageBody);
        return "ok123";
    }

 

 

여기서 더 간단하게 바꿀 수 있다.

 

파라미터로 @RequestBody 애너테이션을 사용해 메세지 바디의 내용을 바로 가져올 수 있고, 메서드에 @ResponseBody 애너테이션을 붙여 뷰를 찾지 않고 응답 결과를 메세지 바디에 담아 그대로 반환하도록 할 수 있다.

 

이 방법을 가장 많이 사용한다.

 

 

그런데 메세지 바디에 텍스트만 적어서 보내지는 않는다.

주로 사용하는 데이터 형식인 JSON 형식을 다뤄보자.

 

 

기본적으로 ObjectMapper를 사용한다.

request 와 response를 통해 읽는 경우 / @RequestBody 애너테이션으로 읽고 HelloData 객체로 변환해서 읽는 경우는 앞의 예시와 동일하니 넘어가자.

 

 

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

 

@RequestBody에 객체를 파라미터로 넘긴다.

HTTP 메세지 컨버터는 HTTP 메세지 바디의 내용을 원하는 문자나 객체로 변환해준다.

 

즉, 원하는 타입이 JSON 타입이면 (content-type 이 application/JSON 이면)

HelloData helloData = objectMapper.readValue(messageBody, HelloData.class);

위의 코드를 HTTP 메세지 컨버터가 실행해준다.

 

여기서는 @RequestBody 애너테이션을 생략할 수 없다.

앞에서 살펴본 바와 같이 객체 타입은 @ModelAttribute가 요청 파라미터를 처리하기 때문에 생략 시 HTTP 메세지 바디가 아니라 요청 파라미터를 처리하게 된다.

 

 

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

 

 

물론 앞에서와 같이 HttpEntity를 사용해도 된다.

 

JSON 타입으로 요청이 들어오면 HTTP 메세지 컨버터가 해당 타입을 객체로 변환하고,

응답할 때는 객체를 다시 JSON타입으로 변경 후 응답한다.