인프런 강의 34일차.

 - 스프링 MVC 1편 - 백엔드 웹 개발 핵심 기술 1 (김영한 강사님)

 - 서블릿, JSP, MVC 패턴

 - 서블릿으로 1차 구현

   -> 서블릿으로 구현했을 때 불편한 점 개선을 위해 JSP로 2차 구현

   -> JSP로도 불편한 점을 개선하기 위해 MVC 패턴으로 3차 구현

3. 스프링 MVC - 구조 이해

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

 - 지금은 전혀 사용하지 않지만, 과거에 주로 사용했던 스프링 제공 컨트롤러로 핸들러 매핑과 어댑터를 이해해보자.

public interface Controller {
    ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse
    response) throws Exception;
}

 - 과거 버전 스프링 컨트롤러

 - 스프링도 처음에는 이런 형태의 컨트롤러를 제공했다.

 - Controller 인터페이스는 @Controller 애노테이션과 전혀 다르다.

package hello.servlet.web.springmvc.old;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

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

 - hello.servlet.web.springmvc.old.OldController

 - @Component : 이 컨트롤러는 /springmvc/old-controller라는 이름의 스프링빈으로 등록되었다.

 - 빈의 이름으로 URL을 매핑할 것이다.(name, url-pattern이 없다)

 - 실행 : http://localhost:8080/springmvc/old-controller

 - 콘솔에 OldController.handleRequest가 출력되면 성공

 - 이 컨트롤러가 호출되려면 다음 2가지가 필요하다.

 - HandlerMapping(핸들러 매핑)

   -> 핸들러 매핑에서 이 컨트롤러를 찾을 수 있어야 한다.

   -> 예) 스프링 빈의 이름(/springmvc/old-controller)으로 핸들러를 찾을 수 있는 핸들러 매핑이 필요하다.

 - HandlerAdapter(핸들러 어댑터)

   -> 핸들러 매핑을 통해서 찾은 핸들러를 실행할 수 있는 핸들러 어댑터가 필요하다.

   -> 예) Controller 인터페이스를 실행할 수 있는 핸들러 어댑터를 찾고 실행해야 한다

 - 스프링 부트가 자동 등록하는 핸들러 매핑과 핸들러 어댑터 샘플 (우선순위에 따라 호출된다)

HandlerMapping

0 = RequestMappingHandlerMapping  : 애노테이션 기반의 컨트롤러인 @RequestMapping에서 사용
1 = BeanNameUrlHandlerMapping : 스프링 빈의 이름으로 핸들러를 찾는다.

HandlerAdapter

0  = RequestMappingHandlerAdapter  : 애노테이션 기반의 컨트롤러인 @RequestMapping에서 사용
1  = HttpRequestHandlerAdapter  : HttpRequestHandler 처리 
2  = SimpleControllerHandlerAdapter : Controller 인터페이스 (애노테이션 X, 과거에 사용)

핸들러 매핑도, 핸들러 어댑터도 모두 순서대로 찾고 만약 없으면 다음 순서로 넘어간다.

 - 1. 핸들러 매핑으로 핸들러 조회

   1. HandlerMapping 을 순서대로 실행해서 핸들러를 찾는다.

   2. 이 경우 빈 이름으로 핸들러를 찾아야 하기 때문에 이름 그대로 빈 이름으로 핸들러를 찾아주는 

      BeanNameUrlHandlerMapping 가 실행에 성공하고 핸들러인 OldController를 반환한다.

 - 2. 핸들러 어댑터 조회

   1. HandlerAdapter의 supports()를 순서대로 호출한다.

   2. SimpleControllerHandlerAdapter 가 Controller 인터페이스를 지원하므로 대상이된다. 

 - 3. 핸들러 어댑터 실행

   1. 디스패처 서블릿이 조회한 SimpleControllerHandlerAdapter를 실행하면서 핸들러 정보도 함께 넘겨준다.

   2. SimpleControllerHandlerAdapter 는 핸들러인 OldController를 내부에서 실행하고 그 결과를 반환한다. 

 - OldController 핸들러 매핑, 어댑터 

 - OldController를 실행하면서 사용된 객체는 다음과같다.

