6.스프링 MVC - 기본 기능

로깅 간단하게 알아보기

로깅 라이브러리

• 스프링 부트 라이브러리를 사용하면 스프링 부트 로깅 라이브러리(spring-boot-starter-logging)이 포함된다.

• SLF4J: 인터페이스

• Logback, Log4J, Log4J2: SLF4J인터페이스 구현체

로그 선언

• private Logger log = LoggerFactory.getLogger(getClass());

• @Slf4j 롬복

로깅 사용

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);

• 개발 환경, 배포 환경 등 여러 각각의 환경에 맞게 선택적 출력을 할 수 있고, 성능적으로도 sout보다 훨씬 빠르기 때문에 반드시 로깅을 사용해야 한다.

• TRACE > DEBUG > INFO > WARN > ERROR

요청 매핑(RequestMapping)

HTTP 메서드 매핑과 축약

@RequestMapping(value = "/mapping-get-v1", method = RequestMethod.GET)
public String mappingGetV1() {
    log.info("mappingGetV1");
    return "ok";
}

@GetMapping("/mapping-get-v2")
public String mappingGetV2() {
    log.info("mappingGetV2");
    return "ok";
}

• @RequestMapping 애너테이션에 method 옵션으로 메서드를 지정할 수 있고, 이를 축약하여 @GetMapping, @PostMapping, @PutMapping, @PatchMapping, @DeleteMapping을 사용할 수 있다.

경로 변수 사용(@PathVariable)

@GetMapping("/mapping/{userId}")
public String mappingPath(@PathVariable("userId") String data) {
    log.info("mappingPath userId={}", data);
    return "ok";
}

@GetMapping("/mapping/users/{userId}/orders/{orderId}")
public String mappingPath(@PathVariable String userId, @PathVariable Long orderId) {
    log.info("mappingPath userId={}, orderId={}", userId, orderId);
    return "ok";
}

• @PathVariable애너테이션을 통해서 경로 변수를 사용할 수 있고, 여러 개도 받을 수 있다.

특정 파라미터 조건 매핑

@GetMapping(value = "/mapping-param", params = "mode=debug")
public String mappingParam() {
    log.info("mappingParam");
    return "ok";
}

• params 옵션을 통해서 특정 파라미터(mode 파라미터가 debug)일 때만 처리할 수도 있다.

특정 헤더 조건 매핑

@GetMapping(value = "/mapping-header", headers = "mode=debug")
public String mappingHeader() {
    log.info("mappingHeader");
    return "ok";
}

• headers 옵션을 통해서 특정 헤더(헤더의 mode옵션이 debug)일 때만 처리할 수도 있다.

미디어 타입 조건 매핑(Content-Type)

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

• HTTP 요청의 Content-Type헤더 기반으로 미디어 타입 매핑을 할 수도 있다.

미디어 타입 조건 매핑(Accept)

@PostMapping(value = "/mapping-consume", produces = "text/html")
public String mappingProduces() {
    log.info("mappingProduces");
    return "ok";
}

• HTTP 요청의 Accept헤더 기반으로 미디어 타입 매핑을 할 수도 있다.

HTTP 요청

헤더 조회

@Slf4j
@RestController
public class RequestHeadController {
    @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";
    }
}

• HttpMoethod: HTTP요청의 메서드 정보를 조회한다.

• Locale: HTTP요청의 Locale정보를 조회한다.

• @RequestHeader MultiValueMap<String, String>: 모든 HTTP헤더를 MultiValueMap형식으로 조회한다.

• @RequestHeader("host") String host: 특정 HTTP헤더를 조회한다.

• @CookieValue(value = "myCookie", required = false) String cookie: 특정 쿠기를 조회한다.

쿼리 파라미터, HTML Form

RequestParam

• 쿼리 파라미터는 GET방식, HTML Form은 POST방식이지만, SpringBoot에서 파싱하는 방법은 동일하다.

@Slf4j
@Controller
public class RequestParamController {
    @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");
    }

    @ResponseBody
    @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) {
        log.info("username={}, age={}", username, age);
        return "ok";
    }

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

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

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

• v1: request.getParameter()를 통해서 서블릿을 사용하는 것과 같이 조회할 수 있다.

