🌱 스프링 MVC 1

yeop·2023년 5월 29일

Spring

✔️ 웹 애플리케이션의 이해

웹 서버, 웹 애플리케이션 서버

웹 서버

정적 리소스 제공
예) Nginx, Apache

웹 애플리케이션 서버

웹 서버 기능 포함 + 동적 리소스 제공
프로그램 코드를 실행해서 애플리케이션 로직 수행
예) 톰캣, Jetty, Undertow

서블릿

서블릿에서 초록색 박스 안의 것들을 제외하고 모두 대신 처리해준다.
WAS, 서블릿 컨테이너 구조

@WebServlet(name="helloServlet", urlPatterns="/hello")
public classs HelloServlet extends HttpServlet {
		
		@Override
		protected void service(HttpsServletRequest request, HttpServletResponse response){
				//  애플리케이션 로직
		}
}

톰캣처럼 서블릿을 지원하는 WAS를 서블릿 컨테이너라고 한다
서블릿 컨테이너는 서블릿 객체를 생성, 초기화, 호출, 종료하는 생명주기를 관리한다.
서블릿 객체는 싱글톤으로 관리된다.
서블릿 컨테이너 종료 시 함께 종료된다.
JSP도 서블릿으로 변화 되어서 사용
동시 요청을 위한 멀티 쓰레드 처리 지원

동시 요청 - 멀티 쓰레드

쓰레드

애플리케이션 코드를 하나하나 순차적으로 실행하는 것은 쓰레드
쓰레드가 없다면 자바 애플리케이션 실행이 불가능

쓰레드 풀

동시 요청의 경우 요청이 올 때마다 쓰레드를 생성하면 쓰레드가 너무 많이 생성되면 리소스가 임계점을 넘어 서버가 죽을 수도 있고 생성 비용 또한 비효율적이다.
그래서 필요한 쓰레드를 최대치를 설정해놓고 쓰레드 풀에 보관하고 관리한다.
쓰레드 풀에 있는 쓰레드가 모두 사용 중이라면 기다리는 요청은 거절하거나 특정 숫자만큼 대기하도록 설정할 수 있다.
장점
- 쓰레드가 미리 생성되어 있어, 쓰레드를 생성하고 종료하는 비용(CPU)이 절약되고 응답시간이 빠르다.
- 생성 가능한 쓰레드 최대치가 있어 많은 요청이 들어와도 기존 요청은 안전하게 처리할 수 있다.
최대 쓰레드를 너무 낮게 설정하면?
- 동시 요청이 많을 시, 클라이언트는 금방 응답 지연, 서버 리소스가 여유롭다 → 비효율적
최대 쓰레드를 너무 높게 설정하면?
- 동시 요청이 많을 시 리소스 임계점 초과로 서버 다운
적정 숫자 - 성능 테스트
- 툴: nGrinder, 아파치 ab, 제이미터

자바 웹 기술 역사

서블릿
- HTML 생성이 어려움
JSP
- HTML 생성은 편리하지만, 비즈니스 조직까지 너무 많은 역할 담당
서블릿, JSP 조합 MVC 패턴 사용
- 모델, 뷰, 컨트롤러로 역할 나누어 개발
MVC 프레임워크 춘추 전국 시대 - 2000년대 초 ~ 2010년 초
애노테이션 기반의 스프링 MVC 등장
- @Controller
스프링 부트의 등장
- 스프링 부트는 서버를 내장
- 과거에는 서버에 WAS를 직접 설치하고, 소스는 War파일을 만들어서 설치한 WAS에 배포
- 스프링 부트는 빌드 결과(Jar)에 WAS 서버 포함 → 빌드 배포 단순화
스프링 웹 기술의 분화
- Web Servlet - Spring MVC
  - 서블릿 기술 사용 O
- Web Reactive - Spring WebFlux
  - 특징
    - 비동기 넌 블러킹 처리
    - 최소 쓰레드로 최대 성능 - 쓰레드 컨텍스트 스위칭 비용 효율화
    - 함수형 스타일로 개발 - 동시처리 코드 효율화
    - 서블릿 기술 사용 X

자바 뷰 템플릿 역사

JSP
- 속도 느림, 기능 부족
프리마커, Velocity (벨로시티)
- 속도 문제 해결, 다양한 기능
타임리프(Thymeleaf)
- 내추럴 템플릿: HTML의 모양을 유지하면서 뷰 템플릿 적용 가능
- 스프링 MVC와 강력한 기능 통합, 성능은 프리마커, 벨로시티가 더 빠름

✔️ 서블릿

서블릿 기본 설정

