[Spring] 스프링 MVC 1편 - 백엔드 웹 개발 핵심 기술 섹션6 스프링 MVC - 기본 기능

본 내용은 인프런 김영한T 스프링 MVC 1편 - 백엔드 웹 개발 핵심 기술 강의를 정리한 내용입니다:)

[Spring] 스프링 MVC 1편 - 백엔드 웹 개발 핵심 기술 섹션6 스프링 MVC - 기본 기능

◼️ 로깅 간단히 알아보기

SLF4J는 인터페이스이고, 그 구현체로 Logback 같은 로그 라이브러리를 선택한다.

실무에서는 스프링 부트가 기본으로 제공하는 Logback을 대부분 사용한다.

 

사용예시

import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
...

//@Slf4j
@RestController
public class LogTestController {
     private final Logger log = LoggerFactory.getLogger(getClass());
     @RequestMapping("/log-test")
     public String logTest() {
     String name = "Spring";

     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);
     //로그를 사용하지 않아도 a+b 계산 로직이 먼저 실행됨, 이런 방식으로 사용하면 X
     log.debug("String concat log=" + name);
     return "ok";
 }
}

application properties

logging.level.hello.springmvc=error # hello.springmvc 패키지와 그 하위 로그 레벨 설정

🟢 로그 사용시 장점

• 쓰레드 정보, 클래스 이름 같은 부가 정보를 함께 볼 수 있고, 출력 모양을 조정할 수 있다.
• 로그 레벨에 따라 개발 서버에서는 모든 로그를 출력하고, 운영서버에서는 출력하지 않는 등 로그를 상황에 맞게
  조절할 수 있다.
• 시스템 아웃 콘솔에만 출력하는 것이 아니라, 파일이나 네트워크 등, 로그를 별도의 위치에 남길 수 있다. 특히 파
  일로 남길 때는 일별, 특정 용량에 따라 로그를 분할하는 것도 가능하다.
• 성능도 일반 System.out보다 좋다. (내부 버퍼링, 멀티 쓰레드 등등) 그래서 실무에서는 꼭 로그를 사용해야 한
  다.

◼️ 요청 매핑

@ Controller: 뷰를 찾고 뷰가 랜더링 된다.

@RestController: 반환 값으로 뷰를 찾는 것이 아니라, HTTP 메시지 바디에 바로 입력한다.

 

🟢 스프링 3.0 이전, 이후 / 차이

스프링 부트 3.0 이전에는 다음 두가지 요청은 다른 URL이지만, 스프링은 다음 URL 요청들을 같은 요청으로 매핑한다.

매핑: /hello-basic → URL 요청: /hello-basic , /hello-basic/

기존에는 마지막에 있는 / (slash)를 제거했지만, 스프링 부트 3.0 부터는 마지막의 / (slash)를 유지한다.
따라서 /hello-basic , /hello-basic/ 는 서로 다른 URL 요청을 사용해야 한다. 따라서 다음과 같이 다르게 매핑해서 사용해야 한다.

매핑: /hello-basic → URL 요청: /hello-basic
매핑: /hello-basic/ → URL 요청: /hello-basic

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

🟢 HTTP 메서드 축약

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

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

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

🟢 특정 파라미터 조건 매핑

/**
 * 파라미터로 추가 매핑
 * params="mode",
 * params="!mode"
 * params="mode=debug"
 * params="mode!=debug" (! = )
 * params = {"mode=debug","data=good"}
 * url: http://localhost:8080/mapping-param?mode=debug
 */
@GetMapping(value = "/mapping-param", params = "mode=debug")
public String mappingParam() {
     log.info("mappingParam");
     return "ok";
}

🟢 특정 헤더 조건 매핑

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

🟢 미디어 타입 조건 매핑 - HTTP 요청 Content-Type, consume

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

/**
 * 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 헤더를 기반으로 미디어 타입으로 매핑한다.

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

Content-Type은 전송된 데이터의 형식을 명시하는 반면, Accept 헤더는 클라이언트가 받아들일 수 있는 데이터 형식을 서버에게 요청한다. 예를 들어, 클라이언트가 Accept: text/html 을 요청했다면, 서버는 HTML 형식의 문서를 반환해야 한다.

◼️ 요청 매핑 - API 예시

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

@RestController
@RequestMapping("/mapping/users")
public class MappingClassController {
     /**
     * GET /mapping/users
     */
     @GetMapping
     public String users() {
         return "get users";
     }
    /**
     * DELETE /mapping/users/{userId}
     */
     @DeleteMapping("/{userId}")
     public String deleteUser(@PathVariable String userId) {
         return "delete userId=" + userId;
     }
     ...
 }

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

