[Spring MVC] 기본 기능 - 요청 매핑

이 글은 인프런 김영한님의 Spring 강의를 바탕으로 개인적인 정리를 위해 작성한 글입니다.

---

@RestController
특정 클래스를 RESTful 웹 서비스의 컨트롤러로 지정한다.
이 어노테이션을 사용한 클래스는 HTTP 요청을 처리하는 핸들러 메소드를 포함하며, 각 메소드는 특정 HTTP 요청(예: GET, POST, DELETE 등)에 매핑된다.
@RestController는 @Controller 와 유사하지만, 차이점은 @RestController 로 지정된 컨트롤러의 메소드가 기본적으로 HTTP 응답 본문(Body)에 직접 데이터를 작성한다는 점이다.이는@ResponseBody 어노테이션을 모든 핸들러 메소드에 적용한 것과 같은 효과를 가진다.

@Controller 는 반환 값이 String 이면 뷰 이름으로 인식된다.
그래서 뷰를 찾고 뷰가 랜더링 된다. @RestController 는 반환 값으로 뷰를 찾는 것이 아니라, HTTP 메시지 바디에 바로 입력한다.

@ResponseBody
웹 어플리케이션에서 컨트롤러의 핸들러 메소드가 HTTP 응답 본문(Body)에 직접 내용을 작성할 수 있도록 지정한다.
이 어노테이션은 @Controller 어노테이션이 적용된 클래스 내의 메소드에 사용될 때 유용하며, @RestController 어노테이션과는 달리, @Controller 어노테이션과 함께 사용되어야 한다.
@RestController 어노테이션은 기본적으로 모든 메소드에 @ResponseBody 를 적용한 것과 같은 효과를 제공한다.

스프링 부트 3.0 부터는 /hello-basic 과 /hello-basic/ 는 서로 다른 URL 요청을 사용해야 한다.
따라서 다음과 같이 다르게 매핑해서 사용해야 한다.
매핑: /hello-basic -> URL요청: /hello-basic
매핑: /hello-basic/ -> URL요청: /hello-basic/

 

단순 @RequestMapping("/hello-basic")

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

@Slf4j
@RestController
public class MappingController {

    /**
     * 기본 요청
     * 둘다 허용 /hello-basic, /hello-basic/
     * HTTP 메서드 모두 허용 GET, HEAD, POST, PUT, PATCH, DELETE
     */
    @RequestMapping("/hello-basic")
    public String helloBasic(){
        log.info("helloBasic");
        return "ok";
    }
}

단순히 @RequestMapping("/경로") 를 사용하면 어떤 HTTP 메서드로 들어오든 상관 없이 해당 컨트롤러가 실행된다.

즉, @RequestMapping 에 method 속성으로 HTTP 메서드를 지정하지 않으면 HTTP 메서드와 무관하게 호출된다.

 

HTTP 메서드 매핑

메서드 지정

/*
* method 특정 HTTP 메서드 요청만 허용
* GET, HEAD, POST, PUT, PATCH, DELETE
*/
 @RequestMapping(value = "/mapping-get-v1", method = RequestMethod.GET)
 public String mappingGetV1() {
     log.info("mappingGetV1");
     return "ok";
 }

get 요청만 허락하도록 @RequestMapping에 메서드를 지정할 수 있다.

만약 여기에 POST 요청을 하면 스프링 MVC는 HTTP 405 상태코드(Method Not Allowed)를 반환한다.

 

HTTP 메서드 매핑 축약

/**
* 편리한 축약 애노테이션
* @GetMapping
* @PostMapping
* @PutMapping
* @DeleteMapping
* @PatchMapping
*/
@GetMapping(value = "/mapping-get-v2")
public String mappingGetV2() {
     log.info("mapping-get-v2");
	return "ok";
}

HTTP 메서드를 축약한 애노테이션을 사용하는 것이 더 직관적이다.

이 어노테이션 내부에서 @RequestMapping 과 method 를 지정해서 사용한다.

• @GetMapping
• @PostMapping
• @PutMapping
• @DeleteMapping
• @PatchMapping

지정된 메스드 이외의 메서드로 접근하면 오류를 내뿜는다.

 

PathVariable(경로 변수) 사용

/**
* PathVariable 사용
* 변수명이 같으면 생략 가능
* @PathVariable("userId") String userId -> @PathVariable String userId
*/
 @GetMapping("/mapping/{userId}")
 public String mappingPath(@PathVariable("userId") String data) {
     log.info("mappingPath userId={}", data);
     return "ok";
 }