ServletComponentScan
- 스프링 부트는 해당 Annotation을 통해서블릿을 직접 등록할 수 있도록 한다
@WebServlet 서블릿 애노테이션
- name: 서블릿 이름
- urlPatterns: URL 매핑
HTTP요청을 통해 매핑된 URL이 호출되면 서블릿 컨테이너는 다음 메서드를 호출한다.
- protected void service(HttpsServletRequest request, HttpServletResponse response)
- 단축키 : ctrl + o

HTTP요청 메시지 로그로 확인하기

Application.properties
- logging.level.org.apache.coyote.http11=debug

HttpServletRequest

기능

임시 저장소 기능
- 해당 HTTP 요청이 시작부터 끝날 때까지 유지되는 임시 저장소 기능
  - 저장: request.setAttribute(name, value)
  - 조회: request.getAttribute(name)
세션 관리 기능
- request.getSession(create: true)

조회 코드

//http://localhost:8080/request-header?username=hello
@WebServlet(name = "requestHeaderServlet", urlPatterns = "/request-header")
public class RequestHeaderServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        printStartLine(request);
        printHeaders(request);
        printHeaderUtils(request);
        printEtc(request);
        response.getWriter().write("ok");
    }

    //start line 정보
    private void printStartLine(HttpServletRequest request) {
        System.out.println("--- REQUEST-LINE - start ---");
        System.out.println("request.getMethod() = " + request.getMethod()); //GET
        System.out.println("request.getProtocol() = " + request.getProtocol()); //HTTP / 1.1
        System.out.println("request.getScheme() = " + request.getScheme()); //http
        // http://localhost:8080/request-header
        System.out.println("request.getRequestURL() = " + request.getRequestURL());
        // /request-header
        System.out.println("request.getRequestURI() = " + request.getRequestURI());
        //username=hi
        System.out.println("request.getQueryString() = " +
                request.getQueryString());
        System.out.println("request.isSecure() = " + request.isSecure()); //https 사용 유무
        System.out.println("--- REQUEST-LINE - end ---");
        System.out.println();
    }

    //Header 편리한 조회
    private void printHeaderUtils(HttpServletRequest request) {
        System.out.println("--- Header 편의 조회 start ---");
        System.out.println("[Host 편의 조회]");
        System.out.println("request.getServerName() = " + request.getServerName()); //Host 헤더
        System.out.println("request.getServerPort() = " + request.getServerPort()); //Host 헤더
        System.out.println();
        System.out.println("[Accept-Language 편의 조회]");
        request.getLocales().asIterator().forEachRemaining(locale -> System.out.println("locale = " + locale));
        System.out.println("request.getLocale() = " + request.getLocale());
        System.out.println();
        System.out.println("[cookie 편의 조회]");
        if (request.getCookies() != null) {
            for (Cookie cookie : request.getCookies()) {
                System.out.println(cookie.getName() + ": " + cookie.getValue());
            }
        }
        System.out.println();
        System.out.println("[Content 편의 조회]");
        System.out.println("request.getContentType() = " +
                request.getContentType());
        System.out.println("request.getContentLength() = " +
                request.getContentLength());
        System.out.println("request.getCharacterEncoding() = " +
                request.getCharacterEncoding());
        System.out.println("--- Header 편의 조회 end ---");
        System.out.println();
    }

    //Header 모든 정보
    private void printHeaders(HttpServletRequest request) {
        System.out.println("--- Headers - start ---");
        /*
         Enumeration<String> headerNames = request.getHeaderNames();
         while (headerNames.hasMoreElements()) {
         String headerName = headerNames.nextElement();
         System.out.println(headerName + ": " + request.getHeader(headerName));
         }
        */
        request.getHeaderNames().asIterator()
                .forEachRemaining(headerName -> System.out.println(headerName + ": " + request.getHeader(headerName)));
                        System.out.println("--- Headers - end ---");
        System.out.println();
    }

    //기타 정보
    private void printEtc(HttpServletRequest request) {
        System.out.println("--- 기타 조회 start ---");
        System.out.println("[Remote 정보]");
        System.out.println("request.getRemoteHost() = " +
                request.getRemoteHost()); //
        System.out.println("request.getRemoteAddr() = " +
                request.getRemoteAddr()); //
        System.out.println("request.getRemotePort() = " +
                request.getRemotePort()); //
        System.out.println();
        System.out.println("[Local 정보]");
        System.out.println("request.getLocalName() = " +
                request.getLocalName()); //
        System.out.println("request.getLocalAddr() = " +
                request.getLocalAddr()); //
        System.out.println("request.getLocalPort() = " +
                request.getLocalPort()); //
        System.out.println("--- 기타 조회 end ---");
        System.out.println();
    }
    }