HTTP 헤더 정보를 조회하는 방법을 알아보자.

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

🪄참고
@Controller 의 사용 가능한 파라미터 목록은 다음 공식 메뉴얼에서 확인할 수 있다.
https://docs.spring.io/spring-framework/docs/current/reference/html/web.html#mvc-annarguments
@Controller 의 사용 가능한 응답 값 목록은 다음 공식 메뉴얼에서 확인할 수 있다.
https://docs.spring.io/spring-framework/docs/current/reference/html/web.html#mvc-annreturn-types

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

🟢 서버로 데이터를 요청하는 방법

1. GET: 쿼리 파라미터(/url**?username=hello&age=20**)
2. POST: HTML FORM
3. message body 직접 요청

위의 방법 1,2는 아래처럼 둘다 형식이 같으므로 구분없이 조회할 수 있다.

POST /request-param ...
content-type: application/x-www-form-urlencoded
username=hello&age=20

또한 방법1,2는 아래처럼 요청 파라미터를 조회한다.

@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"); // HttpServletRequest가 제공하는 방식
     int age = Integer.parseInt(request.getParameter("age"));
     log.info("username={}, age={}", username, age);
     response.getWriter().write("ok");
 }
}

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

@RequestParam : 파라미터 이름으로 바인딩
@ResponseBody : View 조회를 무시하고, HTTP message body에 직접 해당 내용 입력

@ResponseBody
@RequestMapping("/request-param-v2")
public String requestParamV2(
 @RequestParam("username") String memberName,
 @RequestParam("age") int memberAge) {
     log.info("username={}, age={}", memberName, memberAge);
     return "ok";
}

아래처럼, HTTP 파라미터 이름이 변수 이름과 같으면 @RequestParam(name="xx") 생략 가능하다.

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

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

/**
 * @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("username") String username
@PathVariable("userId") String userId

 

아래처럼 파라미터 필수 여부를 지정한다.

/**
 * @RequestParam.required
 * /request-param-required -> username이 없으므로 400 예외
 *
 * 주의!
 * /request-param-required?username= -> 빈문자로 통과
 *
 * 주의!
 * /request-param-required
 * 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";
}

위에서 주의할 점은, age 파라미터가 전혀 제공되지 않았을 때 Spring이 이 변수에 null을 할당하려고 하는데,이때 int age에서는 오류가 난다는 것이다. 따라서 객체형 Integer로 변경해야 한다.

 

또한 아래처럼 defaultValue를 통해 기본 값을 적용 가능하다.

/**
 * @RequestParam
 * - defaultValue 사용
 *
 * 참고: defaultValue는 빈 문자의 경우에도 적용
 * /request-param-default?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";
}

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

@ModelAttribute는 자동으로 요청파라미터 바인딩 객체에 값을 넣어준다.

롬복 @Data: @Getter , @Setter , @ToString , @EqualsAndHashCode , @RequiredArgsConstructor 자동 적용

import lombok.Data;
@Data
public class HelloData {
     private String username;
     private int age;
}

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

스프링MVC는 @ModelAttribute 가 있으면 다음을 실행한다. @ModelAttribute 은 생략 가능하다.

• HelloData 객체를 생성한다.
• 요청 파라미터의 이름으로 HelloData 객체의 프로퍼티를 찾는다. 그리고 해당 프로퍼티의 setter를 호출해서
  파라미터의 값을 입력(바인딩) 한다.
• 예) 파라미터 이름이 username 이면 setUsername() 메서드를 찾아서 호출하면서 값을 입력한다.

🟢 스프링 생략 규칙

• String , int , Integer 같은 단순 타입 = @RequestParam
• 나머지 = @ModelAttribute (argument resolver 로 지정해둔 타입 외)

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

HTTP 메시지 바디를 통해 데이터가 직접 넘어오는 경우는 @RequestParam,@ModelAttribute 를 사용할 수 없다.

먼저 가장 단순한 텍스트 메시지를 HTTP 메시지 바디에 담아서 전송하고 읽어보려면, InputStream을 사용한다.

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

스프링 MVC는 다음 파라미터를 지원하며,이를 사용해 아래와 같이 위 코드를 간략화 할 수 있다.

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

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

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

 

스프링 MVC는 다음 파라미터를 지원하며,이를 사용해 아래와 같이 위 코드를 간략화 할 수 있다.

☀️ HttpEntity: HTTP header, body 정보를 편리하게 조회

• 메시지 바디 정보를 직접 조회
• 요청 파라미터를 조회하는 기능과 관계 없음 @RequestParam X, @ModelAttribute X
• HttpEntity는 응답에도 사용 가능 - 메시지 바디 정보 직접 반환 헤더 정보 포함 가능
• view 조회X

☀️ HttpEntity 를 상속받은 다음 객체들도 같은 기능을 제공한다.

• RequestEntity : HttpMethod, url 정보가 추가, 요청에서 사용
• ResponseEntity  : HTTP 상태 코드 설정 가능, 응답에서 사용
  • return new ResponseEntity("Hello World", responseHeaders, HttpStatus.CREATED)

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

☀️ @RequestBody

@RequestBody 를 사용하면 HTTP 메시지 바디 정보를 편리하게 조회할 수 있다.

☀️ @ResponseBody 

응답 결과를 HTTP 메시지 바디에 직접 담아서 전달할 수 있다.이 경우에도 view를 사용하지 않는다.

참고로 헤더 정보가 필요하다면 HttpEntity 를 사용하거나 @RequestHeader 를 사용하면 된다.

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

* @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 @ResponseBody

◼️ HTTP 요청 메시지 - JSON

JSON은, HttpServletRequest를 사용해서 직접 HTTP 메시지 바디에서 데이터를 읽어와서, 문자로 변환한다.

그리고 문자로 된 JSON 데이터를 Jackson 라이브러리인 objectMapper 를 사용해서 자바 객체로 변환한다

/**
 * {"username":"hello", "age":20}
 * content-type: application/json
 */