• HandlerMapping = BeanNameUrlHandlerMapping (0번째는 없었고, 1번째가 선택됨)
• HandlerAdapter = SimpleControllerHandlerAdapter (0, 1번째는 없었고, 2번째가 선택됨)

 3.7 HttpRequestHandler

 - 핸들러 매핑과, 어댑터를 더 잘 이해하기 위해 Controller 인터페이스가 아닌 다른 핸들러를 비교해보자..

 - HttpRequestHandler 핸들러(컨트롤러)는 서블릿과 가장 유사한 형태의 핸들러이다.

public interface HttpRequestHandler {
    void handleRequest(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException;
}

 - HttpRequestHandler

package hello.servlet.web.springmvc.old;

import org.springframework.stereotype.Component;
import org.springframework.web.HttpRequestHandler;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component("/springmvc/request-handler")
public class MyHttpRequestHandler implements HttpRequestHandler {
    @Override
    public void handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("MyHttpRequestHandler.handleRequest");
    }
}

 - hello.servlet.web.springmvc.old.MyHttpRequestHandler

 - 실행 : http://localhost:8080/springmvc/request-handler

 - 웹 브라우저에 빈 화면이 나오고, 콘솔에 MyHttpRequestHandler.handleRequest가 출력되면 성공이다.

 - 1. 핸들러 매핑으로 핸들러 조회

  1. HandlerMapping 을 순서대로 실행해서 핸들러를 찾는다.

  2. 이 경우 빈 이름으로 핸들러를 찾아야 하기 때문에 이름 그대로 빈 이름으로 핸들러를 찾아주는

     BeanNameUrlHandlerMapping 가 실행에 성공하고 핸들러인 MyHttpRequestHandler를 반환한다.

 - 2. 핸들러 어댑터 조회

  1. HandlerAdapter의 supports()를 순서대로 호출한다.

  2. HttpRequestHandlerAdapter 가 Controller 인터페이스를 지원하므로 대상이된다. 

 - 3. 핸들러 어댑터 실행

  1. 디스패처 서블릿이 조회한 HttpRequestHandlerAdapter 를 실행하면서 핸들러 정보도 함께 넘겨준다.

  2. HttpRequestHandlerAdapter 는 핸들러인 MyHttpRequestHandler를 내부에서 실행하고 그 결과를 반환한다. 

 - MyHttpRequestHandler 핸들러 매핑, 어댑터

 - OldController를 실행하면서 사용된 객체는 다음과같다.

• HandlerMapping = BeanNameUrlHandlerMapping 
• HandlerAdapter = HttpRequestHandlerAdapter 

 3.8 @RequestMapping
 - 가장 우선 순위가 높은 핸들러 매핑과 핸들러 어댑터는 
 - RequestMappingHandlerMapping, RequestMappingHandlerAdapter이다. 
   -> @RequestMapping의 앞글자를 따서 만든 이름인데, 이것이 바로 지금 스프링에서 주로 사용하는 애노테이션 기반의 컨트롤러를 지원하는 매핑과 어댑터이다.

   -> 실무에서는 99.9% 이 방식의 컨트롤러를 사용한다. 

인프런 강의 33일차.

 - 스프링 MVC 1편 - 백엔드 웹 개발 핵심 기술 1 (김영한 강사님)

 - 서블릿, JSP, MVC 패턴

 - 서블릿으로 1차 구현

   -> 서블릿으로 구현했을 때 불편한 점 개선을 위해 JSP로 2차 구현

   -> JSP로도 불편한 점을 개선하기 위해 MVC 패턴으로 3차 구현

