[스프링 MVC 1편] #6. 스프링 MVC - 기본 기능 (1)

[newh08]

프로젝트 생성
packaging 에서 Jar/ War 있는데 이번엔 Jar 선택
War: 톰켓(WAS 서버) 별도 설치 후 빌드된 파일 넣을때 War 선택 (또는 JSP 를 쓸 때)
Jar: 내장 톰켓 쓸 때

처음 롬복 셋팅

Jar 사용시 /resources/static/index.html 을 Welcome 페이지로 사용함. (index 파일 생성하기)

로깅 간단히 알아보기
기본적으로 스프링 부트가 dependencies 에 로그 라이브러리를 가져온다

• SLF4J : 인터페이스. 다양한 로그 구현체던 다 사용 가능하도록?
• Logback: SLF4J의 구현체

//@Controller 는 view 를 반환하게 되지만, @RestController 는 그냥 스트링 그 자체를 반환
@RestController
public class LogTestController {

    // LoggerFactory 를 slf4j 꺼로 사용해야함.
    private final Logger log = LoggerFactory.getLogger(getClass());

    @RequestMapping("/log-test")
    public String logTest(){
        String name = "test";

        // 남지 않음 -> 보려면 로그 레벨을 설정해야함(logging.level.hello.springmvc={level}
        // 내려갈수록 레벨이 높아진다 생각하면 됌
        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";
    }
}

/**
결과
2024-06-28T00:56:08.186+09:00  INFO 555 --- [springmvc] [nio-8080-exec-4] h.springmvc.basic.LogTestController      : info log = test
2024-06-28T00:56:08.189+09:00  WARN 555 --- [springmvc] [nio-8080-exec-4] h.springmvc.basic.LogTestController      : warn log = test
2024-06-28T00:56:08.190+09:00 ERROR 555 --- [springmvc] [nio-8080-exec-4] h.springmvc.basic.LogTestController      : error log = test
**/

로그 레벨을 debug 로 바꾸면 너무 많은 로그가 보임 (스프링 라이브러리에서도 로그 사용중)
private final Logger log = LoggerFactory.getLogger(getClass());
이렇게 로그를 선언해도 되지만, @slf4j 붙이면 그냥 선언 없이 log 사용 가능.

• log.trace("test" + name) 이런식으로 사용 X
  이유: 이 로그는 출력하지 않는데, 안에 연산이 진행되어 의미없는 연산이 발생함.

로그를 상황에 맞게 조절 가능!
콘솔에 남기기 or 파일로 남기기 + 파일 용량 크면 분할, 압축, 백업 기능 선택 가능
성능적으로도 System.out.println 보다 훨씬 좋음

요청 매핑
요청이 왔을때 알맞은 컨트롤러를 호출하는걸 맵핑
url 매핑 말고도 다양한 방법이 있음.
Mapping 의 다양한 기능에 대해!

@Slf4j
@RestController
public class MappingController {

    //가장 간단한 요청 맵핑 (url) 배열로 2개 넣을 수도 있음
    @RequestMapping({"/hello-basic", "hello-go"})
    public String helloBasic() {
        log.info("helloBasic");
        return "ok";
    }
}

/hello-basic, /hello-basic/
이 두개는 다른 url 이지만, 같은 요청으로 매핑함.

@RequestMapping 에 메서드를 get 으로 지정했는데, post 요청이 오면 405 오류를 반환한다. (정확히는 매핑 실패?)

url 자체에 변수가 있는 경우!

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

url = localhost:8080/mapping/userA -> 변수 data 에 userA 저장

• http API 가 리소스 경로에 식별자를 넣는 스타일을 선호함.
  이것과 다른 방식: 쿼리 파라미터 방식 (/mapping/?userId=userA)

