[Spring] 4.MVC 프레임워크 만들기

[Spring] 4.MVC 프레임워크 만들기

 

1. 프론트 컨트롤러 패턴 소개

[프론트 컨트롤러 도입 전]

- 클라이언트의 호출을 받는 입구가 없음

 

[프론트 컨트롤러 도입 후]

- 수문장 역할하는 프론트 컨트롤러 서블릿 하나로 클라이언트 요청 받음

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

- 공통 처리 기능

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

스프링 웹 MVC의 핵심도 바로 'Front Controller' 'DispatcherServlet'이 Front Controller 패턴으로 구현되어있음

---

2. 프론트 컨트롤러  도입 - v1

단계적으로 도입

기존 코드를 최대한 유지하면서 프론트 컨트롤러 도입

먼저 구조를 맞추고 점진적으로 리팩토링

 

'v1 구조'

ControllerV1

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

- 컨트롤러 인터페이스 도입

- 해당 인터페이스를 구현한 컨트롤러 만들어야함

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

 

왜 인터페이스를 만드는가?

- 각 컨트롤러 만들건데 요청 정보 들어왔을때 맵핑 정보 찾아서 호출할 때 일관성있게 다형성 사용해서 Front Controller는 인터페이스에 의존하면서 편리하게 호출 가능

 

 

회원 등록 컨트롤러

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

 

회원 저장 컨트롤러

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

 

회원 목록 컨트롤러

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 폴더 안에 존재

하지만 프론트 컨트롤러의 경우 web-frontcontroleller-v1에 생성

 

프론트 컨트롤러

@WebServlet(name = "frontControllerServletV1", urlPatterns = "/front-controller/v1/*")
public class FrontControllerServletV1 extends HttpServlet {
  
  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 {
    System.out.println("FrontControllerServletV1.service");
    String requestURI = request.getRequestURI();
    
    ControllerV1 controller = controllerMap.get(requestURI);
    if (controller == null) {
      response.setStatus(HttpServletResponse.SC_NOT_FOUND);
      return; 
    }
    
    controller.process(request, response);
  }
}