• v2: @RequestParam애너테이션을 사용해서 요청 파라미터를 쉽게 가져올 수 있다.
  • @ResponseBody애너테이션을 사용하여 View조회를 무시하고, body에 직접 입력한다.

• v3: @RequestParam애너테이션에서 변수이름과 파라미터 이름이 동일하면 name 속성을 생략할수 있다.

• v4: Java pritimive 타입(int, long, byte…) + String + Wrapper 의 경우는 애너테이션을 생략하면, 기본적으로 @RequestParam를 통해서 가져온다.

• required: required 옵션을 통해서 필수여부를 지정할 수 있다. 파라미터가 넘어오지 않으면, null로 되어 처리된다.
  • primitive에는 null을 넣을 수 없으므로 예외가 발생한다(500번)
  • 단, required가 true이더라도 빈 문자열(username=&age=20)이 들어오면 에러가 발생하지 않는다.
  • 기본값은 true이되, v4와 같이 애너테이션을 생략하면 false가 기본이다.

• default: defaultValue 옵션을 통해서 파라미터가 없을 경우 기본 값을 지정할 수 있다.

• map: 파라미터를 Map과 MultiValueMap을 통해서 조회할 수도 있다.

ModelAttribute

@Slf4j
@Controller
public class RequestParamController {
    @ResponseBody
    @RequestMapping("/model-attribute-v1")
    public String modeAttributeV1(@ModelAttribute HelloData helloData) {
        log.info("username={}, age={}", helloData.getUsername(), helloData.getAge());
        log.info("helloData={}", helloData);
        return "ok";
    }

    @ResponseBody
    @RequestMapping("/model-attribute-v2")
    public String modeAttributeV2(HelloData helloData) {
        log.info("username={}, age={}", helloData.getUsername(), helloData.getAge());
        log.info("helloData={}", helloData);
        return "ok";
    }
}

• v1: @ModelAttriute애너테이션을 통해서 객체에 바로 값을 바인딩할 수 있다.
  • 먼저 스프링이 객체를 생성한다.
  • 파라미터 이름으로 객체의 프로퍼티를 찾고, 해당 프로퍼티를 setter를 호출하여 세팅한다.

• v2: Java pritimive 타입(int, long, byte…) + String + Wrapper을 제외한 나머지 객체는 애너테이션 생략시 ModelAttribute가 삽입된다.
  • 이런 작업을 Argument Resolver가 하게 된다.

단순 텍스트(RequestBody)

@Slf4j
@Controller
public class RequestBodyController {
    @PostMapping("/request-body-string-v1")
    public void requestBodyStringV1(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");
    }

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

    @PostMapping("/request-body-string-v3")
    public HttpEntity<String> requestBodyStringV3(HttpEntity<String> httpEntity) {
        String messageBody = httpEntity.getBody();
        log.info("messageBody={}", messageBody);

        return new HttpEntity<>("ok");
    }

    @ResponseBody
    @PostMapping("/request-body-string-v4")
    public String requestBodyStringV4(@RequestBody String messageBody) {
        log.info("messageBody={}", messageBody);

        return "ok";
    }
}

• v1: 기존의 방법으로, request에서 InputStream을 가져와 읽을 수 있다.

• v2: InputStream과 Writer를 request와 response에서 가져오는 것이 아닌 파라미터로 직접 받을 수 있다.

• v3: HttpEntity를 통해서 HTTP의 header와 body를 편리하게 조회할 수 있다. 뿐만 아니라 HttpEntity를 상속받은 RequestEntity, ResponseEntity를 사용할 수도 있다.

• v4: @RequestBody와 @ResponseBody 애너테이션을 통해서 HTTP 메시지를 직접 받을 수도, 직접 넘길수도 있다.

JSON(RequestBody)

@Slf4j
@Controller
public class RequestJsonController {
    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 helloData = objectMapper.readValue(messageBody, HelloData.class);
        log.info("username={}, age={}", helloData.getUsername(), helloData.getAge());

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