3. 스프링 MVC - 구조 이해

 3.1 스프링 MVC 전체 구조

 - 직접 만든 MVC 프레임워크 구조와 Spring MVC 구조를 비교해보자

 - 직접 만든 프레임워크 -> 스프링 MVC 비교

 - FrontController -> DispatcherServlet

 - handlerMappingMap -> HandlerMapping

 - MyHandlerAdapter -> HandlerAdapter

 - ModelView -> ModelAndView

 - viewResolver -> ViewResolver

 - MyView -> View

 - DispatcherServlet 구조 살펴보기

   -> org.springframework.web.servlet.DispatcherServlet

   -> 스프링 MVC도 프론트 컨트롤러 패턴으로 구현되어 있다.

   -> 스프링 MVC의 프론트 컨트롤러가 바로 디스패처 서블릿(DispatcherServlet)이다.

   -> 그리고 이 디스패처 서블릿이 바로 스프링 MVC의 핵심이다.

 - DispacherServlet 서블릿 등록

   -> DispacherServlet 도 부모 클래스에서 HttpServlet 을 상속 받아서 사용하고, 서블릿으로 동작한다.

   -> 순서 : DispatcherServlet -> FrameworkServlet -> HttpServletBean -> HttpServlet

   -> 스프링 부트는 DispacherServlet 을 서블릿으로 자동으로 등록하면서 모든 경로( urlPatterns="/" )에 대해서 매핑한다.

   -> 더 자세한 경로가 우선순위가 높다. 그래서 기존에 사용자가 정의해서 등록한 서블릿도 함께 동작한다.

 - 요청 흐름

   -> 서블릿이 호출되면 HttpServlet 이 제공하는 serivce() 가 호출된다.

   -> 스프링 MVC는 DispatcherServlet 의 부모인 FrameworkServlet 에서 service() 를 오버라이드 해두었다.

   -> FrameworkServlet.service() 를 시작으로 여러 메서드가 호출되면서 DispacherServlet.doDispatch() 가 호출된다.

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        HttpServletRequest processedRequest = request;
        HandlerExecutionChain mappedHandler = null;
        ModelAndView mv = null;
        // 1. 핸들러 조회
        mappedHandler = getHandler(processedRequest);
        if (mappedHandler == null) {
            noHandlerFound(processedRequest, response);
            return;
        }
        // 2. 핸들러 어댑터 조회 - 핸들러를 처리할 수 있는 어댑터
        HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
        // 3. 핸들러 어댑터 실행 -> 4. 핸들러 어댑터를 통해 핸들러 실행 -> 5. ModelAndView 반환
        mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
        processDispatchResult(processedRequest, response, mappedHandler, mv,dispatchException);
    }
    private void processDispatchResult(HttpServletRequest request, HttpServletResponse response, HandlerExecutionChain mappedHandler, ModelAndView mv, Exception exception) throws Exception {
        // 뷰 렌더링 호출
        render(mv, request, response);
    }
    protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {
        View view;
        String viewName = mv.getViewName();
        // 6. 뷰 리졸버를 통해서 뷰 찾기, 7. View 반환
        view = resolveViewName(viewName, mv.getModelInternal(), locale, request);
        // 8. 뷰 렌더링
        view.render(mv.getModelInternal(), request, response);
    }

 - DispacherServlet 의 핵심인 doDispatch() 코드를 분석해보자.

 - 최대한 간단히 설명하기 위해 예외처리, 인터셉터 기능은 제외했다.

 3.2 Spring MVC 구조

 - 동작 순서

 - 1. 핸들러 조회: 핸들러 매핑을 통해 요청 URL에 매핑된 핸들러(컨트롤러)를 조회한다.

 - 2. 핸들러 어댑터 조회: 핸들러를 실행할 수 있는 핸들러 어댑터를 조회한다.

 - 3. 핸들러 어댑터 실행: 핸들러 어댑터를 실행한다.

 - 4. 핸들러 실행: 핸들러 어댑터가 실제 핸들러를 실행한다.

 - 5. ModelAndView 반환: 핸들러 어댑터는 핸들러가 반환하는 정보를 ModelAndView로 변환해서 반환한다.

 - 6. viewResolver 호출: 뷰 리졸버를 찾고 실행한다.

   -> JSP의 경우: InternalResourceViewResolver 가 자동 등록되고, 사용된다.

 - 7. View 반환: 뷰 리졸버는 뷰의 논리 이름을 물리 이름으로 바꾸고, 렌더링 역할을 담당하는 뷰 객체를 반환한다.

   -> JSP의 경우 InternalResourceView(JstlView) 를 반환하는데, 내부에 forward() 로직이 있다.

   -> thymeleaf의 경우 내부에 뷰 렌더링하는 java 코드가 존재한다. (HTML을 resonse 코드에 담아서 반환한다.)

 - 8. 뷰 렌더링: 뷰를 통해서 뷰를 렌더링 한다

 3.3 인터페이스 살펴보기

 - 스프링 MVC의 큰 강점은 DispatcherServlet 코드의 변경 없이, 원하는 기능을 변경하거나 확장할 수 있다는 점이다.

 - 지금까지 설명한 대부분을 확장 가능할 수 있게 인터페이스로 제공한다.

 - 이 인터페이스들만 구현해서 DispatcherServlet 에 등록하면 여러분만의 컨트롤러를 만들 수도 있다.

 3.4 주요 인터페이스 목록

 - 핸들러 매핑: org.springframework.web.servlet.HandlerMapping

 - 핸들러 어댑터: org.springframework.web.servlet.HandlerAdapter

 - 뷰 리졸버: org.springframework.web.servlet.ViewResolver

 - 뷰: org.springframework.web.servlet.View

 3.5 정리

 - 스프링 MVC는 코드 분량도 매우 많고, 복잡해서 내부 구조를 다 파악하는 것은 쉽지 않다.

 - 사실 해당 기능을 직접 확장하거나 나만의 컨트롤러를 만드는 일은 없으므로 걱정하지 않아도 된다.

 - 왜냐하면 스프링 MVC는 전세계 수 많은 개발자들의 요구사항에 맞추어 기능을 계속 확장왔고, 그래서 여러분이 웹 애플리케이션을 만들 때 필요로 하는 대부분의 기능이 이미 다 구현되어 있다.

 - 그래도 이렇게 핵심 동작방식을 알아두어야 향후 문제가 발생했을 때 어떤 부분에서 문제가 발생했는지 쉽게 파악하고, 문제를 해결할 수 있다.

 - 그리고 확장 포인트가 필요할 때, 어떤 부분을 확장해야 할지 감을 잡을 수 있다.

 - 실제 다른 컴포넌트를 제공하거나 기능을 확장하는 부분들은 강의를 진행하면서 조금씩 설명하겠다.

 - 지금은 전체적인 구조가 이렇게 되어 있구나 하고 이해하면 된다.

 - 우리가 지금까지 함께 개발한 MVC 프레임워크와 유사한 구조여서 이해하기 어렵지 않았을 것이다

