(스프링 MVC1) MVC 프레임워크 만들기

프론트 컨트롤러 패턴 소개

• 프론트 컨트롤러 도입 전

• 프론트 컨트롤러 도입 후 * (공통의 관심사를 모으기 위해) 프론트 컨트롤러(서블릿)을 도입한다.

Front Controller 패턴 특징

• 프론트 컨트롤러 서블릿 하나로 클라이언트의 요청을 받음
  --> 프론트 컨트롤러는 서블릿이다(서블릿을 그냥 앞에 하나 두는 개념)
• 프론트 컨트롤러가 요청에 맞는 컨트롤러를 찾아서 호출
  --> 이전에는 클라이언트의 요청이 오면 매핑되는 서블릿이 직접 호출이 되었다면, 이제는 프론트 컨트롤러가 서블릿 요청을 다 받도록 만들고, 내부에서 공통 처리 등의 작업을 거친 후, 프론트 컨트롤러에 의해서 클라이언트 요청에 해당하는 세부 컨트롤러가 호출된다
• 입구를 하나로 만들 수 있다
• 공통 처리가 가능하다
• 프론트 컨트롤러를 제외한 나머지 컨트롤러는 서블릿을 사용하지 않아도 된다.

스프링 웹 MVC와 프론트 컨트롤러

• 스프링 웹 MVC 의 핵심은 바로 FrontController
• 스프링 웹 MVC의 DispatcherServlet이 FrontController의 패턴으로 구현되어 있다.

---

프론트 컨트롤러 도입 -V1

프론트 컨트롤러를 단계적으로 도입해보자
먼저, 최대한 기존 코드를 유지하면서, 프론트 컨트롤러를 도입해보자

V1구조
* 클라이언트가 HTTP 요청을 하면, FrontController이라는 서블릿이 요청을 받는다

• 이후, 요청 URL정보를 가지고, 매핑 정보에서 어떤 컨트롤러를 호출해야 하는지, 대상 컨트롤러를 조회하여 호출한다.
• 컨트롤러는 내부 로직을 수행하고, JSP forward를 한다.

*프론트 컨트롤러 도입 단계