    @ResponseBody
    @PostMapping("/request-body-json-v2")
    public String requestBodyJsonV2(@RequestBody String messageBody) throws IOException {
        log.info("messageBody={}", messageBody);
        HelloData helloData = objectMapper.readValue(messageBody, HelloData.class);
        log.info("username={}, age={}", helloData.getUsername(), helloData.getAge());

        return "ok";
    }

    @ResponseBody
    @PostMapping("/request-body-json-v3")
    public String requestBodyJsonV3(@RequestBody HelloData helloData) throws IOException {
        log.info("username={}, age={}", helloData.getUsername(), helloData.getAge());

        return "ok";
    }

    @ResponseBody
    @PostMapping("/request-body-json-v4")
    public String requestBodyJsonV4(HttpEntity<HelloData> httpEntity) throws IOException {
        HelloData helloData = httpEntity.getBody();
        log.info("username={}, age={}", helloData.getUsername(), helloData.getAge());

        return "ok";
    }

    @ResponseBody
    @PostMapping("/request-body-json-v5")
    public HelloData requestBodyJsonV5(@RequestBody HelloData helloData) throws IOException {
        log.info("username={}, age={}", helloData.getUsername(), helloData.getAge());

        return helloData;
    }
}

• v1: 이전과 마찬가지로 request에서 InputStream을 가져온 뒤 String으로 읽고, ObjectMapper로 deserialize해줄 수 있다.
  • 다만만, @ModelAttribute과 달리 setter가 필요없다!

• v2: 이전의 v4와 마찬가지로 @RequestBody애너테이션을 통해서 직접 String을 읽고, ObjectMapper로 deserialize해줄 수 있다.

• v3: @RequestBody애너테이션을 사용하면 사용자 생성 객체도 JSON을 통해서 받을 수 있다.
  • 다만, @RequestParam과 @ModelAttribute와 달리 생략이 불가능하다.
  • 만약 생략하면 @ModelAttribute와 같이 동작하기 때문에 body를 파싱하지 못 한다.

• v4: HttpEntity를 사용할 수도 있다.

• v5: @ResponseBody 사용 시 객체를 넘겨줄 수도 있다.

HTTP 응답

정적 리스소

• 스프링 부트는 /static, /public, /resources, /META-INF/resources경로에 있는 정적 리소스를 제공한다.

• src/main/resources/static에 basic/hello-form.html을 보관하면 http://localhost:8080/basic/hello-form.html에서 실행할 수 있다.

뷰 템플릿

• src/main/resources/templates가 기본 뷰 템플릿 경로다.

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

• v1: ModelAndView객체를 통해서 논리적인 view이름과 mode을 반환할 수 있다.

• v2: 일반 String을 논리적인 view이름으로 반환하고, Model객체를 파라미터로 받을 수 있다.

• v3: 만약 void로 리턴할 경우, 논리적인 view이름을 request url로 매핑한다.

HTTP API, 메시지 바디에 직접 입력

@Slf4j
@Controller
public class ResponseBodyController {
    @GetMapping("/response-body-string-v1")
    public void responseBodyStringV1(HttpServletRequest request, HttpServletResponse response) throws IOException {
        response.getWriter().write("ok");
    }

    @GetMapping("/response-body-string-v2")
    public ResponseEntity<String> responseBodyStringV2() {
        return new ResponseEntity<>("ok", HttpStatus.OK);
    }

    @ResponseBody
    @GetMapping("/response-body-string-v3")
    public String responseBodyStringV3() {
        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;
    }
}

• v1: 서블릿을 다룰 때 처럼 response에서 Writer객체를 얻어 직접 쓸 수 있다.

• v2: HttpEntity의 자식클래스인 ResponseEntity를 통하여 메시지의 헤더, 바디, 응답코드를 설정하여 반환할 수 있다.

• v3: @ResponseBody애너테이션을 사용하면 String을 view이름이 아닌 HTTP 메시지 컨버터를 통해서 HTTP 메시지를 직접 입력한다.

• json-v1: ResponseEntity를 통해서 HTTP 메시지 컨버터를 통하여 JSON형식으로 변환하여 반한한다.

• json-v2: ResponseEntity대신 @ResponseBody를 사용하면 응답코드를 설정할 수 없는데, @ResponseStatus애너테이션으로 응답코드를 설정할 수 있다.
  • 물론, 동적으로 응답코드를 설정하려면 ResponseEntity를 사용해야한다.

