톰캣 406 not acceptable request 메시지 확인 방법

이 글은 스프링 [스프링 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 출력
• @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"; }

실행 : //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"; }

실행 : //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
• 웹 브라우저에서 다음과 같이 실행하면 된다.
  //localhost:8080/basic/hello-form.html

뷰 템플릿

• 뷰 템플릿 경로
  src/main/resources/templates

• 뷰 탬플릿 생성 (타임리프 사용)

`src/main/resources/templates/response/hello.html` ~~~java <!DOCTYPE html> <html xmlns:th="//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 메시지 컨버터를 호출해서 응답 결과를 만든다.

확장도 가능하다. (그러나 스프링이 거의다 제공!)

• 다음 인터페이스들을 확장하면 된다.
  • HandlerMethodArgumentResolver
  • HandlerMethodReturnValueHandler
  • HttpMessageConverter