- v1/* : v1하위에 뭐가 들어와도 지금 해당 서블릿이 무조건 호출됨

* 실제 개발할 땐 절대경로를 많이 씀

* 패턴 비슷한 경우 상대경로를 써도 됨

---

3. 프론트 컨트롤러  도입 - v2

모든 컨트롤러에서 뷰로 이동하는 부분에 중복이 있는 문제 해결

-> 뷰를 처리하는 객체 생성

1) 클라이언트가 HTTP 요청

2) 프론트 컨트롤러가 컨트롤러 찾아와서 호출

3) 컨트롤러가 직접 포워딩하지 않고 MyView 객체 만들어서 반환하면,

4) 프론트 컨트롤러가 대신 JSP 포워딩

 

MyView

public class MyView {
  
  private String viewPath;
  
  public MyView(String viewPath) {
    this.viewPath = viewPath;
  }
  
  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;
}

 

회원 등록 폼

public class MemberFormControllerV2 implements ControllerV2 {
  @Override
  public MyView process(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    return new MyView("/WEB-INF/views/new-form.jsp");
  }
}

- 이제 각 컨트롤러는 복잡한 dispatcher.forward() 호출 필요 없음

 

회원 저장

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

 

회원 목록

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

 

프론트 컨트롤러 V2

@WebServlet(name = "frontControllerServletV2", urlPatterns = "/front-controller/v2/*")
public class FrontControllerServletV2 extends HttpServlet {

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

  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 {
    String requestURI = request.getRequestURI();
    
    ControllerV2 controller = controllerMap.get(requestURI);
    
    if (controller == null) {
      response.setStatus(HttpServletResponse.SC_NOT_FOUND);
      return;
    }
    
    MyView view = controller.process(request, response);
    view.render(request, response);
  }
}

- 프론트 컨트롤러 도입으로 MyView 객체의 render() 호출하는 부분을 모두 일관되게 처리 가능

- 각각의 컨트롤러는 MyView 객체를 생성만해서 반환하면됨

---

4. Model 추가 - v3

[서블릿 종속성 제거]

- 컨트롤러 입장에서 request, response 필요없음  

- 요청 파라미터 정보 < request.getParameter("") > 는 자바의 Map으로 대신 넘기면 지금 구조에서 컨트롤러가 서블릿 기술 몰라도 동작 가능

- request객체를 Model로 사용하는 대신 별도의 Model 객체 만들어서 반환

 

즉 컨트롤러가 서블릿 기술 전혀 사용하지 않도록

-> 코드 단순 / 테스트 코드 작성 쉬워짐!

 

[뷰 이름 중복 제거]

- 컨트롤러에서 지정하는 뷰 이름에 중복이 있는 것을 확인 가능

- 컨트롤러는 '뷰의 논리 이름'을 반환, 실제 물리 위치의 이름은 프론트 컨트롤러에서 처리하도록 단순화

- 향후 뷰의 폴더 위치가 함께 이동해서 프론트 컨트롤러만 고치면 됨!

-> 변경의 지점을 하나로 둘 수 있음

/WEB-INF/views/new-form.jsp new-form /WEB-INF/views/save-result.jsp save-result /WEB-INF/views/members.jsp members

 

V3 구조

ModelView

- 서블릿 종속성 제거하기 위해 Model 직접 만들고 추가로 View 이름까지 전달하는 객체를 만들어야함

- ModelView 객체는 다른 버전에서도 사용하므로 패키지를 frontcontroller에 둠

public class ModelView {
  
  private String viewName; // 뷰 논리적 이름
  
  private Map<String, Object> model = new HashMap<>(); // 모델
  
  public ModelView(String viewName) {
    this.viewName = viewName;
  }

  public String getViewName() {
    return viewName;
  }

  public void setViewName(String viewName) {
    this.viewName = viewName;
  }
  
  public Map<String, Object> getModel() {
    return model;
  }

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

- 뷰 이름과 뷰 렌더링시 필요한 model 객체 가지고있음

 

ControllerV3

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

- 프레임워크에 종속적임

- 서블릿에 더이상 종속적이지 않음

설명)

이 컨트롤러는 서블릿 기술을 전혀 사용하지 않는다. 따라서 구현이 매우 단순해지고, 테스트 코드 작성시 테스트 하기 쉽다. HttpServletRequest가 제공하는 파라미터는 프론트 컨트롤러가 paramMap에 담아서 호출해주면 된다. 응답 결과로 뷰 이름과 뷰에 전달할 Model 데이터를 포함하는 ModelView 객체를 반환하면 된다

회원 등록 폼

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

- ModelView 생성할 때 new-form이라는 view의 논리적인 이름 지정

- 실제 물리적 이름은 프론트 컨트롤러에서 처리

 

회원 저장

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

- 파라미터 정보는 map에 담겨있기 때문에 map에서 필요 파라미터 조회하면 됨

- 뷰에 필요한 객체는 map에 담아서 반환

 

회원 목록

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

 

먼저 MyView 수정

public class MyView {
  
  private String viewPath;
  
  public MyView(String viewPath) {
    this.viewPath = viewPath;
  }
  
  public void render(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
    dispatcher.forward(request, response);
  }

  public void render(Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    modelToRequestAttribute(model, request);
    RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
    dispatcher.forward(request, response);
  }
  
  private void modelToRequestAttribute(Map<String, Object> model, HttpServletRequest request) {
    model.forEach((key, value) -> request.setAttribute(key, value));
  }
  
}

 

프론트 컨트롤러 서블릿

@WebServlet(name = "frontControllerServletV3", urlPatterns = "/front-controller/v3/*")
public class FrontControllerServletV3 extends HttpServlet {
  
  private Map<String, ControllerV3> controllerMap = new HashMap<>();
  
  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 {
    String requestURI = request.getRequestURI();
    ControllerV3 controller = controllerMap.get(requestURI);
    
    if (controller == null) {
      response.setStatus(HttpServletResponse.SC_NOT_FOUND);
      return; 
    }
    
    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);
  }
  
  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;
  }

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

 

createParamMap()

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

 

뷰 리졸버

컨트롤러가 반환한 논리 뷰 이름을 실제 물리 뷰 경로로 변경 그리고 실제 물리 경로가 있는 MyView 객체를 반환 논리 뷰 이름: members 물리 뷰 경로: /WEB-INF/views/members.jsp

 

뷰 렌더

뷰 객체를 통해서 HTML 화면을 렌더링 한다. 뷰 객체의 render() 는 모델 정보도 함께 받는다. JSP는 request.getAttribute() 로 데이터를 조회하기 때문에, 모델의 데이터를 꺼내서 request.setAttribute() 로 담아둔다. JSP로 포워드 해서 JSP를 렌더링 한다.

---

5. 단순하고 실용적인 컨트롤러 - v4

ModelView 객체를 생성하고 반환하는 부분 번거로움-> 실제 개발 시 단순, 편리 사용 중요(실용성)

 

편리하게 개발할 수 있는 v4

v4 - v3에서 개선된 점

- ModelView를 반환하지 않고 ViewName 반환

 

ControllerV4

 public interface ControllerV4 {
      /**
       * @param paramMap
       * @param model
       * @return viewName
       */
      String process(Map<String, String> paramMap, Map<String, Object> model);
  }