• 인터페이서 ControllerV1을 생성ㅎ나다
• 인터페이스를 구현한 컨트롤러(MemberFormController, MemberSaveController, MemberListController)를 만든다.
• 인터페이스를 구현한 FrontController를 만든다.
  --> HttpServlet를 상속하고, @WebServlet을 통해 URL 매핑을 한다. 이 때 모든 URL에서 접근가능하도록 마지막에 /*로 처리한다.
• FrontController 내부적으로는 Map을 만들어 URL을 key, 컨트롤러 구현체를 value로 처리한 매핑정보 Map을 하나 만든다.

ControllerV1 인터페이스 생성

public interface ControllerV1 {

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

• 이 인터페이스를 구현한 각 Member컨트롤러를 만든다.

MemberFormControllerV1 클래스

public class MemberFormControllerV1 implements ControllerV1 {
    @Override
    public void process(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String viewPath = "/WEB_INF/views/new-form.jsp";
        RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
        dispatcher.forward(request,response);
    }
}

MemberSaveControllerV1 클래스

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

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

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

MemberListControllerV1 클래스

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

이제 프론트 컨트롤러를 만들어보자
FrontControllerServletV1

@WebServlet(name = "frontControllerServletV1", urlPatterns = "/front-controller/v1/*")
public class FrontControllerServletV1 extends HttpServlet {
    //URL을 key로 하여 ControllerV1 구현체들을 value로 가져올 수 있는 매핑정보 MAP
    private Map<String, ControllerV1> controllerMap = new HashMap<>();

    public FrontControllerServletV1() {
        controllerMap.put("/front-controller/v1/members/new-form", new MemberFormControllerV1());
        controllerMap.put("/front-controller/v1/members/save", new MemberSaveControllerV1());
        controllerMap.put("/front-controller/v1/members", new MemberListControllerV1());
    }

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //요청 URI에 맞는 구현체를 가져온다. 
        String requestURI = request.getRequestURI();
        ControllerV1 controller = controllerMap.get(requestURI);

        if(controller==null){
            response.setStatus(HttpServletResponse.SC_NOT_FOUND);
            return;
        }

        //가져온 구현체의 오버라이딩 메소드 실행
        controller.process(request,response);

    }
}

프론트 컨트롤러 분석

• urlPatterns
  urlPatterns = "/front-controller/v1/*"
  /front-controller/v1 를 포함한 하위 모든 요청은 이 서블릿에서 받아들인다.

• controllerMap
  key= 매핑 URL
  value=호출된 컨트롤러

• service()
  먼저 requestURI를 조회해서, 실제 호출할 컨트롤러를 controllerMap에서 찾는ㄴ다. 만약 없다면 404 상태 코드를 반환한다.
  컨트롤러를 찾고, controller.process(request,response)를 호출해서 해당 컨트롤러를 실행한다.

실행 순서

• localhost:8080/front-controller/v1/new-form의 요청이 오면, 위의 FrontController이 실행된다.
• 생성자에서 매핑정보를 우선 생성한다. URL주소를 key, ControllerV1의 인터페이스 구현체를 value로 Map에 넣어둔다
• service()가 실행된다
  --> request.getRequestURI()를 통해 요청한 URI를 꺼내온다
  --> 꺼내온 URI로 controllerMap에서 구현체를 가져온다(다형성)
  --> 매핑된 구현체가 없으면 404를 처리하고, 구현체가 있다면, 오버라이딩 메소드(process())를 실행하여 이전에 만들었던 JSP forward로직을 실행한다.

"구조적으로" 프론트 컨트롤러 패턴을 도입해보았다
이제 MVC 패턴을 도입하면서 불편했던 점들을 하나씩 개선해보자.

---

View 분리 - v2

모든 컨트롤러에서 뷰로 이동하는 부분에 중복이 있어 깔끔하지 않다.
이부분을 깔끔하게 분리하기 위해서, 별도로 뷰를 처리하는 객체를 만들것이다.

V2 구조

• 클라이언트가 HTTP 요청을 보낸다.
• FrontController는 매핑 정보에서 요청 URL에 따른 컨트롤러를 조회하여 호출한다.
• 과거에는 컨트롤러에서 JSP로 직접 forward를 해줬지만, 이제 컨트롤러에서 FrontController에 MyView라는 객체를 만들어 반환한다.
• FrontController가 MyView의 render()를 호출하면, MyView가 JSP로 forward한다.

MyView 클래스

public class MyView {
    
    private String viewPath;

    public MyView(String viewPath) {
        this.viewPath = viewPath;
    }
    
    //각 컨트롤러마다 호출했던 forward로직을 여기서 처리한다. 
    public void render(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{
        RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
        dispatcher.forward(request,response);
    }
}

ControllerV2 클래스

public interface ControllerV2 {
    MyView process(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException;
}

MemberFormControllerV2

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

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

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

MemberListControllerV2

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

FrontControllerV2

@WebServlet(name = "FrontControllerServletV2", urlPatterns = "/front-controller/v2/*")
public class FrontControllerServletV2 extends HttpServlet {
    //URL을 key로 하여, ControllerV2 구현체들을 value로 가져올 수 있는 매핑정보MAP
    private Map<String, ControllerV2> controllerMap = new HashMap<>();

    //URL별 매핑정보 생성
    public FrontControllerServletV2() {
        controllerMap.put("/front-controller/v2/members/new-form", new MemberFormControllerV2());
        controllerMap.put("/front-controller/v2/members/save", new MemberSaveControllerV2());
        controllerMap.put("/front-controller/v2/members", new MemberListControllerV2());
    }

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

        //요청 URI에 맞는 구현체가져옴
        String requestURI = request.getRequestURI();
        ControllerV2 controller = controllerMap.get(requestURI);

        if (controller == null) {
            response.setStatus(HttpServletResponse.SC_NOT_FOUND);
            return;
        }

        //가져온 구현체의 오버라이딩 메소드 실행
        //v2 : 기존과 다르게 viewName을 셋팅한 MyView 객체를 return받은 후, render()를 실행한다.
        MyView view = controller.process(request, response);
        view.render(request, response);
    }
}

• ControllerV2의 반환 타입이 Myview이므로, 프론트 컨트롤러는 컨트롤러의 호출 결과로 MyView를 반환받는다.
  그리고 view.render()를 호출하면, forward로직을 수해해서 JSP가 실행된다.

---

Model 추가

변경하고 싶은 부분이 두가지가 있다
1. 컨트롤러는 HttpServletRequest, HttpServletResponse에 종속적이다. 모델도 컨트롤러에서 request.setAttribute()를 통해서 사용했다. 컨트롤러가 서블릿 기술을 사용하지 않도록 변경해볼 예정이다.

2. 컨트롤러에서 리턴하는 뷰 네임에 중복이 있다.
   "WEB-INF/views/", ".jsp"가 중복이 된다. 이 부분을 제거하기 위해 컨트롤러는 논리 이름만 반환한다.

예를 들면,

//기존 중복 포함된 반환명
//return "/WEB-INF/views/new-form.jsp"
 
//중복 제거한 논리명
//return "new-form"

V3 구조

• 클라이언트가 HTTP요청을 보낸다
• 프론트 컨트롤러는 매핑 정보에서 요청 URL에 매핑되는 컨트롤러를 조회한다
• 컨트롤러는 내부 로직을 처리 후, Model과 View가 섞여있는 ModelView라는 객체를 반환한다.
• 프론트 컨트롤러는 (논리 이름을 물리 이름으로 변환하기 위해) viewResolver를 호출하고, MyView를 반환한다.
• render()를 호출한다.

ModelView

• 지금까지 컨트롤러에서 서블릿에 종속적인 HttpServletRequest를 사용했다
• 그리고 Model도 request.Attribute()를 통해 데이터를 저장하고 뷰에 전달했다
• 서블릿의 종속성을 제거하기 위해 Model을 직접 만들고, 추가로 view이름까지 전달하는 객체를 만들어보자.

public class ModelView {
    private String viewPath;
    private Map<String, Object> model = new HashMap<>();

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

    public String getViewPath() {
        return viewPath;
    }

    public void setViewPath(String viewPath) {
        this.viewPath = viewPath;
    }

    public Map<String, Object> getModel() {
        return model;
    }

    public void setModel(Map<String, Object> model) {
        this.model = model;
    }
}

• 뷰의 이름과 뷰를 렌더링할 때 필요한 model 객체를 가지고 있다. model은 단순히 map으로 되어 있으므로, 컨트롤러에서 뷰에 필요한 데이터를 key와 value로 넣어주면 된다.

ControllerV3 인터페이스

public interface ControllerV3 {
    ModelView process(Map<String, String> paramMap);
}

• HttpServletRequest가 제공하는 요청 파라미터는 프론트 컨트롤러가 paramMap에 담아서 호출해주면 된다. 응답 결과로 뷰 이름과, 뷰에 전달할 Model데이터를 포함하는 ModelView 객체를 반환하면 된다.

MemberFormControllerV3

public class MemberFormControllerV3 implements ControllerV3 {
    @Override
    public ModelView process(Map<String, String> paramMap) {
        return new ModelView("new-form");
    }
}

• ModelView를 생성해서, new-form이라는 view의 논리적인 이름을 지정한다.
  실제 물리적인 이름은 프론트 컨트롤러에서 처리한다.

MemberSaveControllerV3

public class MemberSaveControllerV3 implements ControllerV3 {
    private MemberRepository memberRepository = MemberRepository.getInstance();
 
    @Override
    public ModelView process(Map<String, String> paramMap) {
        String username = paramMap.get("username");
        int age = Integer.parseInt(paramMap.get("age"));
 
        Member member = new Member(username, age);
        memberRepository.save(member);
 
        ModelView mv = new ModelView("save-result");
        mv.getModel().put("member", member);
 
        return mv;
    }
}

• paramMap.get("username"): 파라미터 정보는 map에 담겨있다. map에서 필요한 요청 파라미터를 조회하면 된다.
• mv.getModel().put("member", member): 모델은 단순한 map이므로 모델에 뷰에서 필요한 member객체를 담고 반환한다.

MemberListControllerV3

public class MemberListControllerV3 implements ControllerV3 {
    private MemberRepository memberRepository = MemberRepository.getInstance();
    @Override
    public ModelView process(Map<String, String> paramMap) {
        List<Member> members = memberRepository.findAll();
        ModelView mv = new ModelView("members");
        mv.getModel().put("members", members);
        
        return mv;
    }
}

• 컨트롤러들이 동일하게 변경된 부분은 ModelView 객체 생성 후 논리명을 셋팅하는 부분과, model 처리가 필요한 부분은 setAttribute가 아니라 ModelView 객체에서 Model Map을 꺼내 put처리를 해준다는 점이다.

FrontControllerServletV3

@WebServlet(name = "FrontControllerServletV3", urlPatterns = "/front-controller/v3/*")
public class FrontControllerServletV3 extends HttpServlet {
    //URL을 key로 하여, ControllerV3 구현체들을 value로 가져올 수 있는 매핑정보MAP
    private Map<String, ControllerV3> controllerMap = new HashMap<>();

    //URL별 매핑정보 생성
    public FrontControllerServletV3() {
        controllerMap.put("/front-controller/v3/members/new-form", new MemberFormControllerV3());
        controllerMap.put("/front-controller/v3/members/save", new MemberSaveControllerV3());
        controllerMap.put("/front-controller/v3/members", new MemberListControllerV3());
    }

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

        //요청 URI에 맞는 구현체가져옴
        String requestURI = request.getRequestURI();
        ControllerV3 controller = controllerMap.get(requestURI);

        if (controller == null) {
            response.setStatus(HttpServletResponse.SC_NOT_FOUND);
            return;
        }

        //v3 : request, response를 넘겨주지 말고 paramMap을 넘긴다.
        Map<String, String> paramMap = createParamMap(request);
        ModelView mv = controller.process(paramMap);

        String viewName = mv.getViewName();
        MyView view = viewResolver(viewName);

        view.render(mv.getModel(), request, response);
    }

    //view의 논리명을 물리명으로 변경
    private MyView viewResolver(String viewName) {
        return new MyView("/WEB-INF/views/" + viewName + ".jsp");
    }

    //request 요청 파라미터를 Map에 셋팅해주는 역할
    private Map<String, String> createParamMap(HttpServletRequest request) {
        Map<String, String> paramMap = new HashMap<>();
        request.getParameterNames().asIterator()
                .forEachRemaining(paramName -> paramMap.put(paramName, request.getParameter(paramName)));

        return paramMap;
    }
}

• createParamMap() :HttpServletRequest에서 파라미터 정보를 꺼내서Map으로 변환한다. 그리고 해당 Map(paramMap)을 컨트롤러에 전달하면서 호출한다.

뷰 리졸버

• MyView view = viewResolver(viewName)
  컨트롤러가 반환한 논리 뷰 이름을 실제 물리 뷰 경로로 변경한다. 그리고 실제 물리 경로가 있는 MyView 객체를 반환한다.
  논리 뷰 이름: members
  물리 뷰 경로: /WEB-INF/views/members.jsp
• view.render(mv.getModel(), request, response)
  뷰 객체를 통해서 HTML 화면에 렌더링한다
  뷰 객체의 render()는 모델 정보도 함께 받는다
  JSP는 request.getAttribute() 로 데이터를 조회하기 때문에, 모델의 데이터를 꺼내서 request.setAttribute()로 담아둔다.
  JSP로 포워드해서 JSP를 렌더링 한다.

---

단순하고 실용적인 컨트롤러 V4

v4구조

• 컨트롤러가 Modelview를 반환하지 않고, viewName만 반환한다.

ControllerV4

public interface ControllerV4 {
    String process(Map<String, String> paramMap, Map<String, Object> model);

}

MemberFormControllerV4

public class MemberFormControllerV4 implements ControllerV4 {
    @Override
    public String process(Map<String, String> paramMap, Map<String, Object> model) {
        return "new-form";
    }
}

MemberSaveControllerV4

public class MemberSaveControllerV4 implements ControllerV4 {
    private MemberRepository memberRepository = MemberRepository.getInstance();
    @Override
    public String process(Map<String, String> paramMap, Map<String, Object> model) {
        String username = paramMap.get("username");
        int age = Integer.parseInt(paramMap.get("age"));

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

        model.put("member", member);
        return "save-result";
    }
}

• model.out("member",member): 모델이 파라미터로 전달되기 때문에 직접 모델을 생서하지 않아도 된다.

MemberListControllerV4

public class MemberListControllerV4 implements ControllerV4 {
    private MemberRepository memberRepository = MemberRepository.getInstance();
    @Override
    public String process(Map<String, String> paramMap, Map<String, Object> model) {
        List<Member> members = memberRepository.findAll();
        model.put("members",members);
        return "members";
    }
}

FrontControllerV4

@WebServlet(name = "frontControllerServletV4", urlPatterns = "front-controller/v4/*")
public class FrontControllerServletV4 extends HttpServlet {

    private Map<String, ControllerV4> controllerMap = new HashMap<>();

    public FrontControllerServletV4(){
        controllerMap.put("/front-controller/v4/members/new-form", new MemberFormControllerV4());
        controllerMap.put("/front-controller/v4/members/save", new MemberSaveControllerV4());
        controllerMap.put("/front-controller/v4/members", new MemberListControllerV4());
    }

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String requestURI = request.getRequestURI();
        ControllerV4 controller = controllerMap.get(requestURI);

        if (controller == null) {
            response.setStatus(HttpServletResponse.SC_NOT_FOUND);
            return;
        }
        Map<String, String> paramMap = createParamMap(request);
        Map<String, Object> model = new HashMap<>(); //추가
        String viewName = controller.process(paramMap, model);
        MyView view = viewResolver(viewName);

        view.render(model,request,response);

        //V4: paramMap뿐만 아니라, Model를 같이 넘긴다.

    }
    private MyView viewResolver(String viewName) {
        return new MyView("/WEB-INF/views/" + viewName + ".jsp");
    }

    //request 요청 파라미터를 Map에 셋팅해주는 역할
    private Map<String, String> createParamMap(HttpServletRequest request) {
        Map<String, String> paramMap = new HashMap<>();
        request.getParameterNames().asIterator()
                .forEachRemaining(paramName -> paramMap.put(paramName, request.getParameter(paramName)));
        return paramMap;
    }
}

• 모델 객체 전달
  Map model = new HashMap<>(); 추가
  --> 모델 객체를 프론트 컨트롤러에서 생성해서 넘겨준다. 컨트롤러에서 모델 객체에 값을 담으면 여기에 그대로 담겨있게 된다.

• 뷰의 논리 이름을 직접 반환
  
  컨트롤러가 직접 뷰의 논리이름을 반환하므로 이 값을 사용해서 실제 물리 뷰를 찾을 수 있다.

단순하고 실용적인 컨트롤러 v5

어댑터 패턴

• 지금까지 우리가 개발한 프론트 컨트롤러는 한가지 방식의 컨트롤러 인터페이스만 사용할 수 있다. 따라서 호환이 불가능하다. v3는 110v이고, v4는 220v 전기 콘센트 같은 것이다
• 어댑터 패턴을 사용해서 프론트 컨트롤러가 다양한 방식의 컨트롤러를 처리할 수 있도록 변경해보자

v5구조 참고

• 클라이언트에서 HTTP요청을 보낸다

• 프론트 컨트롤러는 핸들러 매핑 정보에서 핸들러를 조회한다.(핸들러 매핑 정보가 V3이라고 가정해보자)

• 핸들러를 처리할 수 있는 핸들러 어댑터를 조회(V3를 처리할 수 있는 어댑터를 찾아온다)

• 기존에는 FrontController에서 핸들러를 바로 호출했지만, 이제는 중간에 핸들러 어뎁터를 통해서 호출한다. 핸들러 어댑터에게 handler(컨트롤러)를 넘겨준다, 그러면 어댑터가 대신 호출해서 결과를 받는다. 그리고 FrontController에게 ModelView를 반환해준다)

• 핸들러 어댑터(=핸들러를 처리해주는 어댑터): 중간에 어댑터 역할을 하는 어댑터가 추가되었는데 이름이 핸들러 어댑터이다. 여기서 어댑터 역할을 해주는 덕분에 다양한 종류의 컨트롤러를 호출할 수 있다.

• 핸들러 : 컨트롤러의 이름을 더 넓은 범위인 핸들러로 변경했다. 어댑터가 있기 때문에 꼭 컨트롤러의 개념 뿐만 아니라, 어떠한 것이든 해당하는 종류의 어댑터만 있으면 다 처리할 수 있기 때문이다.

MyHandlerAdapter

public interface MyHandlerAdapter {
    
    boolean supports(Object handler);
    
    ModelView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws ServletException, IOException;
}

• boolean supprots(Object handler) :
  handler는 컨트롤러를 말한다.
  어댑터가 해당 컨트롤러를 처리할 수 있는지 판단하는 메서드이다.

• ModelView handle(HttpServletRequest request, HttpServletResponse response, **Object handler**)
  어뎁터는 실제 컨트롤러를 호출하고 그 결과로 ModelView를 반환해야 한다.
  실제 컨트롤러가 ModelView를 반환하고, 그렇지 못하면 어댑터가 ModelView를 직접 생성해서라도 반환해야 한다.
  이전에는 프론트 컨트롤러가 실제 컨트롤러를 호출했지만, 이제는 이 어댑터를 통해서 실제 컨트롤러가 호출된다.

실제 어댑터를 구현해보자 --> 먼저 ControllerV3를 지원하는 어댑터를 구현해 보자
ControllerV3HandlerAdaper

public class ControllerV3HandlerAdapter implements MyHandlerAdapter {
    @Override
    public boolean supports(Object handler) {
        return (handler instanceof ControllerV3);
    }

    @Override
    public ModelView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws ServletException, IOException {
        ControllerV3 controller = (ControllerV3) handler;
        Map<String, String> paramMap = createParamMap(request);
        ModelView mv = controller.process(paramMap);
        return mv;

    }

    private Map<String, String> createParamMap(HttpServletRequest request) {
        Map<String, String> paramMap = new HashMap<>();
        request.getParameterNames().asIterator()
                .forEachRemaining(paramName -> paramMap.put(paramName, request.getParameter(paramName)));

        return paramMap;
    }
}

• handler를 컨트롤러 V3을 변환한 다음에 V3 형식에 맞도록 호출한다
• supports()를 통해 ControllerV3만 지원하기 때문에, 타입 변환은 걱정없이 실행해도 된다
• ControllerV3는 ModelView를 반환하므로, 그대로 ModelView를 반환하면 된다

FrontControllerServletV5

@WebServlet(name = "frontControllerServletV5", urlPatterns = "/front-controller/v5/*")
public class FrontControllerServletV5 extends HttpServlet {
    //ControllerV3,V4등 다 넣어야 하기 때문에 <String, Object>로 처리
    private final Map<String, Object> handlerMappingMap = new HashMap<>();
    private final List<MyHandlerAdapter> handlerAdapters = new ArrayList<>();

    public FrontControllerServletV5() {
        initHandlerMappingMap();
        initHandlerAdapters();
    }

    //핸들러(컨트롤러) 매핑
    private void initHandlerMappingMap() {
        handlerMappingMap.put("/front-controller/v5/v3/members/new-form", new MemberFormControllerV3());
        handlerMappingMap.put("/front-controller/v5/v3/members/save", new MemberSaveControllerV3());
        handlerMappingMap.put("/front-controller/v5/v3/members", new MemberListControllerV3());
    }

    //핸들러를 처리할 수 있는 어댑터
    private void initHandlerAdapters() {
        handlerAdapters.add(new ControllerV3HandlerAdapter());
    }

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //요청에 맞는 핸들러 가져옴 : MemberFormControllerV3, MemberFormControllerV4
        Object handler = getHandler(request);
        if (handler == null) {
            response.setStatus(HttpServletResponse.SC_NOT_FOUND);
            return;
        }

        //어댑터 반환 : ControllerV3HandlerAdapter, ControllerV4HandlerAdapter
        MyHandlerAdapter adapter = getHandlerAdapter(handler);
        ModelView mv = adapter.handle(request, response, handler);

        String viewName = mv.getViewName();
        MyView view = viewResolver(viewName);

        view.render(mv.getModel(), request, response);
    }

    private Object getHandler(HttpServletRequest request) {
        String requestURI = request.getRequestURI();
        return handlerMappingMap.get(requestURI);
    }

    private MyHandlerAdapter getHandlerAdapter(Object handler) {
        //iter 입력하면 for문 자동처리
        for (MyHandlerAdapter adapter : handlerAdapters) {
            if (adapter.supports(handler)) {
                return adapter;
            }
        }

        throw new IllegalArgumentException("handler adapter를 찾을 수 없습니다. handler=" + handler);
    }

    private MyView viewResolver(String viewName) {
        return new MyView("/WEB-INF/views/" + viewName + ".jsp");
    }
}

• 컨트롤러(Controller)->핸들러(Handler)
  --> 이전에는 컨트롤러를 직접 매핑해서 사용했다. 그런데 이제는 어댑터를 사용하기 때문에, 컨트롤러 뿐만아니라, 어댑터가 지원하면 어떤 것도 URL에 매핑하여 사용할 수 있다.

---

유연한 컨트롤러2 - V5

FrontControllerServletV5에 ControllerV4의 기능도 추가해보자
FrontControllerServlet클래스에 ControllerV4 기능 추가

private void initHandlerMappingMap() {
        handlerMappingMap.put("/front-controller/v5/v3/members/new-form", new MemberFormControllerV3());
        handlerMappingMap.put("/front-controller/v5/v3/members/save", new MemberSaveControllerV3());
        handlerMappingMap.put("/front-controller/v5/v3/members", new MemberListControllerV3());
        //V4추가
        handlerMappingMap.put("/front-controller/v5/v4/members/new-form", new MemberFormControllerV4());
        handlerMappingMap.put("/front-controller/v5/v4/members/save", new MemberSaveControllerV4());
        handlerMappingMap.put("/front-controller/v5/v4/members", new MemberListControllerV4());
    }

    //핸들러를 처리할 수 있는 어댑터
    private void initHandlerAdapters() {
        handlerAdapters.add(new ControllerV3HandlerAdapter());
        handlerAdapters.add(new ControllerV4HandlerAdapter());
    }

• 핸들러 매핑(handlerMapping)에 ControllerV4를 사용하는 컨트롤러를 추가하고, 해당 컨트롤러를 처리할 수 있는 어댑터인 ControllerV4HandlerAdapter도 추가하자

ControllerV4HandlerAdaper

public class ControllerV4HandlerAdapter implements MyHandlerAdapter {
    @Override
    public boolean supports(Object handler) {
        return (handler instanceof ControllerV4);
    }

    @Override
    public ModelView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws ServletException, IOException {
        ControllerV4 controller = (ControllerV4) handler;
        Map<String, String> paramMap = createParamMap(request);
        HashMap<String, Object> model = new HashMap<>();

        String viewName = controller.process(paramMap, model);
        ModelView mv = new ModelView(viewName);
        mv.setModel(model);
        
        return mv;
        


    }

    private Map<String, String> createParamMap(HttpServletRequest request){
        Map<String, String> paramMap = new HashMap<>();
        request.getParameterNames().asIterator().forEachRemaining(paramName -> paramMap.put(paramName, paramMap.get(paramName)));
        return paramMap;
    }
}

support(Object handler)

 public boolean supports(Object handler) {
        return (handler instanceof ControllerV4);
    }

--> handler가 ControllerV4인 경우에만 처리하는 어댑터이다.

실행로직

public ModelView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws ServletException, IOException {
        ControllerV4 controller = (ControllerV4) handler;
        Map<String, String> paramMap = createParamMap(request);
        HashMap<String, Object> model = new HashMap<>();

        String viewName = controller.process(paramMap, model);
        ModelView mv = new ModelView(viewName);
        mv.setModel(model);
        
        return mv;

--> handler를 ControllerV4로 캐스팅하고, paramMap과 model를 만들어서 해당 컨트롤러를 호출한다. 그리고 viewName을 반환 받는다
--> 어댑터가 호출하는 ControllerV4는 뷰의 이름을 반환한다.
그런데, 어댑터는 뷰의 이름이 아니라 ModelView를 만들어서 반환해야 한다.
--> ControllerV4는 뷰의 이름을 반환했지만, 어댑터는 이것을 ModelView로 만들어서 형식을 맞추어 반환한다