PathVariable 을 여러개 해도 다 맵핑 가능하다!
@GetMapping("/mapping/user/{userId}/order/{orderId}

매핑에서 params -> url 에 해당 params 가 있어야 정상 작동

@GetMapping(value="/mapping-param", params = "mode=debug") // 특정 파라미터 정보가 있으면 수행됩니다!
    public String mappingParam() {
        log.info("mappingParam");
        return "ok";
    }

url: localhost:8080/mapping-param/?mode=debug
그런데 별로 사용 하지 않음..

해더 정보 매핑
params 대신 headers -> http header 에 넣어줘야 작동

미디어 타입 조건 매핑
http header content-type 에 따라!

@PostMapping(value="/mapping-Consumes", consumes = "application/json")
    public String mappingConsumes() {
        return "ok";
    }

http body 를 raw, JSON 으로 변경해 요청
요청 http headers 의 content-type 과 consumes 가 일치해야 정상 작동.

다른 예시
consumes = "text/plain"
consumes = {"text/plain", "application/*"}
consumes = MediaType.TEXT_PLAIN_VALUE

consumes -> 요청 정보를 소비
produces -> 서버에서 정보 생산

@PostMapping(value = "/mapping-produce", produces = "text/html")
    public String mappingProduce() {
        return "ok";
    }

http header 의 accept 와 produces 가 일치해야 정상 작동.

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

요청 매핑 - API 예시
회원관리 API

• 회원 목록 조회 : GET '/users'
• 회원 등록 : POST '/users'
• 회원 조회 : GET '/users/{userId}'
• 회원 수정 : PATCH '/users/{userId}'
• 회원 삭제 : DELETE '/users/{userId}'

@RestController
public class MappingClassController {
    /**
     * - 회원 목록 조회 : GET      '/users' 
     * - 회원 등록        : POST    '/users' 
     * - 회원 조회        : GET       '/users/{userId}'
     * - 회원 수정        : PATCH  '/users/{userId}' 
     * - 회원 삭제        : DELETE '/users/{userId}'
     */

    @GetMapping("/mapping/users")
    public String user() {
        return "getUser";
    }

    @PostMapping("/mapping/users")
    public String addUser() {
        return "post user";
    }

    @GetMapping("/mapping/users/{userId}")
    public String findUser(@PathVariable String userId) {
        return "get userId" + userId;
    }

    @PatchMapping("/mapping/users/{userId}")
    public String updateUser(@PathVariable String userId) {
        return "update userId" + userId;
    }

    @DeleteMapping("/mapping/users/{userId}")
    public String deleteUser(@PathVariable String userId) {
        return "delete userId" + userId;
    }
}

Class 레벨에 @RequestMapping("/mapping/users") 를 추가하면 중복 제거 가능.
postman 으로 매핑 확인 가능.

HTTP 요청 - 기본,헤더 조회
실제 요청된 HTTP 정보가 스프링에서 어떤식으로 조회되는지?
스프링 MVC 가 HTTP 요청 헤더 조회를 아주 간편하게 해주는 기능 있음.

@Slf4j
@RestController
public class RequestHeaderController {

    @RequestMapping("/headers")
    // 에노테이션 기반 컨트롤러는 정말 다양한 파라미터를 받을 수 있다.
    public String headers(HttpServletRequest request,
                          HttpServletRequest 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";
    }
}

MultiValueMap -> 하나의 키에 여러 값을 받을 수 있음. -> 키를 꺼내면 배열이 반환됨.
속성:
required 필수값 여부
defaultValue 기본값 속성

어노테이션기반 컨트롤러에서 사용할 수 있는 파라미터는 공식 메뉴얼에 나와 있다.
https://docs.spring.io/spring-framework/docs/current/reference/html/web.html#mvc-ann- arguments
파라미터 뿐 만 아니라 가능한 리턴도 공식 메뉴얼에 있다.
https://docs.spring.io/spring-framework/docs/current/reference/html/web.html#mvc-ann- return-types

HTTP 요청 파라미터 - 쿼리 파라미터, HTML Form
전송된 쿼리 파라미터, HTML Form 이 어떻게 처리되는지?

클라이언트에서 서버로 요청 데이터 전달 방법은 3가지

• Get : 쿼리 파라미터 (URL)
• Post : HTML Form (메시지 바디에 쿼리 파라미터 형식으로)
• Http message body 에 데이터를 직접 담아서 요청 (JSON, XML)

쿼리파라미터, HTML Form 조회는 '요청 파라미터(request parameter) 조회' 라고 함
스프링으로 요청 파라미터 조회하는 방법?
단계적으로 알아보자.

//HttpServletRequest 가 제공하는 방식 사용 , 쿼리 파라미터던, HTML Form 이던 다 받을 수 있음
    @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"));
        response.getWriter().write("ok");
    }