HTTP 요청 메시지 바디 조회

Get - 쿼리 파라미터

getParameter 코드

@WebServlet(name = "requestParamServlet", urlPatterns = "/request-param")
public class RequestParamServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("[전체 파라미터 조회] - start");
        request.getParameterNames().asIterator()
                .forEachRemaining(paramName -> System.out.println(paramName + "=" + request.getParameter(paramName)));
        System.out.println();

        System.out.println("[단일 파라미터 조회]");
        String username = request.getParameter("username");
        String age = request.getParameter("age");
        System.out.println("age = " + age);
        System.out.println("username = " + username);
        System.out.println();

        System.out.println("[이름이 같은 복수 파라미터 조회]");
        String[] usernames = request.getParameterValues("username");
        for (String name : usernames) {
            System.out.println("username = " + name);
        }

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

    }
}

GET URL 쿼리 파라미터 형식은 http 메시지 바디를 사용하지 않기 때문에 content-type이 없다.

Post - HTML Form
- content-type: application/x-www-form-urlencoded
- message body: username=hello&age=20
- request.getParameter() 는 GET 쿼리 파라미터 형식도 지원하고 POST HTML Form 형식도 지원한다.

HTTP API - MessageBody → Postman 테스트

JSON 형식 전송
- contenxt-type: application/json
- message body: {”username”:”hello”, “age”:”20}

코드

@WebServlet(name= "requestBodyJsonServlet", urlPatterns = "/request-body-json")
public class RequestBodyJsonServlet extends HttpServlet {
    
    private ObjectMapper objectMapper = new ObjectMapper();

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletInputStream inputStream = req.getInputStream();
        String messageBody = StreamUtils.copyToString(inputStream, StandardCharsets.UTF_8);

        System.out.println("messageBody = " + messageBody);

        HelloData helloData = objectMapper.readValue(messageBody, HelloData.class);

        System.out.println("helloData.getUsername() = " + helloData.getUsername());
        System.out.println("helloData.getAge() = " + helloData.getAge());
    }
}

req.getInputStream()을 사용해서 인코딩된 바디 메시지를 받아서 StreamUtils 를 통해 디코딩한 바디 메시지를 저장할 수 있다.
JSON 결과를 파싱해서 사용할 수 있는 자바 객체로 변환하려면 먼저 자바 객체 형식(HelloData.class)을 먼저 선언해준다
그 후 스프링 부트로 Spring MVC를 선택하면 기본으로 제공하는 Jackson (ObjectMapper)이라는 JSON 변환 라이브러리를 사용한다.

HttpServletResponse

코드

@WebServlet(name = "responseHeaderServlet", urlPatterns = "/response-header")
public class ResponseHeaderServlet extends HttpServlet {

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //[Status-line]
        resp.setStatus(HttpServletResponse.SC_OK);

        //[response-headers]
        resp.setHeader("Content-Type", "text/plain");
        resp.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
        resp.setHeader("Pragma", "no-cache");
        resp.setHeader("my-header", "hello");

        //[Header 편의 메서드]
        content(resp);
        cookie(resp);
        redirect(resp);

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

    private void content(HttpServletResponse response) {
        //Content-Type: text/plain;charset=utf-8
        //Content-Length: 2
        //response.setHeader("Content-Type", "text/plain;charset=utf-8");
        response.setContentType("text/plain");
        response.setCharacterEncoding("utf-8");
        //response.setContentLength(2); //(생략시 자동 생성)
    }

    private void cookie(HttpServletResponse response) {
        //Set-Cookie: myCookie=good; Max-Age=600;
        //response.setHeader("Set-Cookie", "myCookie=good; Max-Age=600");
        Cookie cookie = new Cookie("myCookie", "good");
        cookie.setMaxAge(600); //600초
        response.addCookie(cookie);
    }

    private void redirect(HttpServletResponse response) throws IOException {
        //Status Code 302
        //Location: /basic/hello-form.html
        //response.setStatus(HttpServletResponse.SC_FOUND); //302
        //response.setHeader("Location", "/basic/hello-form.html");
        response.sendRedirect("/basic/hello-form.html");
    }
}

HTTP 응답 메시지 바디 조회

HTML 응답

@WebServlet(name = "responseBodyHtmlServlet", urlPatterns = "/response-html")
public class ResponseBodyHtmlServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //Content-Type: text/html;charset=utf-8
        resp.setContentType("text/html");
        resp.setCharacterEncoding("utf-8");

        PrintWriter writer = resp.getWriter();
        writer.println("<html>");
        writer.println("<body>");
        writer.println(" <div>안녕?</div>");
        writer.println("</body>");
        writer.println("</html>");
    }

