이 글은 스프링 [스프링 MVC 1편]을 듣고 정리한 내용입니다
📌 프로젝트 생성
- 프로젝트 세팅 정보
- *주의:
Jar선택- JSP 사용하지 않기 때문에
- Jar를 사용하면 항상 내장 서버 (톰캣 등)을 사용하고,
webapp경로도 사용하지 않는다. 내장 서버 사용에 최적화 되어 있는 기능이다. - 최근에는 주로 이 방식을 사용한다.
- War를 사용하면 내장 서버도 사용 가능 하지만, 주로 외부 서버에 배포하는 목적으로 사용한다.
📌 로깅 라이브러리 알아보기
- welcome 페이지 만들기 (코드는 생략)
스프링 부트의 기본 로깅 라이브러리
- SLF4J
- LogBack
- 로그 라이브러리는 Logback, Log4J, Log4J2 등등 수많은 라이브러리가 있는데 그것을 통합해서 인터페이스로 제공하는것이 SLF4J이다.
- 즉, SLF4J는 인터페이스이고 그 구현체로 Logback 같은 것들을 선택하면 된다.
LogTestController
@Slf4j
@RestController //ok라는 String을 바로 반환해서 편리하다 (테스트할때 간단하게 쓸 수 있음)
public class LogTestController {
// private final Logger log = LoggerFactory.getLogger(getClass());
@RequestMapping("/log-test")
public String logTest(){
String name = "Spring";
System.out.println("name = " + name);
log.trace("trace log={}", name);
log.debug("debug log={}", name);
log.info("info log={}", name);
log.warn("warn log={}", name);
log.error("error log={}", name);
return "ok";
}
}로그 테스트
- 로그가 출력되는 포멧 확인
- 시간, 로그 레벨, 프로세스 ID, 쓰레드 명, 클래스 명, 로그 메세지
- 로그 레벨 설정을 변경해서 출력 결과 확인하기
- LEVEL:
TRACE > DEBUG > INFO > WARN > ERROR - 개발 서버는
DEBUG출력 - 운영 서버는
INFO출력
- LEVEL:
@Slf4j어노테이션 사용
로그 레벨 설정하는 방법
application.properties 파일에 설정하기.
#전체 로그 레벨 설정(기본 info)
logging.level.root=info
#hello.springmvc 패키지와 그 하위 로그 레벨 설정
logging.level.hello.springmvc=debug올바른 로그 사용법
log.data("data={}", data}이런 형식으로 사용해야 한다.log.debug("data="+ data)-> 이런 형식은 문자 연산이 발생하기 때문에 쓰면 안된다.
로그 사용의 장점은?
- 쓰레드 정보, 클래스 이름 같은 부가 정보를 확인할 수 있고, 출력 모양을 조정 할 수 있다.
- 로그 레벨에 따라 개발 서버에서는 모든 로그를 출력하고, 운영서버에서는 출력하지 않는 등 로그를 상황에 맞게 사용할 수 있다.
- 성능도 좋고, 실무에서는 꼭 사용하도록 하자
📌 요청 매핑
MappingController
@RestController
public class MappingController {
private Logger log = LoggerFactory.getLogger(getClass());/**
* 기본 요청
* 둘다 허용 /hello-basic, /hello-basic/
* HTTP 메서드 모두 허용 GET, HEAD, POST, PUT, PATCH, DELETE
*/
@RequestMapping("/hello-basic")
public String helloBasic() {
log.info("helloBasic");
return "ok";
}
}@RestController란?
@Controller는 반환값이 String 이면 뷰 이름으로 인식되어서, 뷰를 찾고 뷰가 랜더링 된다.@RestController는 반환값으로 뷰를 찾는 것이 아니라, HTTP 메시지 바디에 바로 입력 한다.
RequestMapping 다중 설정 가능
//예시
@RequestMapping(value={"/hello-basic","/hello-go"}, method= RequestMethod.GET)
public String helloBasic(){
log.info("helloBasic");
return "ok";
}이런 경우엔 다른 URL 이지만, 같은 요청으로 매핑한다.
ex) URL 요청: /hello-basic , /hello-basic/
매핑: /hello-basic/
HTTP 메서드와 @RequestMapping
@RequestMapping에 mthod 속성으로 HTTP 메서드를 지정하지 않으면 HTTP 메서드와 무관하게 호출된다- GET, HEAD, POST, PUT, PATCH, DELETE 모두 허용
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";
}
//만약 여기에 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";
}
PatchVariable(경로 변수) 사용
* PathVariable 사용
* 변수명이 같으면 생략 가능
* @PathVariable("userId") String userId -> @PathVariable userId
*/
@GetMapping("/mapping/{userId}")
public String mappingPath(@PathVariable("userId") String data) {
log.info("mappingPath userId={}", data);
return "ok";
}
실행 : http://localhost:8080/mapping/userA
- 최근 HTTP API는 다음과 같이 리소스 경로에 식별자 넣는 스타일을 선호한다
ex)/mapping/userA,/users/1
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";
}실행 : http://localhost:8080/mapping/users/userA/orders/100
특정 파라미터 조건 매핑
// 특정 파라미터가 있거나 없는 조건을 추가하는 방법이다. 잘 사용하지느 않음.
/**
* 파라미터로 추가 매핑
* 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 요청 Content-Type, consume
/**
* 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 요청의 Content-Type 헤더를 기반으로 미디어 타입으로 매핑한다.
- 맞지 않으면 HTTP 415 상태코드(Unsupported Media Type)을 반환한다.
미디어 타입 조건 매핑 - HTTP 요청 Accept, produce
/*** 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";
}- HTTP 요청의 Accept 헤더를 기반으로 미디어 타입으로 매핑한다.
- 맞지 않으면 HTTP 406 상태코드(Not Acceptable)을 반환한다.
📌 요청 매핑 - API 예시
회원 관리 API
- 회원 목록 조회: GET
/users - 회원 등록: POST
/users - 회원 조회: GET
/users/{userId} - 회원 수정: PATCH
/users/{userId} - 회원 삭제: DELETE
/users/{userId}
MappingClassController
package hello.springmvc.basic.requestmapping;
@RestController
@RequestMapping("/mapping/users")
public class MappingClassController {
/**
* 회원 목록 조회: GET '/users'
* 회원 등록: POST '/users'
* 회원 조회: GET 'users/{userId}'
* 회원 수정: PATCH 'users/{userId}
* 회원 삭제: DELETE 'users/{userId}'*/
@GetMapping
public String user(){
return "get users";
}
@PostMapping
public String addUsers(){
return "post users";
}
@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;
}
}
📌 HTTP 요청 - 기본, 헤더 조회
-
매핑 방법을 배웠으니, 이제 HTTP 요청이 보내는 데이터들을 스프링 MVC로 어떻게 조회하는지 보자
-
먼저, HTTP 헤더 정보 조회하는 방법
RequestHeaderController
package hello.springmvc.basic.request;
@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("localse={}", locale);
log.info("headerMap={}", headerMap);
log.info("header host={}", host);
log.info("myCookie={}", cookie);
return "ok";
}
}
@Slf4j어노테이션을 붙였으니, 다음 코드를 자동으로 생성해서 로그를 선언해준다.
private static final org.slf4j.Logger log =
org.slf4j.LoggerFactory.getLogger(RequestHeaderController.class);- 개발자는 편하기
log라고 사용하면 된다.
📌 HTTP 요청 파라미터 - 쿼리 파라미터, HTML Form
요청 데이터 전달하는 3가지 방법
- GET - 쿼리 파라미터
- POST - HTML Form
- HTTP message body에 데이터를 직접 담아서 요청 (HTTP API)
스프링으로 요청 파라미터를 조회하는 방법
RequestParamController
@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.parseInt(request.getParameter("age"));
log.info("username={}, age={}", username, age);
response.getWriter().write("ok");
}
}여기서는 단순히 HttpServletRequest가 제공하는 방식으로 요청 파라미터를 조회함.
HTML Form 방식 - POST
<!DOCTYPE html>
<html lang="en">
<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
/**
* @RequestParam 사용
* 파라미터 이름으로 바인디
* @ResponseBody 추가
* View 조회를 무시하고, HTTP message body에 직접 해당 내용 입력
*/
@ResponseBody //이 어노테이션을 붙이면 뷰 조회를 진행하지 않고,return "ok"라는 문자를 바로 반환해준다. (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("username" String memberName
=> memberName = reqeust.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";
}requestParamV4
/**
* @RequestParam 사용
* String, int 등의 단순 타입이면 @RequestParam 도 생략 가능
*/@ResponseBody
@RequestMapping("/request-param-v4")
public String requestParamV4(String username, int age) {
log.info("username={}, age={}", username, age);
return "ok";
}*주의
@RequestParam애노테이션을 생략하면 스프링 MVC는 내부에서required=false를 적용한다
*참고
너무 생략해도 과한 것 같은 느낌이 있다. 명확하게@RequestParam정도는 쓰는게 괜찮을지도 ...?
파라미터 필수 여부 - requestParamRequired
/**
* @RequestParam.required
* /request-param -> username이 없으므로 예외
*
* 주의!
* /request-param?username= -> 빈문자로 통과
*
* 주의!
* /request-param
* 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";
}- 이때, int에 null을 입력하는건 불가능하다 -> 500예외 발생
기본값 적용 - requestParamDefault
/**
* @RequestParam
* - defaultValue 사용
*
* 참고: defaultValue는 빈 문자의 경우에도 적용
* /request-param?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";
}- 이 경우는 이미 기본값이 적용되었기 때문에
required는 의미가 없다. /requset-param?username=과 같이 빈문자의 경우에도 설정한 기본값이 적용된다.
파라미터를 Map으로 조회하기 - requestParamMap
- Map으로 조회할 수도 있다.
- 이전과 똑같이 Map 앞에
@ReqeustParam을 붙여주면 된다.
/**
* @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";
}- 파라미터의 값이 1개가 확실하지 않은 경우에는
Map대신MultiValueMap을 사용하자
📌 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들이 적용된다.
@ModelAttrivute 적용
modelAttributeV1
/*** @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";
}- 이와 같이 알아서
HelloaData객체가 생성되고, 요청 파라미터 값도 모두 들어가진다. - 스프링 MVC는
@ModelAttirubte가 있으면- HelloData 객체를 생성하고
- 요청 파라미터의 이르믕로 HelloData의 객체 프로퍼티를 찾아서 해당 프로퍼티의 setter를 호출해서 파라미터의 값을 바인딩한다.
ex) 파라미터 이름이 username이면 setUSername() 메서드를 호출하면서 값을 입력한다.
@ModelAttribute 생략
modelAttiributeV2
/**
* @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";
}*스프링 에서의 규칙
String, int, Interger과 같은 단순 타입 =>@RequestParam
나머지 =>@ModelAttribute(argument resolver로 지정해둔 타입 외)
📌 HTTP 요청 메시지 - 단순 텍스트
- HTTP message body에 데이터를 직접 담아서 요청하는 경우에는 (ex JSON형식) 앞의 두 경우와 다르게
@ReqeustParam,@ModelAttribute를 사용할 수 없다. InputStream을 사용해서 직접 읽을 수 있다.
RequestBodyStringController
RequestBodyStringV1
@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 응답 메시지의 바디에 직접 결과 출력
*/
@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
requestBodyStringV1
/**
* 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");
}HttpEntity를 상속받은 다음 객체들도 같은 기능을 제공한다.- RequestEntity
- HttpMethod, url 정보 추가, 요청에서 사용
- ResponseEntity
- HTTP 상태 코드 설정 가능, 응답에서 사용
return new ResponseEntity<String>("Hello world", responseHeaders, HttpStatus.CREATED)
@RequestBody
/**
* @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
📌 HTTP 요청 메시지 - JSON
- 이번엔 HTTP API에서 주로 사용하는 JSON 형식을 조회해 본다.
RequestBodyJsonController
/**
* {"username" : "hello", "age":20}
* content-type: application/json
*/
@Slf4j
@Controller
public class RequestBodyJsonController {
private ObjectMapper objectMapper = new ObjectMapper();
// 문자로 된 JSON 데이터를 Jackson 라이브러리인 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");
}
}@RequestBody 문자 변환
requestBodyJsonV2
/**
* @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처럼 한번에 객체로 변환할 수 없을까?
@RequestBody 객체 변환
requestBodyJsonV3
/**
* @RequestBody 생략 불가능(@ModelAttribute 가 적용되어 버림)
* HttpMessageConverter 사용 -> MappingJackson2HttpMessageConverter (contenttype: 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 객체 파라미터
- @ReqeustBody HelloData data
- @RequestBody에 직접 만든 객체를 지정할 수 있다.
@RequestBody 생략 불가능
스프링은 @ModelAttribute, @RequestParam 생략시 다음과 같은 규칙을 적용한다.
- String, int, Integer과 같은 단순타입 = @RequestParam
- 나머지 = @ModelAttribute (argument resolver로 지ㅓㅈㅇ해둔 타입 외)
따라서 위 예제의 경우, HelloData에 @RequestBody를 생략하면 @ModelAttribute가 적용되어버린다.
HelloData data -> @ModelAttribute HelloData data
따라서 생략하면 HTTP 메시지 바디가 아니라 요청 파라미터를 처리하게 되므로, 생략하면 안된다.
reqeustBodyJsonV4
- 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
/**
* @RequestBody 생략 불가능(@ModelAttribute 가 적용되어 버림)
* HttpMessageConverter 사용 -> MappingJackson2HttpMessageConverter (contenttype: 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를 사용하면 해당 객체를 HTTP 메시지 바디에 직접 넣어줄 수 있다. 이 경우에도 HttpEntity를 사용해도 된다.
-
@RequestBody요청- JSON 요청 -> HTTP 메시지 컨버터 -> 객체
-
@ResponseBody응답- 객체 -> HTTP 메시지 컨버터 -> JSON 응답
📌 HTTP 응답 - 정적 리소스, 뷰 템플릿
정적 리소스
- 정적 리소스 경로
src/main/resources/static - 만약 파일 위치가 다음과 같다면
`src/main/resources/static/basic/hello-form.html - 웹 브라우저에서 다음과 같이 실행하면 된다.
http://localhost:8080/basic/hello-form.html
뷰 템플릿
-
뷰 템플릿 경로
src/main/resources/templates -
뷰 탬플릿 생성 (타임리프 사용)
`src/main/resources/templates/response/hello.html`
~~~java
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<p th:text="${data}">empty</p>
</body>
</html>ResponseViewControlelr - 뷰 템플릿을 호출하는 컨트롤러
@Controller
public class ResponseViewController {
@RequestMapping("/response-view-v1")
public ModelAndView responseViewV1() {
ModelAndView mav = new ModelAndView("response/hello")
.addObject("data", "hello!");
return mav;}
@RequestMapping("/response-view-v2")
public String responseViewV2(Model model) {
model.addAttribute("data", "hello!!");
return "response/hello";
}
@RequestMapping("/response/hello")
public void responseViewV3(Model model) {
model.addAttribute("data", "hello!!");
}
}String을 반환하는 경우 - View or HTTP 메시지
@ResponseBody가 없으면response/hello로 뷰 리졸버가 실행되어서 뷰를 찾고 렌더링한다.@ResponseBody가 있으면 뷰 리졸버를 실행하지 않고 HTTP 바디에 직접response/hello라는 문자가 입력된다.
HTTP 메시지
@ResponseBody, @HttpEntity를 사용하면, 뷰 템플릿을 사용하는 것이 아니라, HTTP 메시지 바디에 직접 응답 데이터를 출력할 수 있다.
📌 HTTP 응답 - HTTP API, 메시지 바디에 직접 입력
- HTTP API 형식에서는 HTML이 아니라 데이터를 전달해야하므로, HTTP 메시지 바디에 JSON같은 형식으로 데이터를 실어 보낸다.
ResponseBodyController
package hello.springmvc.basic.response;
@Slf4j
@RestController
public class ResponseBodyController {
// 서블릿에서 처럼 HttpServletResponse 객체를 통해 HTTP 메시지 바디에 직접 응답 메시지(ok)를 실어 보낸다.
@GetMapping("/response-body-string-v1")
public void responseBodyV1(HttpServletResponse response) throws IOException {
response.getWriter().write("ok"); //메시지 바디에 직접 실어보냄
}
//ResponseEntity는 HttpEntity를 상속 받았는데, HttpEntity는 HTTP 메시지의 헤더, 바디 정보를 가지고 있다.
//또한 응답코드도 설정할 수 있다.
@GetMapping("/response-body-string-v2")
public ResponseEntity<String> responseBodyV2(){
return new ResponseEntity<>("ok", HttpStatus.OK);
}
//@ResponseBody를 사용하면 view를 사용하지 않고, HTTP 메시지 컨버터를 통해서 HTTP 메시지를 직접 입력할 수 있다. (ResponseEntity도 동일한 방식으로 동작한다.)
@ResponseBody
@GetMapping("/response-body-string-v3")
public String responseBodyV3(){
return "ok";
}
//ResponseEntity를 반환한다.
//HTTP 메시지 컨버터를 통해서 JSON 형식으로 변환되어서 반환된다.
@GetMapping("/response-body-json-v1")
public ResponseEntity<HelloData> responseBodyJsonV1(){
HelloData helloData = new HelloData();
helloData.setUsername("userA");
helloData.setAge(20);
return new ResponseEntity<>(helloData, HttpStatus.OK);
}
//ResponseEntity는 HTTP 응답 코드를 설정할 수 있는데, @ResponseBody를 사용하면 이런것을 설정하기 까다롭다
//@ResponseStatus(HttpStatus.OK)애노테이션을 사용해 응답코드를 설정할 수 있다.
@ResponseStatus(HttpStatus.OK)
@GetMapping("/response-body-json-v2")
public HelloData responseBodyJsonV2(){
HelloData helloData = new HelloData();
helloData.setUsername("userA");
helloData.setAge(20);
return helloData;
}
}
@RestController
@Controller대신에@RestController애노테이션을 사용하면, 해당 컨트롤러에 모두@ResponseBody가 적용된다.
(@RestController안에@ResponseBody가 있다.)- 따라서, 뷰 템플릿을 사용하는 것이 아니라 HTTP 메시지 바디에 직접 데이터를 입력한다.
- **이름 그대로 Rest API(HTTP API)를 만들 때 사용하는 컨트롤러이다.
📌 HTTP 메시지 컨버터
- 뷰 템플릿으로 HTML을 생성해서 응답하는게 아니라, HTTP API 처럼 JSON 데이터를 HTTP 메시지 바디에서 직접 읽거나 쓰는 경우, HTTP 메시지 컨버터를 사용하면 편리하다.
스프링 MVC는 다음의 경우에 HTTP 메시지 컨버터를 적용한다.
- HTTP 요청:
@RequestBody,HttpEntity(RequestEntity) - HTTP 응답:
@ResponseBody, `HttpEntity(ResponseEntity)
스프링 부트 기본 메시지 컨버터
0 = ByteArrayHttpMessageConverter
1 = StringHttpMessageConverter
2 = MappingJackson2HttpMessageConverter주요한 메시지 컨버터들
HTTP 요청 데이터 읽기
- HTTP 요청이 오고, 컨트롤러에서
@RequestBody,HtttpEntity파라미터를 사용한다. - 메시지 컨버터가 메시지를 읽을 수 있는지 확인하기 위해
canRead()를 호출한다. canRead()조건을 만족하면read()를 호출해서 객체를 생성하고 반환한다.
HTTP 응답 데이터 생성
- 컨트롤러에서
@ResponseBody,HttpEntity로 값이 반환된다. - 메시지 컨버터가 메시지를 쓸 수 있는지 확인하기 위해
canWrite()를 호출한다. canWrite()조건을 만족하면write()를 호출해서 HTTP 응답 메시지 바디에 데이터를 생성한다.
📌 요청 매핑 핸들러 어댑터 구조
메시지 컨버터는 어디쯤에?
@RequestMapping을 처리하는 핸들러 어댑터인RequestMappingHandlerAdapter(요청 매핑 핸들러 어댑터)에 있다.
ArgumentResolver
- 어노테이션 기반의 컨트롤러는 매우 다양한 파라미터를 사용할 수 있다.
ex) HttpServletRequest,Model,@RequestParam,@ModelAttribute등 - 그 이유는 ArgumentResolver 덕분이다.
- 어노테이션 기반 컨트롤러를 처리하는
RequestMappingHandlerAdapter는 바로 이ArguementResolver를 호출해서 컨트롤러가 필요하는 다양한 파라미터의 값(객체)를 생성한다. - 그리고 파라미터의 값이 모두 준비되면 컨트롤러를 호출하면서 값을 넘겨준다.
ArgumentResolver의 동작방식
HandlerMethodArgumentResolver (줄여서 ArgumentResolver 라고 부른다)
public interface HandlerMethodArgumentResolver {
boolean supportsParameter(MethodParameter parameter);
@Nullable
Object resolveArgument(MethodParameter parameter, @Nullable
ModelAndViewContainer mavContainer,
NativeWebRequest webRequest, @Nullable WebDataBinderFactory
binderFactory) throws Exception;
}ArgumentResolver의supportsParameter()를 호출해서 해당 파라미터를 지원하는지 체크하고, 지원하면resolveArgument()를 호출해서 실제 객체를 생성한다.- 이렇게 생성된 객체가 컨트롤러 호출시 넘어가게 된다.
ReturnValueHandler
HandleMethodReturnValueHandler를 줄여서ReturnValueHandler라고 부른다.- 이것은 응답값을 변환하고 처리한다.
HTTP 메시지 컨버터의 위치는 어디쯤?
- 요청의 경우
@RequestBody를 처리하는ArgumentResolver가 있고,HttpEntity를 처리하는Argument가 있다. 이ArgumentResolver`들이 HTTP 메시지 컨버터를 사용해서 필요한 객체를 생성한다.
- 응답의 경우
@ResponseBody와HttpEntity를 처리하는ReturnValueHandler가 있다. 그리고 여기에서 HTTP 메시지 컨버터를 호출해서 응답 결과를 만든다.
확장도 가능하다. (그러나 스프링이 거의다 제공!)
- 다음 인터페이스들을 확장하면 된다.
HandlerMethodArgumentResolverHandlerMethodReturnValueHandlerHttpMessageConverter
공부한 내용 잊어버리지 않게 기록하는 공간!