/mapping/userA 이런 식으로 리소스 경로에 식별자를 넣는 스타일에서 사용하는 방식이다.

@RequestMapping 은 URL 경로를 템플릿화 할 수 있는데, @PathVariable 을 사용하면 매칭 되는 부분을 편리하게 조회할 수 있다.

 

@PathVariable 의 이름과 파라미터 이름이 같으면 아래와 같이 생략할 수 있다.

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

 

 

또한 PathVariable은 다중으로 사용이 가능하다.

/**
* PathVariable 사용 다중
*/
@GetMapping("/mapping/users/{userId}/orders/{orderId}")
public String mappingPath(@PathVariable String userId, @PathVariable Long orderId) {
    log.info("mappingPath userId={}, orderId={}", userId, orderId);
    return "ok";
}

 

 

특정 파라미터 조건 매핑

특정 파라미터가 있거나 없는 조건을 추가할 수 있다.

잘 사용하지는 않는다.

/mapping-param?mode=debug

/**
* 파라미터로 추가 매핑
* 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";
 }

 

특정 헤더 조건 매핑

파라미터 매핑과 비슷하지만, HTTP 헤더를 사용한다.

즉, 헤더에 정보가 포함되어 있어야 사용할 수 있다.

/**
* 특정 헤더로 추가 매핑
* 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";
}

 

미디어 타입 조건 매핑

Consumes과 Produces의 차이점
Consumes: 컨트롤러가 처리할 수 있는 요청의 미디어 타입을 지정한다. 요청이 이 타입을 만족해야 컨트롤러 메소드가 해당 요청을 처리한다.
Produces: 컨트롤러 메소드가 생성하여 반환할 수 있는 응답의 미디어 타입을 지정한다. 클라이언트는 이 타입의 데이터를 응답으로 받게 된다.

 

HTTP 요청 Content-Type, consume

HTTP 요청의 Content-Type 헤더를 기반으로 미디어 타입으로 매핑한다.

만약 맞지 않으면 HTTP 415 상태코드(Unsupported Media Type)을 반환한다.

 

consumes 속성은 컨트롤러 메소드가 처리할 수 있는 요청의 MIME 타입을 지정한다.  

consumes = "text/plain"
consumes = {"text/plain", "application/*"}
consumes = MediaType.TEXT_PLAIN_VALUE

이 속성을 사용하면 특정 타입의 데이터를 (서버의 입장에서)소비하는 요청만을 해당 컨트롤러 메소드에서 처리하도록 제한할 수 있다.

예를 들어, consumes = "application/json"이라고 지정하면, 해당 컨트롤러 메소드는 Content-Type 헤더가 application/json인 요청만을 처리한다.

/**
* 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 요청 Accept, produce

HTTP 요청의 Accept 헤더를 기반으로 미디어 타입으로 매핑한다.

만약 맞지 않으면 HTTP 406 상태코드(Not Acceptable)을 반환한다.

 

produces 속성은 컨트롤러 메소드에서 반환하는 응답의 MIME 타입을 지정한다.

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

이 속성을 통해 클라이언트가 Accept 헤더를 통해 요청한 타입과 일치하는 응답 타입만을 반환하도록 제한할 수 있다.

예를 들어, produces = "text/html"이라고 지정하면, 해당 컨트롤러 메소드는 클라이언트에게 text/html 형식의 데이터를 반환한다.

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

 

API 예시

회원 관리를 HTTP API로 만든다 생각하고 매핑을 어떻게 하는지 알아보자.

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

 

@RequestMapping("/mapping/users")

클래스 레벨에 매핑 정보를 두면 메서드 레벨에서 해당 정보를 조합해서 사용한다.

package hello.springmvc.basic.requestmapping;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/users")
public class MappingClassController {
    /**
    * GET /mapping/users
    */
    @GetMapping
    public String users() {
        return "get users";
    }
    
    /**
     * POST /mapping/users
     */
    @PostMapping
    public String addUser() {
        return "post user";
    }
    
    /**
     * GET /mapping/users/{userId}
     */
    @GetMapping("/{userId}")
    public String findUser(@PathVariable String userId) {
        return "get userId=" + userId;
    }
    
    /**
     * PATCH /mapping/users/{userId}
     */
    @PatchMapping("/{userId}")
    public String updateUser(@PathVariable String userId) {
        return "update userId=" + userId;
    }
    
    /**
     * DELETE /mapping/users/{userId}
     */
    @DeleteMapping("/{userId}")
    public String deleteUser(@PathVariable String userId) {
        return "delete userId=" + userId;
    }
}