인프런 강의 29일차.

 - 스프링 MVC 1편 - 백엔드 웹 개발 핵심 기술 1 (김영한 강사님)

 - 서블릿, JSP, MVC 패턴

 - 서블릿으로 1차 구현

   -> 서블릿으로 구현했을 때 불편한 점 개선을 위해 JSP로 2차 구현

   -> JSP로도 불편한 점을 개선하기 위해 MVC 패턴으로 3차 구현

1. MVC 패턴 - 한계

 - MVC 패턴을 적용한 덕분에 컨트롤러의 역할과 뷰를 렌더링하는 역할을 명확하게 구분할 수 있다.

 - 특히 뷰는 화면을 그리는 역할에 충실한 덕분에, 코드가 깔끔하고 직관적이다. 단순하게 모델에서 필요한 데이터를 꺼내고, 화면을 만들면 된다.

 - but, 컨트롤러는 중복도 많고 필요하지 않은 코드도 많다.

 1.1 MVC 컨트롤러의 단점

  - 포워드 중복

  - View로 이동하는 코드가 항상 중복 호출되어야 한다. 물론 이 부분을 공통화해도 되지만, 공통을 항상 호출해야 한다는 점은 매한가지.

//항상 호출되는 코드
RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
dispatcher.forward(request, response);