@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 data = objectMapper.readValue(messageBody, HelloData.class);
     log.info("username={}, age={}", data.getUsername(), data.getAge());
     
     response.getWriter().write("ok");
     }
}

이전에 학습했던 @RequestBody 를 사용해서 HTTP 메시지에서 데이터를 꺼내고 messageBody에 저장해보자.

그리고 문자로 된 JSON 데이터인 messageBody 를 objectMapper 를 통해서 자바 객체로 변환한다.

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

위 코드에서 더 간략화해서, 한번에 객체로 변환하려면 @RequestBody 에 직접 만든 객체를 지정하면 된다.
아래와 같이 객체 파라미터(ex_HelloData)를 사용한다.

/**
 * @RequestBody 생략 불가능(@ModelAttribute 가 적용되어 버림)
 * HttpMessageConverter 사용 -> MappingJackson2HttpMessageConverter (content-type: 
application/json)
 *
 */
@ResponseBody
@PostMapping("/request-body-json-v3")
public String requestBodyJsonV3(@RequestBody HelloData data) {
     log.info("username={}, age={}", data.getUsername(), data.getAge());
     return "ok";
}

아래처럼 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";
}

🟢 @RequestBody는 생략 불가능

스프링은 애노테이션을 생략시 다음과 같은 규칙을 적용한다.

• String , int , Integer 같은 단순 타입 = @RequestParam
• 나머지 = @ModelAttribute (argument resolver 로 지정해둔 타입 외)

따라서 이 경우 HelloData에 @RequestBody 를 생략하면 @ModelAttribute 가 적용되어버려 Null이담긴다. 즉,생략하면 HTTP 메시지 바디가 아니라 요청 파라미터를 처리하게 된다.

 

또한 아래 함수 반환값처럼, 응답에도 객체를 HTTP 바디에 직접 넣어 json을 반환할 수 있다.