HTTP 요청 파라미터 - @RequestParam
스프링이 제공하는 @RequestParam 사용하면 매우 간편함.

    @ResponseBody // 이게 없으면 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";
    }

    @ResponseBody
    @RequestMapping("/request-param-v3")
    public String requestParamV3(
            @RequestParam String username, // 파라미터 이름과 변수명이 같으면 ("") 생략 가능
            @RequestParam int age) {

        log.info("username={}, age={}", username, age);
        return "ok";
    }

    @ResponseBody
    @RequestMapping("/request-param-v4")
    public String requestParamV4(String username, int age) { // 단순 타입이면 @RequestParam 생략 가능
        log.info("username={}, age={}", username, age);
        return "ok";
    }

    @ResponseBody
    @RequestMapping("/request-param-required")
    public String requestParamRequired(
            //필수 여부 설정 가능
            @RequestParam(required = true) String username, // 기본값은 true, 파라미터가 없으면 오류남. 그런데 "" 가 들어가면 통과는 됨.
            @RequestParam(required = false) Integer age) { // int 로 하면 null 이 들어갈 수 없어 required = false 가 의미 없음. Integer 로 해야함

        log.info("username={}, age={}", username, age);
        return "ok";
    }

    @ResponseBody
    @RequestMapping("/request-param-default")
    public String requestParamDefault(
            @RequestParam(required = true, defaultValue = "guest") String username,
                      // 값이 없을때 디폴트 값 설정!  이게 있으면 required=true 가 의미 없음. + 빈 문자도 인지해서 디폴트로 바꿔줌!
            @RequestParam(required = false, defaultValue = "-1") int age) {

        log.info("username={}, age={}", username, age);
        return "ok";
    }

    @ResponseBody
    @RequestMapping("/request-param-map")
    // 모든 파라미터 받기, MultiValueMap 도 가능. 파라미터 값이 1개가 확실하지 않다면 MultiValueMap 사용하자!
    // ?userId=1,&userId=2
    public String requestParamMap(@RequestParam Map<String, Object> paramMap) {
        log.info("username={}, age={}", paramMap.get("username"), paramMap.get("age"));
        return "ok";
    }

HTTP 요청 파라미터 - @ModelAttribute
파라미터를 받아 객체로 바꾸는 편리한 방법.
@ModelAttribute 가 파라미터를 받아 객체를 자동으로 만들어준다

    @ResponseBody
    @RequestMapping("/model-attribute-v1")
    public String modelAttributeV1(@ModelAttribute HelloData helloData) {
        // @ModelAttribute 를 사용하면 이걸 다 지울 수 있음!!
        //HelloData helloData1 = new HelloData();
        //helloData1.setUsername(userName); <- 파라미터를 받아 객체 생성
        //helloData1.setAge(age);
        // 어떻게? 파라미터 이름으로 set 메서드 호출 파라미터 이름이 username 이면 setUsername() 메서드 호출함.

        log.info("username={}, age={}", helloData.getUsername(), helloData.getAge());
        return "ok";
    }

    @ResponseBody
    @RequestMapping("/model-attribute-v2")
    //@ModelAttribute 생략 가능. 어떻게 가능하지? -> 스프링이 기본 타입은 @RequestParam 로, 나머지는 @ModelAttribute 로 판단. (ArgumentResolver 제외)
    public String modelAttributeV2(HelloData helloData) {
        log.info("username={}, age={}", helloData.getUsername(), helloData.getAge());
        return "ok";
    }

바인딩 오류! 타입이 다른 경우 발생함. 검증 및 오류에서 처리 가능.

@ModelAttribute 의 속성? 뒤에서..

HTTP 요청 메시지 - 단순 텍스트
요청 파라미터 말고 메시지 바디에서 직접 데이터가 넘어오는 경우

• HTTP API 에서 주로 사용, JSON, XML, TEXT
• 데이터 형식은 주로 JSON
• POST, PUT, PATCH 메서드

이런 경우는 @RequestParam, @ModelAttribute 사용 불가.
inputStream 을 사용해 읽을 수 있음?

@Slf4j
@Controller
public class RequestBodyStringController {

    // 서블릿과 동일!
    @PostMapping("/request-body-string-v1")
    public void requestBodyString(HttpServletRequest request, HttpServletResponse response) throws IOException {
        ServletInputStream inputStream = request.getInputStream();
        // 스트림은 바이트 코드이기 때문에 문자로 받을땐 어떤 인코딩을 할지 넣어줘야함. 지정 안하면 디폴트 사용함 (OS 에 설정된것?)
        String messageBody = StreamUtils.copyToString(inputStream, StandardCharsets.UTF_8);

        log.info("messageBody={}", messageBody);

        response.getWriter().write("ok");
    }

    @PostMapping("/request-body-string-v2")
    // 메뉴얼에서 확인했듯이.. 파라미터로 inputStream 을 받을 수 있음. 리턴으론 Writer 를 줄 수 있음.
    public void requestBodyStringV2(InputStream inputStream, Writer responseWriter) throws IOException {
        // 이 스트림 바꾸는거 별론데..
        String messageBody = StreamUtils.copyToString(inputStream, StandardCharsets.UTF_8);
        log.info("messageBody={}", messageBody);
        responseWriter.write("ok");
    }

    @PostMapping("/request-body-string-v3")
    // HTTP 메시지 컨버터라는 기능인데 나중에 설명 예정.
    public HttpEntity<String> requestBodyStringV3(HttpEntity<String> httpEntity) throws IOException {
        //<String> 을 보고 넌 문자니 내가 알아서 변환해줄게 ! -> HTTPMessageConverter 가 동작함.
        String messageBody = httpEntity.getBody();
        log.info("messageBody={}", messageBody);
        // 리턴도..
        return new HttpEntity<>("ok");
    }
}