//View Path 또한 중복으로 세팅하는 부분이 있다. (prefix, suffix)
//prefix: /WEB-INF/views/
//suffix: .jsp
String viewPath = "/WEB-INF/views/members.jsp";

  - 만약 jsp가 아닌 thymeleaf같은 다른 뷰로 변경한다면 전체 코드를 전부 변경해야 동작한다.

  - 그 외에 사용 빈도가 적은 코드도 존재한다. (특히 response는 현재 코드에서는 사용하지 않는다)

    ex) HttpServletRequest request, HttpServletResponse response

         > HttpServletRequest, HttpServletResponse를 사용하는 코드는 테스트 케이스를 작성하기도 어렵다.

  - 공통 처리가 어렵다

    > 컨트롤러 호출 전에 먼저 공통 기능을 처리해야만 해결 가능

    > 프론트 컨트롤러 패턴을 도입해서 공통기능을 먼저 처리하는 형태로 해결 해야하며, 스프링 MVC의 핵심도 바로 이 프론트 컨트롤러에 있다.

2. MVC 프레임워크 만들기

 2.1 프론트 컨트롤러 패턴 소개

 2.2 FrontController 패턴 특징

  - 프론트 컨트롤러 서블릿 하나로 클라이언트의 요청을 받음

  - 프론트 컨트롤러가 요청에 맞는 컨트롤러를 찾아서 호출

  - 입구를 하나로!

  - 공통 처리 가능

  - 프론트 컨트롤러를 제외한 나머지 컨트롤러는 서블릿을 사용하지 않아도 됨

  - 스프링 웹 MVC와 프론트 컨트롤러 스프링 웹 MVC의 핵심도 바로 FrontController

  - 스프링 웹 MVC의 DispatcherServlet이 FrontController 패턴으로 구현되어 있음

2.3 FrontController 도입 - v1

  - 프론트 컨트롤러를 단계적으로 도입해보자.

  - 기존 코드를 최대한 유지하면서 프론트 컨트롤러를 도입하는 것이 목표

package hello.servlet.web.frontcontroller.v1;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public interface ControllerV1 {

    void process(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException;

}

  - web.frontcontroller.v1.ControllerV1.java

  - 서블릿과 비슷한 모양의 컨트롤러 인터페이스를 생성한다. 각 컨트롤러들은 이 인터페이스를 구현한다.

  - 프론트 컨트롤러는 이 인터페이스를 호출해서 구현과 관계없이 로직의 일관성을 가져갈 수 있다.

package hello.servlet.web.frontcontroller.v1.controller;

import hello.servlet.domain.member.MemberRepository;
import hello.servlet.web.frontcontroller.v1.ControllerV1;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class MemberFormControllerV1 implements ControllerV1 {

    private MemberRepository memberRepository = MemberRepository.getInstance();

    @Override
    public void process(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String viewPath = "/WEB-INF/views/members.jsp";
        RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
        dispatcher.forward(request, response);
    }
}

  - web.frontcontroller.v1.controller.MemberFormControllerV1.java

  - 리팩토링 순서는 같은 레벨에서의 구조를 먼저 개선 한 후 문제가 없을 때 세부 로직을 변경하는 형태로 개선한다.

  - v1에서는 구조만 변경하는 것으로 진행(viewPath와 Dispatcher호출은 변경하지 않고, 컨트롤러 호출 형태만 변경)

package hello.servlet.web.frontcontroller.v1.controller;

import hello.servlet.domain.member.Member;
import hello.servlet.domain.member.MemberRepository;
import hello.servlet.web.frontcontroller.v1.ControllerV1;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class MemberSaveControllerV1 implements ControllerV1 {

    private MemberRepository memberRepository = MemberRepository.getInstance();

    @Override
    public void process(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String username = request.getParameter("username");
        int age = Integer.parseInt(request.getParameter("age"));   //request.getParam의 결과는 항상 문자이므로 숫자는 따로 형변환을 해주어야함

        Member member = new Member(username, age);
        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);
    }
}

  - web.frontcontroller.v1.controller.MemberSaveControllerV1.java

package hello.servlet.web.frontcontroller.v1.controller;

import hello.servlet.domain.member.Member;
import hello.servlet.domain.member.MemberRepository;
import hello.servlet.web.frontcontroller.v1.ControllerV1;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;

public class MemberListControllerV1 implements ControllerV1 {

    private MemberRepository memberRepository = MemberRepository.getInstance();