HTTP API JSON 응답

@WebServlet(name = "responseJsonServlet", urlPatterns = "/response-json")
public class ResponseJsonServlet extends HttpServlet {

    ObjectMapper objectMapper = new ObjectMapper();

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //Content-Type: application/json
        resp.setContentType("application/json");
        resp.setCharacterEncoding("utf-8");

        HelloData helloData = new HelloData();
        helloData.setUsername("kim");
        helloData.setAge(20);

        //{"username":"kim", "age":"20}
        String s = objectMapper.writeValueAsString(helloData);
        resp.getWriter().write(s);
    }
}

✔️ 서블릿, JSP, MVC

각각 서블릿, JSP, MVC(서블릿 + JSP)를 사용해서 회원가입 서비스를 만든다.

MVC 패턴

회원 등록 폼 - 컨트롤러

@WebServlet(name = "mvcMemberFormServlet", urlPatterns = "/servlet-mvc/members/new-form")
public class MvcMemberFormServlet extends HttpServlet {
    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String viewPath = "/WEB-INF/views/new-form.jsp";
        RequestDispatcher dispatcher = req.getRequestDispatcher(viewPath);
        dispatcher.forward(req, resp);
    }
}

WEB/INF
- 이 경로안에 JSP가 있으면 외부에서 직접 JSP를 호출할 수 없다.
- 서버 내부에서 호출
Redirect vs Forward
- 리다이렉트는 클라이언트에 응답이 나갔다가 클라이언트가 Redirect 경로로 다시 요청한다. 클라이언트가 인지 가능
- 포워드는 서버 내부에서 일어나는 호출이기 때문에 클라이언트 인지 불가능

회원 저장 - 컨트롤러

@WebServlet(name = "mvcMemberSaveServlet", urlPatterns = "/servlet-mvc/members/ save")
        public class MvcMemberSaveServlet extends HttpServlet {
        private MemberRepository memberRepository = MemberRepository.getInstance();
        
        @Override
        protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
         
            String username = request.getParameter("username");
            int age = Integer.parseInt(request.getParameter("age"));
            Member member = new Member(username, age);
            System.out.println("member = " + member);
            memberRepository.save(member);
         
            //Model 에 데이터를 보관한다.
            request.setAttribute("member", member);
            String viewPath = "/WEB-INF/views/save-result.jsp";
            RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
            dispatcher.forward(request, response);
            }
         }

request.setAttribute()
- request 객체에 데이터를 보관해서 뷰에 전달할 수 있다.

MVC 컨트롤러의 단점

ViewPath의 중복
Forward 명령어의 중복
공통 처리가 어렵다. (공통으로 처리할 문제들을 메서드로 묶어서 처리하기가 어렵다.)

✔️ MVC 프레임워크 만들기

Front Controller 특징

프론트 컨트롤러 서블릿 하나로 클라이언트의 요청을 받음
공통 처리 가능
프론트 컨트롤러를 제외한 나머지 컨트롤러는 서블릿을 사용하지 않아도 된다.

Front Controller 도입 - V1

기존 상태

모든 컨트롤러에서 WebServlet Annotation을 사용해서 URL 매핑

V1

각 로직이 들어갈 컨트롤러들의 인터페이스를 만들어 각 컨트롤러가 해당 인터페이스를 상속받을 수 있게 해서 일관성을 높였다.
프론트 컨트롤러를 두어 URL 매핑을 해주었다.
- 해쉬맵에 Key(url), value(controller instance) 형태로 저장해두고
- url을 getRequestURI를 통해 받아와 해쉬맵에서 조회한다.
- 만약 일치하는 Key가 없다면 404 Error 있다면 해당 컨트롤러 호출

V2

MyView라는 부모 클래스를 만들어서 각 컨트롤러가 이 클래스를 반환하게 만들었다.
FrontController에서 이 클래스의 인스턴스를 받아 render 메서드를 통해 forward한다.

V3

서블릿 종속성 제거

FrontController를 제외한 각 컨트롤러는 서블릿을 사용할 필요가 없다.
request 객체 대신 Map 형태로 정보를 받고 Request 반환 값 대신 Model을 만들어 반환한다.
구현 코드가 단순해지고 테스트하기가 쉽다.

뷰 이름 중복 제거

ViewResolver 메서드를 사용해 뷰 이름의 중복된 부분을 제거한다.
ModelView를 통해 뷰의 논리 이름을 전달하고 FrontController에서 변환하여 MyView 객체에 전달한다.

V4

기존 구조에서 모델을 파라미터로 넘기고, 컨트롤러에서 뷰의 논리 이름을 반환한다.
ModelView 클래스를 사용하지 않는다.