- 인터페이스에 ModelView가 없음 -> ModelView가 아닌 String(View이름)만 반환

 

회원 저장

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에 담기만하면 그대로 남아있어서 반환할 필요가 없다

* view이름만 반환

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

  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;
  }
  
  private MyView viewResolver(String viewName) {
    return new MyView("/WEB-INF/views/" + viewName + ".jsp");
  } 
}

- frontcontroller는 이전버전과 동일 (process에 model 추가로 넣어주는 것 말고는)

---

6. 유연한 컨트롤러

어떤 개발자는 V3방식으로 개발하고싶고, 어떤 개발자는 V4방식으로 개발하고싶다면?

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

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

 

어댑터 패턴

- 두 컨트롤러는 호환이 불가

-> 어댑터 패턴을 사용해 프론트 컨트롤러가 다양한 방식의 컨트롤러 처리할 수 있도록 변경해야함

 

V5

핸들러 어댑터 : 다양한 종류의 컨트롤러 호출 가능

핸들러 : 컨트롤러 뿐만 아니라 해당하는 종류의 어댑터만 있다면 모두 처리 가능

 

MyHandlerAdapter

public interface MyHandlerAdapter {

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

boolean supports (Object handler)

- handler는 컨트롤러를 말함

- 어댑터가 해당 컨트롤러를 처리할 수 있는지 판단하는 메서드

 

ModelView handle()

- 어댑터는 실제 컨트롤러를 호출하고 그 결과로 ModelView 반환해야함

- 실제 컨트롤러가 ModelView 반환하지 못하면 어댑터가 ModelView를 직접 생성해서라도 반환해야함

- 이전엔 프론트 컨트롤러가 실제 컨트롤러 호출했지만 이젠 이 어댑터를 통해 실제 컨트롤러가 호출됨

 

ControllerV3HandlerAdapter

public class ControllerV3HandlerAdapter implements MyHandlerAdapter {
  
  @Override
  public boolean supports(Object handler) {    // controllerV3 처리하는 어댑터
    return (handler instanceof ControllerV3);  
  }
  
  @Override
  public ModelView handle(HttpServletRequest request, HttpServletResponse response, Object handler) {
    ControllerV3 controller = (ControllerV3) handler; // 형변환 (타입변환 supports로 걸러지므로 잘됨)
    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;
  }
}

 

FrontControllerServletV5

@WebServlet(name = "frontControllerServletV5", urlPatterns = "/front-controller/v5/*")
public class FrontControllerServletV5 extends HttpServlet {
  
  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 {
    Object handler = getHandler(request);
    if (handler == null) {
      response.setStatus(HttpServletResponse.SC_NOT_FOUND);
    return; 
    }

    MyHandlerAdapter adapter = getHandlerAdapter(handler);
    ModelView mv = adapter.handle(request, response, handler);
    MyView view = viewResolver(mv.getViewName());
    view.render(mv.getModel(), request, response);
  }
  
  private Object getHandler(HttpServletRequest request) {
    String requestURI = request.getRequestURI();
    return handlerMappingMap.get(requestURI);
  }
  
  private MyHandlerAdapter getHandlerAdapter(Object handler) {
    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");
  }
}

컨트롤러 <-> 핸들러

어떤 것이라도 URL에 맵핑 가능하기 때문에 핸들러

 

V6

여기에 ControllerV4 사용할 수 있도록 기능 추가

@WebServlet(name = "frontControllerServletV6", urlPatterns = "/front-controller/v6/*")
public class FrontControllerServletV6 extends HttpServlet {
  
  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());
    
    // 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()); //V4 추가
  }

  @Override
  protected void service(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
    Object handler = getHandler(request);
    if (handler == null) {
      response.setStatus(HttpServletResponse.SC_NOT_FOUND);
    return; 
    }

    MyHandlerAdapter adapter = getHandlerAdapter(handler);
    ModelView mv = adapter.handle(request, response, handler);
    MyView view = viewResolver(mv.getViewName());
    view.render(mv.getModel(), request, response);
  }
  
  private Object getHandler(HttpServletRequest request) {
    String requestURI = request.getRequestURI();
    return handlerMappingMap.get(requestURI);
  }
  
  private MyHandlerAdapter getHandlerAdapter(Object handler) {
    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");
  }
}

 

ControllerV4HandlerAdapter

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) {
    ControllerV4 controller = (ControllerV4) handler;
    Map<String, String> paramMap = createParamMap(request);
    Map<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,
    request.getParameter(paramName)));
    return paramMap;
  }
 }

ControllerV4는 뷰의 이름 반환 -> 어댑터는 뷰의 이름이 아니라 ModelView를 만들어서 반환해야함 

-> ModelView 형식으로 반환해줌