/**
 * @RequestBody 생략 불가능(@ModelAttribute 가 적용되어 버림)
 * HttpMessageConverter 사용 -> MappingJackson2HttpMessageConverter (content-type: 
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;
}

 

@RequestBody,ResponseBody 변환을 정리하면 다음과같다.

• @RequestBody 요청: JSON 요청 → HTTP 메시지 컨버터 → 객체
• @ResponseBody 응답: 객체 → HTTP 메시지 컨버터 → JSON 응답

◼️ HTTP 응답 - 정적 리소스, 뷰 템플릿

🟢 스프링(서버)에서 응답 데이터를 만드는 방법

1. 정적 리소스 예) 웹 브라우저에 정적인 HTML, css, js를 제공할 때는, 정적 리소스를 사용한다.
2. 뷰 템플릿 사용 예) 웹 브라우저에 동적인 HTML을 제공할 때는 뷰 템플릿을 사용한다.
3. HTTP 메시지 사용. HTTP API사용시엔 HTTP 메시지 바디에 JSON 같은 형식으로 데이터를 실어 보낸다.

◼️정적 리소스

정적 리소스는 해당 파일을 변경없이 서비스하는 것이다.

클래스패스 시작경로는 src/main/resources이며, 스프링은 아래 디렉토리 리소스들을 정적 리소스로 제공한다.

/static, /public , /resources , /META-INF/resources

일반적으로 정적리소스 경로는src/main/resources/static이다.

예를들어, 아래 경로는 http://localhost:8080/basic/hello-form.html로 접속시 실행된다.

src/main/resources/static/basic/hello-form.html

◼️뷰 템플릿

뷰 템플릿을 거쳐서 HTML이 생성되고, 뷰가 응답을 만들어서 전달한다.

스프링 부트는 기본 뷰 템플릿 경로 src/main/resources/templates 를 제공한다.

 

먼저, 뷰 템플릿을 생성해보자. src/main/resources/templates/response/hello.html

그리고 뷰 템플릿을 호출하는 컨트롤러를 만들어보자.

@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  X: response/hello 로 뷰 리졸버가 실행되어서 뷰를 찾고, 렌더링 한다.
• @ResponseBody O: 뷰 리졸버를 실행X,HTTP 메시지 바디에 직접 response/hello 라는 문자가 입력된다.

Void를 반환하는 경우 (권장X.명시성 떨어짐)

@Controller 를 사용하고, HTTP 메시지 바디를 처리하는 파라미터( HttpServletResponse , OutputStream(Writer)...etc)가 없으면 요청 URL을 참고해서 논리 뷰 이름으로 사용

• 요청 URL: /response/hello
• 실행: templates/response/hello.html

◼️Thymeleaf 스프링 부트 설정

스프링부트는 타임리프 라이브러리 추가시, ThymeleafViewResolver와 필요빈들을 등록한다.아래 설정은 기본값이다.

application.properties

spring.thymeleaf.prefix=classpath:/templates/
spring.thymeleaf.suffix=.html

◼️ HTTP 응답 - HTTP API, 메시지 바디에 직접 입력

ResponseBody 정리

@Slf4j
@Controller
//@RestController
public class ResponseBodyController {
 @GetMapping("/response-body-string-v1")
 public void responseBodyV1(HttpServletResponse response) throws IOException
{
     response.getWriter().write("ok"); // HTTP 바디에 직접 ok 응답 메시지 전달
 }
 /**
 * HttpEntity, ResponseEntity(Http Status 추가)
 * @return
 */
 @GetMapping("/response-body-string-v2")
 public ResponseEntity<String> responseBodyV2() {
     return new ResponseEntity<>("ok", HttpStatus.OK); //ResponseEntity는 HTTP 응답코드 설정
 }
 @ResponseBody // view 사용X, HTTP 메시지 컨버터 사용
 @GetMapping("/response-body-string-v3")
 public String responseBodyV3() {
     return "ok"; 
 }
 @GetMapping("/response-body-json-v1")
 public ResponseEntity<HelloData> responseBodyJsonV1() {
     HelloData helloData = new HelloData();
     helloData.setUsername("userA");
     helloData.setAge(20);
     //ResponseEntity반환. HTTP 메시지 컨버터를 통해서 JSON 형식으로 변환되어 반환
     return new ResponseEntity<>(helloData, HttpStatus.OK);
 }
 @ResponseStatus(HttpStatus.OK) // ResponseEntity HTTP 응답 코드 설정 가능
 @ResponseBody
 @GetMapping("/response-body-json-v2")
 public HelloData responseBodyJsonV2() {
     HelloData helloData = new HelloData();
     helloData.setUsername("userA");
     helloData.setAge(20);
     return helloData;
 }
}

🟢 RestController

• 해당 컨트롤러에 모두 @responseBody가 적용되는 효과
• 뷰 템플릿 사용 X, HTTP 메시지 바디에 직접 데이터를 입력