V5

✔️ 스프링 MVC

스프링 MVC 전체 구조

DispacherServlet 서블릿 등록

DispacherServlet 은 HttpServlet 을 상속받아서 사용하고 서블릿으로 동작
- 서블릿이 호출되면 HttpServlet이 제공하는 service()가 호출된다.
스프링 부트는 DispacherServlet 을 자동으로 등록하면서 모든 경로(urlPatterns=”/”)에 대해서 매핑 한다.

Spring MVC 동작 순서

Handler 조회
Handler Adapter 조회
Handler Adapter 실행
Handler 실행
ModelAndView 반환
ViewResolver 호출
View 반환
View 랜더링

주요 인터페이스

Handler Mapping
Handler Adapter
View Resolver
View

핸들러 매핑과 핸들러 어댑터

스프링 부트가 자동 등록하는 핸들러 매핑과 핸들러 어댑터

HandlerMapping
- 0 = RequestMappingHandlerMapping: 애노테이션 기반의 컨트롤러인 @RequestMapping 에서 사용
- 1 = BeanNameUrlHandlerMapping: 스프링 빈의 이름으로 핸들러를 찾는다.
Handler Adapter
- 0 = RequestMappingHandlerAdapter: @RequestMapping 어댑터
- 1 = HttpRequestHandlerAdapter : HttpRequestHandler 어댑터
- 2 = SimpleControllerHandlerAdapter: Contoller 인터페이스 어댑터(Annotation X)

HandleRequest - Old Controller 호출 과정

@Component("/springmvc/old-controller")
public class OldController implements Controller {
	 @Override
	 public ModelAndView handleRequest(HttpServletRequest request,
	 HttpServletResponse response) throws Exception {
	 System.out.println("OldController.handleRequest");
	 return null;
	 }
}

핸들러 매핑으로 핸들러 조회
1. BeanNameUrlHandlerMapping 을 통해 매핑
2. OldController 반환
핸들러 어댑터 조회
핸들러 어댑터 실행
1. SimpleControllerHandlerAdapter 를 실행하면서 핸들러 정보도 함께 넘겨준다.
2. SimpleControllerHandlerAdapter 는 핸들러인 OldController 를 내부에서 실행하고 그 결과로 ModelAndView를 반환한다.

뷰 리졸버

스프링 부트가 자주 등록하는 뷰 리졸버