HttpEntity: Http header, body 정보를 편리하게 조회할 수 있도록 도와줌

• 메시지 바디 정보 직접 조회
• 요청 파라미터 조회와는 무관!!!
• 응답에도 사용 가능, 헤더나 바디에 정보 넣어서. 뷰 조회는 안함.

HttpEntity 를 상속받은 RequestEntity, ResponseEntity 도 있음.

HTTP 메세지 컨버터: HTTP 바디를 읽어 문자나 객체로 변환해줌

이것도 귀찮아서 에노테이션을 제공함.

    @ResponseBody // Http 응답 코드에 리턴하는 스트링을 넣어줌.
    @PostMapping("/request-body-string-v4")
    public String requestBodyStringV4(@RequestBody String messageBody) {
        log.info("messageBody={}", messageBody);
        return "ok";
    }

@RequestBody
Http 메시지 바디 정보 조회 가능. 헤더정보가 필요하면 HttpEntity 나 @RequestHeader 사용
다시한번, 요청 파라미터 조회와는 관계가 없다!!

정리

• 요청파라미터 조회 : @RequestParam, @ModelAttribute
• Http 메시지 바디 조회 : @RequestBody

HTTP 요청 메시지 - JSON
JSON 데이터 형식 조회

@Slf4j
@Controller
public class RequestBodyJsonController {

    // JSON 이니 필요!
    private ObjectMapper objectMapper = new ObjectMapper();

    // 서블릿과 같은 방식. postman 에서 테스트시 Content-Type application/JSON 확인
    @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");
    }

    @ResponseBody
    @PostMapping("/request-body-json-v2")
    // http 메시지 바디를 @RequestBody 로 바꿔서
    public String requestBodyJsonV2(@RequestBody String messageBody) throws IOException {

        log.info("messageBody={}", messageBody);
        // 그치만 JSON 을 객체로 변환시키는 과정이 있는데.. 이게 귀찮다!
        HelloData helloData = objectMapper.readValue(messageBody, HelloData.class);
        log.info("username={}, age={}", helloData.getUsername(), helloData.getAge());

        return "ok";
    }

    @ResponseBody
    @PostMapping("/request-body-json-v3")
    // 메시지 바디를 받을 때 String 이 아니라 변환하는 객체로 바로 받을 수 있음.
    // 어떻게 이게 가능? 메시지 컨버터가 http 헤더의 컨텐츠 타입을 보고 JSON 를 파악, 이를 바탕으로 객체로 만들어준다. -> content-type 확인 필요함.
    // 그런데 여기서 @RequestBody 를 삭제하면? @ModelAttribute 로 작동함.
    // 이 때 객체는 생성하지만 파라미터가 없으니 setXxx 가 호출되지 않아 빈 객체가 생성됨 (int age 는 디폴트 값인 0 이 들어감)
    public String requestBodyJsonV3(@RequestBody HelloData data) {
        log.info("username={}, age={}", data.getUsername(), data.getAge());
        return "ok";
    }

    @ResponseBody
    @PostMapping("/request-body-json-v4")
    // HTTP 메시지 컨버터가 HttpEntity<T> 에서 T 를 보고 그 타입으로 변환해주기 때문에 HttpEntity<> 도 사용 가능
    public String requestBodyJsonV4(HttpEntity<HelloData> httpEntity) {
        HelloData data = httpEntity.getBody();
        log.info("username={}, age={}", data.getUsername(), data.getAge());
        return "ok";
    }

    @ResponseBody // http 메시지 컨버터가 들어올때 + 나갈때 둘 다 적용 가능함
    @PostMapping("/request-body-json-v5")
    // 반환타입을 HelloData 로
    public HelloData requestBodyJsonV5(@RequestBody HelloData data) {
        log.info("username={}, age={}", data.getUsername(), data.getAge());
        // data 를 다시 JSON 으로 바꾸고, 이를 http 메시지 응답에 넣어서 응답함! 이 때 Accept:application/json 이어야 함 (이 설정이 HTTP 메시지 컨버터에 영향을 준다?)
        return data;
    }
}

@RequestBody에 직접 만든 객체 지정 가능(@RequestBody HelloData data)
HTTP 메시지 컨버터가 HttpEntity 에서 T 를 보고 그 타입으로 변환해준다.
JSON 요청 -> HTTP 메시지 컨버터 -> 객체

@responsebody
객체 -> HTTP 메시지 컨버터 -> JSON 응답

[seyxxn]

저번주차꺼까지 올리셨네요 ! 수고하셨습니당 ~