    @Override
    public void process(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        List<Member> members = memberRepository.findAll();

        request.setAttribute("members", members);

        String viewPath = "/WEB-INF/views/members.jsp";
        RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
        dispatcher.forward(request, response);
    }
}

  - web.frontcontroller.v1.controller.MemberListControllerV1.java

package hello.servlet.web.frontcontroller.v1;

import hello.servlet.web.frontcontroller.v1.controller.MemberFormControllerV1;
import hello.servlet.web.frontcontroller.v1.controller.MemberListControllerV1;
import hello.servlet.web.frontcontroller.v1.controller.MemberSaveControllerV1;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;


//v1 하위에 모든 컨트롤러를 호출할 수 있음
@WebServlet(name="frontControllerServletV1", urlPatterns = "/front-controller/v1/*")
public class FrontControllerServletV1 extends HttpServlet {

    private Map<String, ControllerV1> controllerV1Map = new HashMap<>();

    public FrontControllerServletV1() {
        //url과 호출해야하는 컨트롤러를 매핑하여 Map에 저장
        controllerV1Map.put("/front-controller/v1/members/new-form", new MemberFormControllerV1());
        controllerV1Map.put("/front-controller/v1/members/save", new MemberSaveControllerV1());
        controllerV1Map.put("/front-controller/v1/members", new MemberListControllerV1());
    }

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("FrontControllerServletV1.service");

        String requestURI = request.getRequestURI();    //호출되는 URL 주소 얻기
        
        ControllerV1 controllerV1 = controllerV1Map.get(requestURI);    //url 주소에 해당하는 Controller생성
        if(controllerV1 == null){
            //매칭되는 컨트롤러가 없으면 404 에러 리턴
            response.setStatus(HttpServletResponse.SC_NOT_FOUND);
            return;
        }
        
        //매칭되는 컨트롤러를 찾았으면 해당 컨트롤러 호출
        controllerV1.process(request, response);

    }
}

  - web.frontcontroller.v1.FrontControllerServletV1.java

  -  urlPatterns는 v1/*로 선언

  - controllerMap : key는 매핑 URL, value는 호출될 Controller

  - JSP는 이전 MVC에서 사용하던 것을 그대로 사용한다,

2.4 View 분리 - v2

  - 모든 컨트롤러에서 뷰로 이동하는 부분에 중복이 있고, 깔끔하지 않다 (viewPath 및 dispatcher 호출 부분)

  - viewPath를 전담해서 처리하는 MyView 구현

  - 과거에는 컨트롤러에서 jsp를 직접 호출했다면 v2에서는 MyView에서 jsp를 호출

package hello.servlet.web.frontcontroller;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class MyView {

    private String viewPath;

    public MyView(String viewPath) {
        this.viewPath = viewPath;
    }

    public void render(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //MyView를 생성할 때 생성자로 세팅한 viewPath 호출
        RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
        dispatcher.forward(request, response);
    }
}

  - web.frontcontroller.v2.MyView.java

  - viewPath에 따른 forward를 수행하는 소스

package hello.servlet.web.frontcontroller.v2;

import hello.servlet.web.frontcontroller.MyView;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public interface ControllerV2 {

    MyView process(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException;
}

  - web.frontcontroller.v2.ControllerV2.java

  - 이제 각 컨트롤러가 dispatcher.forward()를 직접 생성해서 호출하지 않고 MyView객체를 생성하고 뷰 이름만 넣은 뒤 반환하면 된다,

  - ControllerV1와 ControllerV2를 비교해보면 중복이 제거된 것을 확인할 수 있다.

package hello.servlet.web.frontcontroller.v2.controller;

import hello.servlet.web.frontcontroller.MyView;
import hello.servlet.web.frontcontroller.v2.ControllerV2;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class MemberFormControllerV2 implements ControllerV2 {

    @Override
    public MyView process(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        /*
        MyView myView = new MyView("WEB-INF/views/new-form.jsp");
        return myView;
        위 코드를 아래처럼 한번에 변경하는 단축키 Ctrl + alt + N 혹은 Shift + Ctrl + Alt + T로 호출되는 리팩터링 메뉴에서 '인라인' 검색
        */

        return new MyView("WEB-INF/views/new-form.jsp");
    }
}

  - web.frontcontroller.v2.controller.MemberFormControllerV2.java