1 = BeanNameViewResolver: 빈 이름으로 뷰를 찾아서 반환
2 = InternalResourceViewResolver: JSP를 처리할 수 있는 뷰를 반환
- 스프링 부트는 InternalResourceViewResolver 라는 뷰 리졸버를 자동으로 등록한다
- 이 때 [application.properties](http://application.properties) 에 등록한 spring.mvc.view.prefix, spring.mvc.view.suffix 설정 정보를 사용해서 등록한다

MVC 적용

`@Controller`

스프링이 자동으로 스프링 빈으로 등록한다.
스프링 MVC에서 애노테이션 기반 컨트롤러로 인식한다.

`@RequestMapping`

요청 정보 매핑
애노테이션 기반 작동, 해당 URL 호출 시 이 메서드가 호출된다.

`@GetMapping`, `@PostMapping`

@GetMapping = @RequestMapping(method=RequestMethod.Get

✔️ 스프링 MVC 기본기능

로깅, RestController

SLF4J라는 인터페이스를 쓰고 구현체로 Logback을 사용한다.

선언 방법

private Logger log = LoggerFactory.getLogger(getClass());
@Slf4j Annotation 사용

로그 정보

포멧
- 시간, 로그 레벨, 프로세스ID, 쓰레드 명, 클래스명, 로그 메시지
로그 레벨
- TRACE > DEBUG > INFO > WARN > ERROR
- 개발 서버는 DEBUG
- 운영 서버는 INFO
로그 레벨 수정 방법
- [application.properties](http://application.properties) - logging.level.hello,springmvc=debug
올바른 로그 사용법
- log.debug("data=" + data) X , log.debug("data={}, data) O
- 첫번째 방법으로 진행 시 로그 출력 레벨을 INFO로 설정해도 문자 더하기 연산이 발생한다.
장점
- 쓰레드 정보, 클래스 이름과 같은 부가정보를 함께 볼 수 있고 출력 모양 조정 가능
- 로그 레벨 조절을 통해 로그 출력을 상황에 맞게 조절할 수 있다.
- 시스템 아웃 콘솔에만 출력하는 것이 아니라, 파일이나 네트워크 등, 로그를 별도의 위치에 남길 수 있다.
- 성능이 System.out보다 좋다.

@RestController

@Controller는 반환 값이 String이면 뷰 이름으로 인식되어 뷰를 찾고 뷰가 랜더링된다.
@RestController는 반환 값으로 뷰를 찾는 것이 아니라 HTTP 메시지 바디에 바로 입력한다.

요청 매핑

		@RequestMapping("/hello-basic")
    public String helloBasic(){
        log.info("helloBasic");
        return "ok";
    }

    /**
     * method 특정 HTTP 메서드 요청만 허용
     * GET, HEAD, POST, PUT, PATCH, DELETE
     */
    @RequestMapping(value = "/mapping-get-v1", method = RequestMethod.GET)
    public String mappingGetV1() {
        log.info("mappingGetV1");
        return "ok";
    }

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

    /**
     * PathVariable 사용
     * 변수명이 같으면 생략 가능
     * @PathVariable("userId") String userId -> @PathVariable 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"}
     */
    @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";
    }

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

    /**
     * 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 요청 - 기본, 헤더 조회

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

HttpServletResponse
HttpMethod : HTTP 메서드를 조회한다.
Locale : Locale 정보를 조회한다.
@RequestHeader MultiValueMap<String, String> headerMap
- 모든 HTTP 헤더를 MultiValueMap 형식으로 조회한다.
@RequestHeader("host") String host
- 특정 HTTP 헤더를 조회한다.
@CookieValue(value = "myCookie", required = false) String cookie
- 특정 쿠키를 조회한다.
- 속성
  - 필수 값 여부: required
  - 기본 값: defaultValue

HTTP 요청 파라미터 - 쿼리 파라미터, ModelAttribute

클라이언트에서 서버로 요청 데이터를 전달 할 때 사용되는 방법

GET - 쿼리 파라미터
1. /url?username=hello&age=20
POST - HTML Form
1. content-type: application/x-www-form-urlencoded
2. 메시지 바디에 쿼리 파라미터 형식으로 전달 username=hello&age=20
HTTP message body에 데이터를 직접 담아서 요청
1. 주로 JSON 사용

※ 1번과 2번은 Parameter 조회, 3번은 Body 조회

Prameter 조회 방법

request.getParameter()
@RequestParam
- 변수명과 Parameter Key를 같은 이름으로 설정 시 Key 값 생략가능
- String, int, Integer 등의 단순 타입이면 @RequestParam 도 생략 가능
- 기본값이 @RequestParam(required=true)
- DefaultValue 설정 가능
- Map으로 조회
  - @RequestParam Map<String, Object> paramMap

@ModelAttribute

실제 개발을 하면 파라미터를 받아서 필요한 객체를 만들고 그 객체에 값을 넣어주어야 한다.

ModelAttribute를 사용하지 않을 경우

@RequestParam String username;
@RequestParam int age;
HelloData data = new HelloData();
data.setUsername(username);
data.setAge(age);

사용할 경우

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

동작원리
- HelloData 객체를 생성한다.
- HelloData 객체의 포로퍼티를 찾아 setter를 호출해서 파라미터의 값을 바인딩한다.
  - ex) 파라미터 이름이 username이면 setUsername() 메서드를 찾아서 호출

HTTP 요청 메시지 바디

Text 형식

코드

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

    @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) throws IOException{
        String messageBody = httpEntity.getBody();
        log.info("messageBody={}", messageBody);
        return new HttpEntity<>("ok");
    }

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

HttpEntity : Http header, body 정보를 편리하게 조회
- 메시지 바디 정보를 직접 조회
- 응답에도 사용 가능
RequestEntity
ResponseEntity
- HTTP 상태 코드 설정 가능

스프링MVC 내부에서 HTTP 메시지 바디를 읽어서 문자나 객체로 변환해서 전달해주는데, 이때 HTTP 메시지 컨버터라는 기능을 사용한다.

@RequestBody

메시지 바디를 가장 편하게 조회할 수 있는 Annotation
- @RequestBody String messageBody

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

        HelloData data = objectMapper.readValue(messageBody, HelloData.class);
        log.info("username={}, age ={}", data.getUsername(), data.getAge());

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

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

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

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

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

ObjectMapper : Json 데이터를 자바 객체로 변환할 때 사용

@RequestBody

@RequestBody HelloData data 다음과 같은 형식으로 선언 시 자동으로 data에 메시지 바디가 바인딩된다.
- JSON 응답 → HTTP 메시지 컨버터 → 객체
생략 불가능, 생략 시 ModelAttribute로 인식

@ReponseBody

리턴값으로 바디 메시지 사용 가능
객체 리턴 가능
- 객체 → HTTP 메시지 컨버터 → JSON 응답

HTTP 응답

정적 리소스

스프링 부트는 클래스 패스의 다음 디렉토리에 있는 정적 리소스를 제공한다
/static, /public, /resources. /META-INF/resources

뷰 템플릿

경로 : src/main/resources/templetes

뷰 템플릿 호출 컨트롤러 코드

@Controller
public class ResponseViewController {

    @RequestMapping("/response-view-v1")
    public ModelAndView responseView1(){
        ModelAndView mv = new ModelAndView("response/hello")
                .addObject("data", "hello!");
        return mv;
    }
    @RequestMapping("/response-view-v2")
    public String responseView2(Model model){
        model.addAttribute("data", "hello!");
        return "response/hello";
    }

    @RequestMapping("/response/hello")
    public void responseView3(Model model){
        model.addAttribute("data", "hello!");
    }
}

Thymeleaf <appication.properties> 기본값

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

HTTP 메시지

코드

@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(){
        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("oh");
        helloData.setAge(20);
        return new ResponseEntity<>(helloData, HttpStatus.CREATED);
    }
    
    @ResponseStatus(HttpStatus.OK)
    @ResponseBody
    @GetMapping("/response-body-json-v2")
    public HelloData responseBodyJsonV2(){
        HelloData helloData = new HelloData();
        helloData.setUsername("oh");
        helloData.setAge(20);
        return helloData;
    }
}

responseBodyV1
- 서블릿을 직접 다룰 때 처럼 HttpServletResponse 객체를 통해서 HTTP 메시지 바디에 직접 ok 응답 메시지를 전달한다.
- response.getWriter().write("ok")
responseBodyV2
- ResponseEntity 엔티티는 HttpEntity 를 상속 받았는데, HttpEntity는 HTTP 메시지의 헤더, 바디 정보를 가지고 있다. ResponseEntity 는 여기에 더해서 HTTP 응답 코드를 설정할 수 있다.
- HttpStatus.CREATED 로 변경하면 201 응답이 나가는 것을 확인할 수 있다.
responseBodyV3
- @ResponseBody 를 사용하면 view를 사용하지 않고, HTTP 메시지 컨버터를 통해서 HTTP 메시지를 직접 입력할 수 있다. ResponseEntity 도 동일한 방식으로 동작한다.
responseBodyJsonV1
- ResponseEntity 를 반환한다. HTTP 메시지 컨버터를 통해서 JSON 형식으로 변환되어서 반환된다.
responseBodyJsonV2
- ResponseEntity 는 HTTP 응답 코드를 설정할 수 있는데, @ResponseBody 를 사용하면 이런 것을 설정하기 까다롭다.
- @ResponseStatus(HttpStatus.OK) 애노테이션을 사용하면 응답 코드도 설정할 수 있다.
  물론 애노테이션이기 때문에 응답 코드를 동적으로 변경할 수는 없다. 프로그램 조건에 따라서 동적으로 변경하려면 ResponseEntity 를 사용하면 된다.

RestController

@Controller + @ResponseBody
클래스 레벨에 두면 전체 메서드에 적용

HTTP 메시지 컨버터

0 = ByteArrayHttpMessageConverter

바이트 데이터를 처리한다 data[]
클래스 타입: data[], 미디어 타입: */*

1 = StringHttpMessageConverter

String 문자로 데이터를 처리한다.
클래스 타입: String, 미디어 타입: */*

2 = MappingJackson2HttpMessageConverter

클래스 타입: 객체 또는 HashMap
미디어 타입: application/json 관련

content-type: application/json                                                 EX
@RequestMapping
void hello(@RequestBody String data) {}              -> StringHttpMessageConverter

HTTP 요청 데이터 읽기

메시지 컨버터가 canRead() 를 호출하고 대상 클래스 타입을 지원하는지 확인한 후 HTTP 요청의 Content-Type 미디어 타입을 지원하는지 확인한다.
조건을 만족하면 read() 를 호출해서 객체를 생성하고 반환한다.

HTTP 응답 데이터 읽기

메시지 컨버터가 canWrite() 를 호출하고 대상 클래스 타입을 지원하는지 확인한 후 HTTP 응답의 Accept 미디어 타입을 지원하는지 확인한다.
조건을 만족하면 write() 를 호출해서 HTTP 메시지 바디에 데이터를 생성한다.

요청 매핑 핸들러 구조

ArgumentResolver (HandlerMethodArgumentResolver)

애노테이션 기반의 컨트롤러는 매우 다양한 파라미터를 사용할 수 있는데 이를 유연하게 처리해주는게 ArgumentResolver이다
- HttpServletRequest, Model, @RequestParam, @ModelAttribute, HttpEntity

ReturnValueHandler (HandlerMethodReturnValueHandler)

요청의 경우 @RequestBody와 @HttpEntity를 처리하는 ArgumentResolver 가 있는데 이는 바디의 메시지를 받아와 처리해야하기 때문에 이 ArgumentResolver 들이 HTTP 메시지 컨버터를 사용해서 필요한 객체를 생성하는 것이다.

응답의 경우 @ReponseBody와 @HttpEntity를 처리하는 ReturnValueHandler 가 있는데 여기서 HTTP 메시지 컨버터를 호출해서 응답 결과를 만든다.

기능 확장

스프링이 필요한 대부분의 기능을 제공하지만

기능확장을 위해서는 WebMvcConfigurer 를 상속 받아서 스프링 빈으로 등록하면 된다.

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

✔️ 그 외

@ModelAttribute

@ModelAttribute("name") 다음과 같이 선언 시
- model.addAttribute(”name”, 객체) 자동 실행
“name” 생략 시 첫 글자를 소문자로 바꾼 클래스명이 name으로 자동 설정
data 타입이 객체나 Map일 경우 @ModelAttribute 생략가능

PRG(Post-Redirect-Get)

그림과 같이 Redirect를 사용하지 않고 View를 반환값으로 띄워준 상태에서 새로고침을 하면 PostRequest가 계속해서 실행된다.

→ 이를 방지하기 위해 Redirect를 통해 Get Method를 호출해준다.

RedirectAttributes

@PostMapping("/add")
    public String addItem(@ModelAttribute Item item, RedirectAttributes redirectAttributes){
        Item savedItem = itemRepository.save(item);
        redirectAttributes.addAttribute("itemId", savedItem.getId());
        redirectAttributes.addAttribute("status", true);
        // model.addAttribute("item", item);
        return "redirect:/basic/items/{itemId}";
    }

addAttribute한 값이 URL에서 사용되지 않는 나머지 값들은 Query값으로 들어간다.
redirectAttribute를 사용하면 인코딩을 자동으로 해준다.

yeop

이전 포스트

🌱 스프링 원리 (기본)

다음 포스트

🌱 스프링 MVC 1

✔️ 웹 애플리케이션의 이해

웹 서버, 웹 애플리케이션 서버

웹 서버

웹 애플리케이션 서버

서블릿

동시 요청 - 멀티 쓰레드

쓰레드

쓰레드 풀

자바 웹 기술 역사

자바 웹 기술 역사

자바 뷰 템플릿 역사

✔️ 서블릿

서블릿 기본 설정

HTTP요청 메시지 로그로 확인하기

HttpServletRequest

기능

기본 사용법, Header 조회

HTTP 요청 메시지 바디 조회

HttpServletResponse

기본 사용법, Header 조회

HTTP 응답 메시지 바디 조회

✔️ 서블릿, JSP, MVC

MVC 패턴

MVC 컨트롤러의 단점

✔️ MVC 프레임워크 만들기

Front Controller 특징

Front Controller 도입 - V1

기존 상태

V1

V2

V2

V3

서블릿 종속성 제거

뷰 이름 중복 제거

V4

V5

✔️ 스프링 MVC

스프링 MVC 전체 구조

DispacherServlet 서블릿 등록

Spring MVC 동작 순서

주요 인터페이스

핸들러 매핑과 핸들러 어댑터

스프링 부트가 자동 등록하는 핸들러 매핑과 핸들러 어댑터

HandleRequest - Old Controller 호출 과정

뷰 리졸버

스프링 부트가 자주 등록하는 뷰 리졸버

MVC 적용

@Controller

@RequestMapping

@GetMapping, @PostMapping

✔️ 스프링 MVC 기본기능

로깅, RestController

선언 방법

로그 정보

@RestController

요청 매핑

HTTP 요청 - 기본, 헤더 조회

HTTP 요청 파라미터 - 쿼리 파라미터, ModelAttribute

클라이언트에서 서버로 요청 데이터를 전달 할 때 사용되는 방법

Prameter 조회 방법

@ModelAttribute

HTTP 요청 메시지 바디

Text 형식

@RequestBody

Json 형식

@RequestBody

@ReponseBody

HTTP 응답

정적 리소스

뷰 템플릿

HTTP 메시지

RestController

HTTP 메시지 컨버터

0 = ByteArrayHttpMessageConverter

1 = StringHttpMessageConverter

2 = MappingJackson2HttpMessageConverter

HTTP 요청 데이터 읽기

HTTP 응답 데이터 읽기

요청 매핑 핸들러 구조

`@Controller`

`@RequestMapping`

`@GetMapping`, `@PostMapping`