◼️ HTTP 메시지 컨버터

• ResponseBody를 사용하면 viewResolver 대신에 HttpMessageConverter 가 동작한다.
  • 기본 문자처리: StringHttpMessageConverter
  • 객체처리: MappingJackson2HttpMessageConverter
  • 이외에도 byte 처리 등등 기타 여러 HttpMessageConverter가 기본으로 등록되어 있음

🟢 스프링 MVC가 HTTP 메시지 컨버터를 적용하는 경우

• HTTP 요청: @RequestBody , HttpEntity(RequestEntity)
• HTTP 응답: @ResponseBody , HttpEntity(ResponseEntity)

🟢 스프링 부트 기본 메시지 컨버터

1. ByteArrayHttpMessageConverter
2. StringHttpMessageConverter 
3. MappingJackson2HttpMessageConverter

스프링 부트는 대상 클래스 타입과 미디어 타입 둘을 체크해서 사용여부를 결정한다.

만약 만족하지 않으면 다음 메시지 컨버터로 우선순위가 넘어간다.

 

🟢 HTTP 요청 데이터 읽기

HTTP 요청이 오고, 컨트롤러에서 @RequestBody , HttpEntity 파라미터를 사용한다.

메시지 컨버터가 메시지를 읽을 수 있는지 확인하기 위해 canRead() 를 호출한다.

• 대상 클래스 타입을 지원하는가.
  • 예) @RequestBody 의 대상 클래스 ( byte[] , String , HelloData )
• HTTP 요청의 Content-Type 미디어 타입을 지원하는가.
  • 예) text/plain , application/json , */*

canRead() 조건을 만족하면 read() 를 호출해서 객체 생성하고, 반환한다.

 

🟢 HTTP 응답 데이터 생성

컨트롤러에서 @ResponseBody , HttpEntity 로 값이 반환된다.

메시지 컨버터가 메시지를 쓸 수 있는지 확인하기 위해 canWrite() 를 호출한다.

• 대상 클래스 타입을 지원하는가.
  • 예) return의 대상 클래스 ( byte[] , String , HelloData )
• HTTP 요청의 Accept 미디어 타입을 지원하는가.(더 정확히는 @RequestMapping 의 produces )
  • 예) text/plain , application/json , */*

canWrite() 조건을 만족하면 write() 를 호출해서 HTTP 응답 메시지 바디에 데이터를 생성한다.

◼️ 요청 매핑 헨들러 어뎁터 구조

springMVC 구조

RequestMappingHandlerAdapter 동작 방식

🟢 ArgumentResolver

1. 애노테이션 기반 컨트롤러를 처리하는 RequestMappingHandlerAdapter 는 ArgumentResolver 를 호출해서 컨트롤러(핸들러)가 필요로 하는 다양한 파라미터의 값(객체)을 생성한다.
2. ArgumentResolver 의 supportsParameter() 를 호출해서 해당 파라미터를 지원하는지 체크하고, 지원하면resolveArgument() 를 호출해서 실제 객체를 생성한다.
3. 그리고 이렇게 파리미터의 값이 모두 준비되면 컨트롤러를 호출하면서 값을 넘겨준다. 

🟢 ReturnValueHandler

1. 응답 값을 변환하고 처리
2. 예) ModelAndView , @ResponseBody , HttpEntity , String

HTTP 메시지 컨버터 위치

요청의 경우 ArgumentResolver( @RequestBody 또는 HttpEntity 를 처리) 가 있고, 이 ArgumentResolver 들이 HTTP 메시지 컨버터를 사용해서 필요한 객체를 생성한다.

 

응답의 경우 ReturnValueHandler( @ResponseBody 또는 HttpEntity 를 처리 ) 가 있다. 그리고 여기에서 HTTP 메시지 컨버터를 호출해서 응답 결과를 만든다.

 

스프링 MVC는 아래를 사용한다.

• @RequestBody @ResponseBody
  • RequestResponseBodyMethodProcessor(ArgumentResolver, ReturnValueHandler 둘다 구현)
• HttpEntity
  • HttpEntityMethodProcessor(ArgumentResolver, ReturnValueHandler 둘다 구현)

💫 스프링에서 기능확장이 필요할때는 WebMvcConfigurer를 상속받아 스프링 빈으로 등록하면 된다.