package hello.servlet.web.frontcontroller.v2.controller;

import hello.servlet.domain.member.Member;
import hello.servlet.domain.member.MemberRepository;
import hello.servlet.web.frontcontroller.MyView;
import hello.servlet.web.frontcontroller.v2.ControllerV2;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class MemberSaveControllerV2 implements ControllerV2 {

    private MemberRepository memberRepository = MemberRepository.getInstance();

    @Override
    public MyView process(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String username = request.getParameter("username");
        int age = Integer.parseInt(request.getParameter("age"));   //request.getParam의 결과는 항상 문자이므로 숫자는 따로 형변환을 해주어야함

        Member member = new Member(username, age);
        memberRepository.save(member);

        //Model에 데이터 저장
        request.setAttribute("member", member);

        return new MyView("/WEB-INF/views/save-result.jsp");
    }
}

  - web.frontcontroller.v2.controller.MemberSaveControllerV2.java

package hello.servlet.web.frontcontroller.v2.controller;

import hello.servlet.domain.member.Member;
import hello.servlet.domain.member.MemberRepository;
import hello.servlet.web.frontcontroller.MyView;
import hello.servlet.web.frontcontroller.v2.ControllerV2;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;

public class MemberListControllerV2 implements ControllerV2 {

    private MemberRepository memberRepository = MemberRepository.getInstance();

    @Override
    public MyView process(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        List<Member> members = memberRepository.findAll();

        request.setAttribute("members", members);

        return new MyView("/WEB-INF/views/members.jsp");
    }
}

  - web.frontcontroller.v2.controller.MemberListControllerV2.java

package hello.servlet.web.frontcontroller.v2;

import hello.servlet.web.frontcontroller.MyView;
import hello.servlet.web.frontcontroller.v1.ControllerV1;
import hello.servlet.web.frontcontroller.v2.controller.MemberFormControllerV2;
import hello.servlet.web.frontcontroller.v2.controller.MemberListControllerV2;
import hello.servlet.web.frontcontroller.v2.controller.MemberSaveControllerV2;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;


//v1 하위에 모든 컨트롤러를 호출할 수 있음
@WebServlet(name="frontControllerServletV2", urlPatterns = "/front-controller/v2/*")
public class FrontControllerServletV2 extends HttpServlet {

    private Map<String, ControllerV2> controllerV1Map = new HashMap<>();

    public FrontControllerServletV2() {
        //url과 호출해야하는 컨트롤러를 매핑하여 Map에 저장
        controllerV1Map.put("/front-controller/v2/members/new-form", new MemberFormControllerV2());
        controllerV1Map.put("/front-controller/v2/members/save", new MemberSaveControllerV2());
        controllerV1Map.put("/front-controller/v2/members", new MemberListControllerV2());
    }

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("FrontControllerServletV2.service");

        String requestURI = request.getRequestURI();    //호출되는 URL 주소 얻기
        
        ControllerV2 controllerV2 = controllerV1Map.get(requestURI);    //url 주소에 해당하는 Controller생성
        if(controllerV2 == null){
            //매칭되는 컨트롤러가 없으면 404 에러 리턴
            response.setStatus(HttpServletResponse.SC_NOT_FOUND);
            return;
        }
        
        //매칭되는 컨트롤러를 찾았으면 해당 컨트롤러 호출
        MyView view = controllerV2.process(request, response);
        view.render(request, response);
    }
}

  - web.frontcontroller.v2.FrontControllerServletV2.java

  - ControllerV2의 return이 MyView이므로 컨트롤러의 호출 결과로 MyView를 반환받는다.

  - myview.render() 호출을 통해 forward 로직을 수행하여 JSP가 실행된다.

  - JSP는 이전 MVC에서 사용하던 것을 그대로 사용한다,

  - 프론트 컨트롤러의 도입으로 MyView 객체의 render()를 호출하는 부분을 모두 일관되게 처리할 수 있다. 각각의 컨트롤러는 MyView 객체를 생성만해서 반환하면 된다!