- 로깅
- 로그 라이브러리는 Logback, Log4J, Log4J2 등등 수 많은 라이브러리가 있는데, 그것을 통합해서 인터페이스로 제공하는 것이 바로 SLF4J 라이브러리다.
- 쉽게 이야기해서 SLF4J는 인터페이스이고, 그 구현체로 Logback 같은 로그 라이브러리를 선택하면 된다. 실무에서는 스프링 부트가 기본으로 제공하는 Logback을 대부분 사용한다.
//@Slf4j
@RestController
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";
}
}
- 매핑 정보
- @RestController
1. @Controller 는 반환 값이 String 이면 뷰 이름으로 인식된다. 그래서 뷰를 찾고 뷰가 랜더링 된다.
2. @RestController 는 반환 값으로 뷰를 찾는 것이 아니라, HTTP 메시지 바디에 바로 입력한다. 따라서 실행 결과로 ok 메세지를 받을 수 있다.
- @RestController
1. @Controller 는 반환 값이 String 이면 뷰 이름으로 인식된다. 그래서 뷰를 찾고 뷰가 랜더링 된다.
2. @RestController 는 반환 값으로 뷰를 찾는 것이 아니라, HTTP 메시지 바디에 바로 입력한다. 따라서 실행 결과로 ok 메세지를 받을 수 있다. @ResponseBody 와 관련이 있다.
- @RequestMapping("/hello-basic")
1. /hello-basic URL 호출이 오면 이 메서드가 실행되도록 매핑한다.
2. 대부분의 속성을 배열[] 로 제공하므로 다중 설정이 가능하다. {"/hello-basic", "/hello-go"}
- 테스트
- 로그가 출력되는 포멧 확인
1. 시간, 로그 레벨, 프로세스 ID, 쓰레드 명, 클래스명, 로그 메시지
- 로그 레벨 설정을 변경해서 출력 결과
1.LEVEL: TRACE > DEBUG > INFO > WARN > ERROR
2. 개발 서버는 debug
3. 출력 운영 서버는 info 출력
- @Slf4j 로 변경
- 로그 사용법
log.debug("data={}", data)- 로그 출력 레벨을 info로 설정하면 아무일도 발생하지 않는다. 따라서 앞과 같은 의미없는 연산이 발생하지 않는다.
- HTTP 메서드 매핑 축약
@GetMapping(value = "/mapping-get-v2")
public String mappingGetV2() {
log.info("mapping-get-v2");
return "ok";
}- HTTP 메서드를 축약한 애노테이션을 사용하는 것이 더 직관적이다. 코드를 보면 내부에서 @RequestMapping 과 method 를 지정해서 사용하는 것을 확인할 수 있다.
- PathVariable(경로 변수) 사용
/**
* 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 API는 다음과 같이 리소스 경로에 식별자를 넣는 스타일을 선호한다.
1. /mapping/userA
2. /users/1 @RequestMapping 은 URL 경로를 템플릿화 할 수 있는데,
- @PathVariable 을 사용하면 매칭 되는 부분을 편리하게 조회할 수 있다.
- @PathVariable 의 이름과 파라미터 이름이 같으면 생략할 수 있다.
- 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 요청 - 기본, 헤더 조회
@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";
}
}1. HttpServletRequest
2. HttpServletResponse
3. HttpMethod : HTTP 메서드를 조회한다. org.springframework.http.HttpMethod
4. Locale : Locale 정보를 조회한다.
5. @RequestHeader MultiValueMap headerMap
1. 모든 HTTP 헤더를 MultiValueMap 형식으로 조회한다.
6. @RequestHeader("host") String host
1. 특정 HTTP 헤더를 조회한다.
2. 속성
1. 필수 값 여부: required
2. 기본 값 속성: defaultValue
7. @CookieValue(value = "myCookie", required = false) String cookie
1. 특정 쿠키를 조회한다.
2. 속성
1. 필수 값 여부: required
2. 기본 값: defaultValue
- MultiValueMap
1. MAP과 유사한데, 하나의 키에 여러 값을 받을 수 있다.
2. HTTP header, HTTP 쿼리 파라미터와 같이 하나의 키에 여러 값을 받을 때 사용한다.
1. keyA=value1&keyA=value2
MultiValueMap<String, String> map = new LinkedMultiValueMap();
map.add("keyA", "value1");
map.add("keyA", "value2");
//[value1,value2]
List<String> values = map.get("keyA");- HTTP 요청 파라미터 - 쿼리 파라미터, HTML Form
- 클라이언트에서 서버로 요청 데이터를 전달할 때는 주로 다음 3가지 방법을 사용한다.
1. GET - 쿼리 파라미터
1. /url?username=hello&age=20
2. 메시지 바디 없이, URL의 쿼리 파라미터에 데이터를 포함해서 전달
3. 예) 검색, 필터, 페이징등에서 많이 사용하는 방식
2. POST - HTML Form
1. content-type: application/x-www-form-urlencoded
2. 메시지 바디에 쿼리 파리미터 형식으로 전달 username=hello&age=20
3. 예) 회원 가입, 상품 주문,
3. HTML Form 사용 HTTP message body에 데이터를 직접 담아서 요청
1. HTTP API에서 주로 사용, JSON, XML, TEXT
2. 데이터 형식은 주로 JSON 사용
3. POST, PUT, PATCH
- 요청 파라미터 - 쿼리 파라미터, HTML Form
1. HttpServletRequest 의 request.getParameter() 를 사용하면 다음 두가지 요청 파라미터를 조회할 수 있다.
- GET, 쿼리 파라미터 전송
- 예시
http://localhost:8080/request-param?username=hello&age=20
- POST, HTML Form 전송
- 예시
POST /request-param ...
content-type: application/x-www-form-urlencoded
username=hello&age=20- GET 쿼리 파리미터 전송 방식이든, POST HTML Form 전송 방식이든 둘다 형식이 같으므로 구분없이 조회할 수 있다.
- 이것을 간단히 요청 파라미터(request parameter) 조회라 한다.
/**
* 반환 타입이 없으면서 이렇게 응답에 값을 직접 집어넣으면, 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");
}http://localhost:8080/request-param-v1?username=hello&age=20
- Post Form
<!DOCTYPE html>
<html>
<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>- Post의 경우 Form을 통해 파라미터를 전달한다.
- 리소스는 /resources/static 아래에 두면 스프링 부트가 자동으로 인식한다.
- Jar 를 사용하면 webapp 경로를 사용할 수 없다. 이제부터 정적 리소스도 클래스 경로에 함께 포함해야 한다.
- GET을 통해 URI에 파라미터 값을 입력하든, POST Form을 통해 전달하든 똑같이 'username=hello&age=20'의 값이 전달된다. 결국 둘다 파라미터로 값을 받아 올 수 있다.
- HTTP 요청 파라미터 - @RequestParam
@ResponseBody
@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의 name(value) 속성이 파라미터 이름으로 사용
1. @RequestParam("username") String memberName
2. -> request.getParameter("username")
@ResponseBody
@RequestMapping("request-param-v3")
public String requestParamV3(@RequestParam String username,
@RequestParam int age) {
log.info("username={}, age={}", username, age);
return "ok";
}- HTTP 파라미터 이름이 변수 이름과 같으면 @RequestParam(name="xx") 생략 가능
@ResponseBody
@RequestMapping("request-param-v4")
public String requestParamV4(String username, int age) {
log.info("username={}, age={}", username, age);
return "ok";
}- String , int , Integer 등의 단순 타입이면 @RequestParam 도 생략 가능
@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";
}- @RequestParam.required
1. 파라미터 필수 여부
2. 기본값이 파라미터 필수( true )이다.
- /request-param 요청
1. username 이 없으므로 400 예외가 발생한다.
- 주의! - 파라미터 이름만 사용
1. /request-param?username= 파라미터 이름만 있고 값이 없는 경우 빈문자로 통과
- 주의! - 기본형(primitive)에 null 입력
1. /request-param 요청
2. @RequestParam(required = false) int age
- null 을 int 에 입력하는 것은 불가능(500 예외 발생)
1. 따라서 null 을 받을 수 있는 Integer 로 변경하거나, 또는 다음에 나오는 defaultValue 사용
@ResponseBody
@RequestMapping("request-param-default")
public String requestParamDefault(
@RequestParam(defaultValue = "guest") String username,
@RequestParam(defaultValue = "-1") int age) {
log.info("username={}, age={}", username, age);
return "ok";
}- 파라미터에 값이 없는 경우 defaultValue 를 사용하면 기본 값을 적용할 수 있다. 이미 기본 값이 있기 때문에 required 는 의미가 없다.
- defaultValue 는 빈 문자의 경우에도 설정한 기본 값이 적용된다. /request-param-default?username=
/**
* @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> paraMap) {
log.info("username={}, age={}", paraMap.get("username"), paraMap.get("age"));
return "ok";
}- 파라미터를 Map, MultiValueMap으로 조회할 수 있다.
- @RequestParam Map ,
1. Map(key=value)
- @RequestParam MultiValueMap
1. MultiValueMap(key=[value1, value2, ...] ex) (key=userIds, value=[id1, id2])
- 파라미터의 값이 1개가 확실하다면 Map 을 사용해도 되지만, 그렇지 않다면 MultiValueMap 을 사용하자.
- HTTP 요청 파라미터 - @ModelAttribute
@Data
public class HelloData {
private String username;
private int age;
}- 롬복
1. @Data @Getter , @Setter , @ToString , @EqualsAndHashCode , @RequiredArgsConstructor 를 자동으로 적용해준다.
- 위와 같이 객체를 생성해준다.
@ResponseBody
@RequestMapping("/model-attribute-v1")
public String modelAttributeV1(@ModelAttribute HelloData helloData) {
log.info("username={}, age={}", helloData.getUsername(), helloData.getAge());
return "ok";
}- 스프링MVC는 @ModelAttribute 가 있으면 다음을 실행한다.
1. HelloData 객체를 생성한다.
2. 요청 파라미터의 이름으로 HelloData 객체의 프로퍼티를 찾는다. 그리고 해당 프로퍼티의 setter를 호출해서 파라미터의 값을 입력(바인딩) 한다.
3. 예) 파라미터 이름이 username 이면 setUsername() 메서드를 찾아서 호출하면서 값을 입력한다.
http://localhost:8080/model-attribute-v1?username=baek&age=20
@ResponseBody
@RequestMapping("/model-attribute-v2")
public String modelAttributeV2(HelloData helloData) {
log.info("username={}, age={}", helloData.getUsername(), helloData.getAge());
return "ok";
}- @ModelAttribute 는 생략할 수 있다.
- 스프링은 해당 생략시 다음과 같은 규칙을 적용한다.
1. String , int , Integer 같은 단순 타입 = @RequestParam
2. 나머지 = @ModelAttribute (argument resolver 로 지정해둔 타입 외)
- HTTP 요청 메시지 - 단순 텍스트
- HTTP message body에 데이터를 직접 담아서 요청
1. HTTP API에서 주로 사용, JSON, XML, TEXT
2. 데이터 형식은 주로 JSON 사용
3. POST, PUT, PATCH
/**
* 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) throws IOException {
String messageBody = httpEntity.getBody();
log.info("messageBody={}", messageBody);
return new HttpEntity<>("ok");
}- HttpEntity: HTTP header, body 정보를 편리하게 조회
1. 메시지 바디 정보를 직접 조회
2. 요청 파라미터를 조회하는 기능과 관계 없음 @RequestParam X, @ModelAttribute X
- HttpEntity는 응답에도 사용 가능
1. 메시지 바디 정보 직접 반환
2. 헤더 정보 포함 가능
3. view 조회X
- HttpEntity 를 상속받은 다음 객체들도 같은 기능을 제공한다.
- RequestEntity
1. HttpMethod, url 정보가 추가, 요청에서 사용
- ResponseEntity
1. HTTP 상태 코드 설정 가능, 응답에서 사용
2. return new ResponseEntity("Hello World", responseHeaders, HttpStatus.CREATED)
/**
* @RequestBody
* - 메시지 바디 정보를 직접 조회(@RequestParam X, @ModelAttribute X)
* - HttpMessageConverter 사용 -> StringHttpMessageConverter 적용
*
* @ResponseBody
* - 메시지 바디 정보 직접 반환(view 조회X)
* - HttpMessageConverter 사용 -> StringHttpMessageConverter 적용
*/
@ResponseBody
@PostMapping("/request-body-string-v4")
public String requestBodyStringV4(@RequestBody String messageBody) throws IOException {
log.info("messageBody={}", messageBody);
return "ok";
}- @RequestBody
1. @RequestBody 를 사용하면 HTTP 메시지 바디 정보를 편리하게 조회할 수 있다. 참고로 헤더 정보가 필요하다면 HttpEntity 를 사용하거나 @RequestHeader 를 사용하면 된다.
2. 이렇게 메시지 바디를 직접 조회하는 기능은 요청 파라미터를 조회하는 @RequestParam , @ModelAttribute 와는 전혀 관계가 없다.
- 요청 파라미터 vs HTTP 메시지 바디
1. 요청 파라미터를 조회하는 기능: @RequestParam , @ModelAttribute
2. HTTP 메시지 바디를 직접 조회하는 기능: @RequestBody
- @ResponseBody
1. @ResponseBody 를 사용하면 응답 결과를 HTTP 메시지 바디에 직접 담아서 전달할 수 있다. 물론 이 경우에도 view를 사용하지 않는다.
- HTTP 요청 메시지 - JSON
**
* @RequestBody 생략 불가능(@ModelAttribute 가 적용되어 버림)
* HttpMessageConverter 사용 -> MappingJackson2HttpMessageConverter (contenttype: application/json)
*
*/
@ResponseBody
@PostMapping("/request-body-json-v3")
public String requestBodyJsonV3(@RequestBody HelloData helloData) {
log.info("username={}, age={}", helloData.getUsername(), helloData.getAge());
return "ok";
}- @RequestBody 객체 파라미터
1. @RequestBody HelloData data
2. @RequestBody 에 직접 만든 객체를 지정할 수 있다.
- HttpEntity , @RequestBody 를 사용하면 HTTP 메시지 컨버터가 HTTP 메시지 바디의 내용을 우리가 원하는 문자나 객체 등으로 변환해준다. HTTP 메시지 컨버터는 문자 뿐만 아니라 JSON도 객체로 변환해준다.
- @RequestBody는 생략 불가능
- 스프링은 @ModelAttribute , @RequestParam 과 같은 해당 애노테이션을 생략시 다음과 같은 규칙을 적용한다.
1. String , int , Integer 같은 단순 타입 = @RequestParam
2. 나머지 = @ModelAttribute (argument resolver 로 지정해둔 타입 외)
- 따라서 이 경우 HelloData에 @RequestBody 를 생략하면 @ModelAttribute 가 적용되어버린다. HelloData data @ModelAttribute HelloData data 따라서 생략하면 HTTP 메시지 바디가 아니라 요청 파라미터를 처리하게 된다.
@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";
}- HttpEntity를 사용해도 된다
/**
* @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
1. 응답의 경우에도 @ResponseBody 를 사용하면 해당 객체를 HTTP 메시지 바디에 직접 넣어줄 수 있다. 물론 이 경우에도 HttpEntity 를 사용해도 된다.
- @RequestBody 요청
1. JSON 요청 -> HTTP 메시지 컨버터 -> 객체
- @ResponseBody 응답
1.객체 HTTP 메시지 컨버터 JSON 응답
- HTTP 응답 - 정적 리소스, 뷰 템플릿
1. 정적 리소스
1. 예) 웹 브라우저에 정적인 HTML, css, js를 제공할 때는, 정적 리소스를 사용한다.
2. 뷰 템플릿 사용
1. 예) 웹 브라우저에 동적인 HTML을 제공할 때는 뷰 템플릿을 사용한다.
3. HTTP 메시지 사용
1. HTTP API를 제공하는 경우에는 HTML이 아니라 데이터를 전달해야 하므로, HTTP 메시지 바디에 JSON 같은 형식으로 데이터를 실어 보낸다.
- 정적 리소스
1. 스프링 부트는 클래스패스의 다음 디렉토리에 있는 정적 리소스를 제공한다.
2. /static , /public , /resources , /META-INF/resources
3. src/main/resources 는 리소스를 보관하는 곳이고, 또 클래스패스의 시작 경로이다. 따라서 다음 디렉토리에 리소스를 넣어두면 스프링 부트가 정적 리소스로 서비스를 제공한다.
- 정적 리소스 경로
1. src/main/resources/static
2. 다음 경로에 파일이 들어있으면 src/main/resources/static/basic/hello-form.html
3. 웹 브라우저에서 다음과 같이 실행하면 된다. http://localhost:8080/basic/hello-form.html
4. 정적 리소스는 해당 파일을 변경 없이 그대로 서비스하는 것이다.
<!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>@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 메시지
1. @ResponseBody 가 없으면 response/hello 로 뷰 리졸버가 실행되어서 뷰를 찾고, 렌더링 한다.
2. @ResponseBody 가 있으면 뷰 리졸버를 실행하지 않고, HTTP 메시지 바디에 직접 response/hello 라는 문자가 입력된다.
- 여기서는 뷰의 논리 이름인 response/hello 를 반환하면 다음 경로의 뷰 템플릿이 렌더링 되는 것을 확인할 수 있다.
1. 실행: templates/response/hello.html
- Void를 반환하는 경우
1. @Controller 를 사용하고, HttpServletResponse , OutputStream(Writer) 같은 HTTP 메시지 바디를 처리하는 파라미터가 없으면 요청 URL을 참고해서 논리 뷰 이름으로 사용
1. 요청 URL: /response/hello
2. 실행: templates/response/hello.html
- 참고로 이 방식은 명시성이 너무 떨어지고 이렇게 딱 맞는 경우도 많이 없어서, 권장하지 않는다.
- HTTP 메시지
1. @ResponseBody , HttpEntity 를 사용하면, 뷰 템플릿을 사용하는 것이 아니라, HTTP 메시지 바디에 직접 응답 데이터를 출력할 수 있다.
- HTTP 응답 - HTTP API, 메시지 바디에 직접 입력
@Slf4j
@Controller
public class ResponseBodyController {
@GetMapping("/response-body-string-v1")
public void responseBodyV1(HttpServletResponse response) throws IOException {
response.getWriter().write("ok");
}
@GetMapping("/response-body-string-v2")
public ResponseEntity<String> responseBodyV2() throws IOException {
return new ResponseEntity<>("ok", HttpStatus.OK);
}
@ResponseBody
@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);
return new ResponseEntity<>(helloData, HttpStatus.OK);
}
@ResponseStatus(HttpStatus.OK)
@ResponseBody
@GetMapping("/response-body-json-v2")
public HelloData responseBodyJsonV2() {
HelloData helloData = new HelloData();
helloData.setUsername("userA");
helloData.setAge(20);
return helloData;
}
}- responseBodyV1
1. 서블릿을 직접 다룰 때 처럼
2. HttpServletResponse 객체를 통해서 HTTP 메시지 바디에 직접 ok 응답 메시지를 전달한다.
3. response.getWriter().write("ok")
- responseBodyV2
1. ResponseEntity 엔티티는 HttpEntity 를 상속 받았는데, HttpEntity는 HTTP 메시지의 헤더, 바디 정보를 가지고 있다. ResponseEntity 는 여기에 더해서 HTTP 응답 코드를 설정할 수 있다.
2. HttpStatus.CREATED 로 변경하면 201 응답이 나가는 것을 확인할 수 있다.
- responseBodyV3
1. @ResponseBody 를 사용하면 view를 사용하지 않고, HTTP 메시지 컨버터를 통해서 HTTP 메시지를 직접 입력할 수 있다. ResponseEntity 도 동일한 방식으로 동작한다.
- responseBodyJsonV1
1. ResponseEntity 를 반환한다. HTTP 메시지 컨버터를 통해서 JSON 형식으로 변환되어서 반환된다.
- responseBodyJsonV2
1. ResponseEntity 는 HTTP 응답 코드를 설정할 수 있는데, @ResponseBody 를 사용하면 이런 것을 설정하기 까다롭다. 2. @ResponseStatus(HttpStatus.OK) 애노테이션을 사용하면 응답 코드도 설정할 수 있다.
3. 물론 애노테이션이기 때문에 응답 코드를 동적으로 변경할 수는 없다. 프로그램 조건에 따라서 동적으로 변경하려면 ResponseEntity 를 사용하면 된다.
- @RestController
1. @Controller 대신에 @RestController 애노테이션을 사용하면, 해당 컨트롤러에 모두 @ResponseBody 가 적용되는 효과가 있다. 따라서 뷰 템플릿을 사용하는 것이 아니라, HTTP 메시지 바디에 직접 데이터를 입력한다. 이름 그대로 Rest API(HTTP API)를 만들 때 사용하는 컨트롤러이다.
- 참고로 @ResponseBody 는 클래스 레벨에 두면 전체 메서드에 적용되는데, @RestController 에노테이션 안에 @ResponseBody 가 적용되어 있다.
출처 : 인프런 - 우아한 형제들 기술이사 김영한의 스프링 완전 정복 (스프링 핵심원리 - 기본 편)
'Programming > Spring' 카테고리의 다른 글
| Spring - 메시지, 국제화 (0) | 2023.06.22 |
|---|---|
| Spring - 타임리프 - 기본 기능 (0) | 2023.06.20 |
| Spring - 스프링 MVC - 구조 이해 (0) | 2023.06.18 |
| Spring - RequestBodyJsonController (0) | 2023.06.16 |
| Spring - 웹 애플리케이션 이해 (0) | 2023.06.13 |