HTTP 메시지 컨버터

• @ResponseBody를 사용
  • HTTP의 BODY에 문자 내용을 직접 반환
  • viewResolver대신에 HttpMessageConverter가 동작
  • 기본 문자 처리: StringHttpMessageConverter
  • 기본 객체 처리: MappingJackson2HttpMessageConverter
  • byte 처리 등 기다 여러 HttpMessageConverter가 기본으로 등록되어있음.

• 스프링 MVC는 다음의 경우에 HTTP 메시지 컨버터를 적용한다.
  • HTTP요청: @RequestBody, HttpEntity(RequestEntity)
  • HTTP응답: @ResponseBody, HttpEntity(ResponseEntity)

HTTP 메시지 컨버터 인터페이스

package org.springframework.http.converter;

public interface HttpMessageConverter<T> {

	boolean canRead(Class<?> clazz, @Nullable MediaType mediaType);
	boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType);

	List<MediaType> getSupportedMediaTypes();

	T read(Class<? extends T> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException;
	void write(T t, @Nullable MediaType contentType, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException;
}

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

• ByteArrayHttpMessageConverter: byte[] 데이터를 처리한다.
  • 클래스 타입: byte[], 미디어타입: */*
  • 요청 예) @RequestBody byte[] data
  • 응답 예) @ResponseBody return byte[] 쓰기 미디어타입 application/octet-stream

• StringHttpMessageConverter: String 문자로 데이터를 처리한다.
  • 클래스 타입: String, 미디어타입: */*
  • 요청 예) @RequestBody String data
  • 응답 예) @ResponseBody return "ok" 쓰기 미디어타입 text/plain

• MappingJackson2HttpMessageConverter: application/json
  • 클래스 타입: 객체 또는 HashMap,미디어타입 application/json 관련
  • 요청 예) @RequestBody HelloData data
  • 응답 예) @ResponseBody return helloData 쓰기 미디어타입 application/json관련

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 메시지 컨버터는 컨트롤러의 정보를 알아야 하기 때문에 핸들러 어댑터에서 동작하게 된다.

• 애노테이션 기반의 컨트롤러이기 때문에 @RequestMapping을 처리하는 RequestMappingHandlerAdapter에서 HTTP 메시지 컨버터가 동작한다.

RequestMappingHandlerAdpter 동작 방식

ArgumentResolver

public interface HandlerMethodArgumentResolver {

	boolean supportsParameter(MethodParameter parameter);

	@Nullable
	Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer, NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception;
}

• 애노테이션 기반의 컨트롤러는 매우 다양한 파라미터를 사용할 수 있다. HttpServletRequest, Model, @RequestParam, @ModelAttribute등 모두 사용할 수 있다.

• 이를 처리할 수 있는 이유가 ArgumentResolver덕분이다. 이 객체를 사용해서 파라미터의 값이 모두 준비되면 그제서야 비로소 컨트롤러를 호출한다.

ReturnValueHandler

• ArgumentResolver와 비슷하게, 컨트롤러에서 String으로 뷰 이름을 반환해도 동작하는 이유가 이 객체 덕분이다.

HTTP 메시지 컨버터

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

• 응답의 경우: @ResponseBody와 HttpEntity를 처리하는 ReturnValueHandler가 있다. 그리고 여기서 HTTP 메시지 컨트롤러를 호출해서 응답 결과를 만든다.

확장

• 스프링은 다음을 모두 인터페이스로 제공한다. 따라서 언제든지 기능을 확장할 수 있다.
  • HandlerMethodArgumentResolver
  • HandlerMethodReturnValueHandler
  • HttpMessageConverter

• 그럴 일이 많지는 않지만, 확장하기 위해서는 WebMvcConfigurer를 상속 받아서 스프링 빈으로 등록하면 된다.

@Bean
public WebMvcConfigurer webMvcConfigurer() {
	return new WebMvcConfigurer() {
		@Override
		public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
			//...
		}

		@Override
		public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
			//...
		}
	};
}

Uploaded by N2T

(23.06.21 22:15)에 작성된 글 입니다.