⭐️ 스프링 MVC 3 - MVC 프레임워크 만들기

0. summary

1. FrontController 도입(v1) : @WebServlet 어노테이션 중복 해결
2. View 분리 (v2) : viewPath, render 역할 분리 - Myview가 수행
3. Model 추가 (v3): controller에 httpServlet 안보내려는 노력
   1. controller
      • modelview에 보낼 정보(model) render할 논리 path명(view)만 전달
   2. FrontController
      • req 정보 map으로 변환해서 paramMap이란 매개변수 controller로 전달 controller로 줌
      • 논리명 → 물리명 변경
   3. myview
      • model.map 정보 request에 담기
      • render 수행
4. 실용적인 컨트롤러 (v4)
   • ModelView 사용안함 - 나머진 v3와 동일
     •  논리명 path를 return
     • 보낼 정보를 hashmap에 담기 - 해당 hashmap은 frontController에서 제공
5. 유연한 컨트롤러1 (v5)

 

1. 프론트 컨트롤러 패턴

 

• FrontController 특징
  • FrontController servlet 하나로 모든 client 요청을 받는다.
  • FrontController servlet가 요청에 맞는 controller 찾아서 호출
  • FrontController servlet는 공통처리기능을 한다. ( ex) view 호출, view 네임, ModelAndView 관리 등)
  • FrontController servlet 제외한 controller는 servlet을 사용하지 않아도 된다.
• 스프링 web mvc 와 frontContrller 관계
  • FrontController servlet == DispatcherServlet
  • spring의 DispatcherServlet이 frontController 패턴으로 구현

 

2. FrontController 도입(v1)

• 목표
  • 구조의 반복만 수정
  • @WebServlet() 중복의 구조만 해결 == client 요청을 한 곳에서만 받는다.

 

2.1. Controller v1

• @WebSerlet 존재하지 않는 controller
• front controller는 interface 호출해서 구현체와 관계없이 로직의 일관성을 가져갈 수 있다.
• test도 유연해진다.

package hello.servlet.web.frontcontroller.v1;

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

 

// Controller 구현체 - form, save, list
// 보기 쉽게 한 block에 다 넣음. 원래 class 3개 존재

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

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();
    // frontController로 부터 req, res 받아오므로 params에 httpServletRequest 사용 가능
    @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); // request에 존재하는 가상의 model 저장소

        String viewPath = "/WEB-INF/views/save-result.jsp";
        RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath); // 현재 page의 req,res가 다른 page url(.jsp)에서도 사용할 수 있게 해주는 객체
        dispatcher.forward(request,response); // 현재 page의 req, res를 포워딩하는 역할
    }
}

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); // request에 존재하는 가상의 model 저장소

        String viewPath = "/WEB-INF/views/members.jsp";
        RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath); // 현재 page의 req,res가 다른 page url(.jsp)에서도 사용할 수 있게 해주는 객체
        dispatcher.forward(request,response); // 현재 page의 req, res를 포워딩하는 역할
    }
}

 

2.2. FrontController 생성

• urlPatterns: controller를 필요로 하는 모든 요청을 먼저 받아들인다. (/v1/*)
• controllerMap
  1. key - 매핑 url     
  2. value - 호출될 컨트롤러
• service(): 해당 controller 실행

package hello.servlet.web.frontcontroller.v1;

@WebServlet(name = "frontControllerServletV1", urlPatterns = "/front-controller/v1/*") // 해당 하위 모든 url의 요청은 현 servlet을 모두 거쳐 간다.
public class FrontControllerServletV1 extends HttpServlet {
    // 1. 매핑 정보
    private Map<String, ControllerV1> controllerV1Map = new HashMap<>();
    // 2. 생성자 (frontController 객체 생성시 Map에 엔티티 추가)
    public FrontControllerServletV1() {
        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());
    }
    // 3. 구현 controller 호출 실행 메서드 
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // client 요청 url의 정보를 가지고 Map에서 관련 controller를 찾고 해당 controller로 request, response를 전달해 준다.
        String requestURI = request.getRequestURI(); // client url 추출
        ControllerV1 controller = controllerV1Map.get(requestURI); // 관련 controller 꺼내기
        if (controller == null) {
            response.setStatus(HttpServletResponse.SC_NOT_FOUND);
            return;
        }
        // 아직까진 구현 controller에서 직접 model, view 반환
        controller.process(request, response);
    }
}

 

3. View 분리 (v2)

 

3.1. 중복코드

1. Path: view 이름 작성 중복
2. Render: view 이름에 맞게 req,res forward 전달 중복

// 모든 controller에서 중복되는 코드
// 중복1: viewPath
String viewPath = "/WEB-INF/views/new-form.jsp";
// 중복2: forward
RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
dispatcher.forward(request, response);

 

3.2. MyView

1. MyView 생성시 이미 url path 들어가 있다.
2. render는 front controller에서 수행한다.

• myview 또한 interface로 구성하면 다른 type의 html을 받을 수 있다. (현재는 class로 그냥 생성)

package hello.servlet.web.frontcontroller;

public class MyView {
    private String viewPath;

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

    /**
     * v2에서 사용
     *
     * @param request  : controller에서 data를 이미 받음
     * @param response : servlet에서 만든 req
     */
    public void render(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 원래 render 과정
        RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
        dispatcher.forward(request, response);
    }

    /**
     * v3, v4, v5 에서 사용
     *
     * @param model    : ModelView의 객체
     * @param request  : servlet에서 만든 req
     * @param response : servlet에서 만든 res
     */
    public void render(Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        modelToRequestAttribute(model, request); // view로 전달할 data를 map -> req로 이동
        // 원래 render 과정
        RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
        dispatcher.forward(request, response);
    }

    private static void modelToRequestAttribute(Map<String, Object> model, HttpServletRequest request) {
        model.forEach((key, value) -> request.setAttribute(key, value));
    }
}

 

 

3.3. controllerV2

• MyView를 return type으로 받는다.
• 참조변수 request는 객체 주소를 전달하는 것이기에 frontController나 controller나 동일 request 객체를 가리킨다.

// Controller interface
package hello.servlet.web.frontcontroller.v2;

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

 

// Controller 구현체 - form, save, list
// 보기 쉽게 한 block에 다 넣음. 원래 class 3개 존재

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

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

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); // request에 존재하는 가상의 model 저장소
        return new MyView("/WEB-INF/views/members.jsp");
    }
}

 

3.4. frontController

@WebServlet(name = "frontControllerServletV2", urlPatterns = "/front-controller/v2/*") 
public class FrontControllerServletV2 extends HttpServlet {
    // 1. 매핑 정보
    private Map<String, ControllerV2> controllerV2Map = new HashMap<>();
    // 2. 생성자 (frontController 객체 생성시 Map에 엔티티 추가)
    public FrontControllerServletV2() {
        controllerV2Map.put("/front-controller/v2/members/new-form", new MemberFormControllerV2());
        controllerV2Map.put("/front-controller/v2/members/save", new MemberSaveControllerV2());
        controllerV2Map.put("/front-controller/v2/members", new MemberListControllerV2());
    }
    // 3. 구현 controller 호출 실행 메서드 
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // client 요청 url의 정보를 가지고 Map에서 관련 controller를 찾고 해당 controller로 request, response를 전달해 준다.
        String requestURI = request.getRequestURI(); // client url 추출
        ControllerV2 controller = controllerV2Map.get(requestURI); // 관련 controller 꺼내기 - 아직 req,res 값을 받지 못했다
        if (controller == null) {
            response.setStatus(HttpServletResponse.SC_NOT_FOUND);
            return;
        }

        // 변경 부분 (v1 -> v2)
        MyView view = controller.process(request, response); // view 반환 (view Paht 존재)
        // 4. view.render로 view 이동 공통 부분 수행
        view.render(request,response); // 반환 정보로 view render
    }
}

 

4. Model 추가 (v3)

1. 서블릿 종속성 제거
   • 컨트롤러 입장에서 HttpServletRequest, HttpServletResponse이 없어도 요청 파라미터 정보는 자바의 Map으로 대신 넘기도록 하면 지금 구조에서는 컨트롤러가 서블릿 기술을 몰라도 동작할 수 있다.
   • saveController 같은 경우도 getparameter 정보가 필요한 것이지 start-line, header 등등 추가 정보가 필요한 것이 아니다.
   • request params 정보만 model에 담아서 넘기면 model만 다시 반환하면 된다.
2. view 이름 중복 제거(prefix, suffix)
   • view의 논리 이름만 쓰고 물리 위치의 이름은 frontController에서 처리하도록 단순화
   • /WEB-INF/views/new-form.jsp(물리이름)  ->   new-form (논리이름)

 

v3 모식도

4.1. ModelView

• view path 논리명
• req.serAttribute() 받는 역할

package hello.servlet.web.frontcontroller;

public class ModelView {
    private String viewName; // 논리적 경로
    private Map<String, Object> model = new HashMap<>(); // req.setAttribute() 역할

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

 

4.2. MyView

• controller가 준 setAttribute() 정보가 있는 modelview의 map을 request로 변환
• 나머지 render과정은 동일

package hello.servlet.web.frontcontroller;

public class MyView {
    private String viewPath;

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

    /** render method
     * v2에서 사용
     * @param request controller에서 data를 이미 받음
     * @param response servlet에서 만든 req
     */
    public void render(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 원래 render 과정
        RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
        dispatcher.forward(request, response);
    }

    /** render method
     * v3, v4, v5 에서 사용
     * @param model ModelView의 객체
     * @param request servlet에서 만든 req
     * @param response servlet에서 만든 res
     */
    public void render(Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // view로 전달할 data를 map -> req로 이동
        modelToRequestAttribute(model, request);
        // 원래 render 과정
        RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
        dispatcher.forward(request, response);
    }

    /**
     * @param model controller가 준 setAttribute() 정보가 있는 modelview의 map을 request로 변환
     * @param request : model 정보를 request에 담을 것임
     */
    private static void modelToRequestAttribute(Map<String, Object> model, HttpServletRequest request) {
        model.forEach((key, value) -> request.setAttribute(key, value));
    }
}

4.3. controller 생성

• 매개변수로 받는 paramMap에는 frontController에 의해서 req 기본 정보가 들어있다.
• 기본 req 정보를 사용가능하다는 의미

package hello.servlet.web.frontcontroller.v3;

public interface ControllerV3 {
    /**
     * @param paramMap frontController가 주는 map으로 request 기본 정보가 들어있다.
     */
    ModelView process(Map<String , String> paramMap);
}

• viewPath 논리명과 map에 전달할 정보 를 ModelView에 담아서 전달하는 것만 집중

// Controller 구현체 - form, save, list
// 보기 쉽게 한 block에 다 넣음. 원래 class 3개 존재

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

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

public class MemberSaveControllerV3 implements ControllerV3 {
    private MemberRepository memberRepository = MemberRepository.getInstance();
    @Override
    public ModelView process(Map<String, String> paramMap) {
        // frontController에서 getParameter정보만 받아온 paramMap이란 hashMap을 넘겨줌
        String username = paramMap.get("username");
        int age = Integer.parseInt(paramMap.get("age"));

        Member member = new Member(username, age);
        memberRepository.save(member);
        
        // viewResolver가 물리이름으로 바꿀 것임.
        ModelView mv = new ModelView("save-result");
        // 로직 처리해서 view로 보낼 정보를 ModelView의 map에 담아서 반환
        mv.getModel().put("member", member);
        
        return mv;
    }
}

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

 

4.4. frontController 생성

• controller 매개변수의 paramsMap에 미리 기본 request 정보 담아주기
• controller가 반환한 modelView의 viewPath 논리 명을 물리명으로 변경 -> 변경하면서 바로 Myview 객체 생성

package hello.servlet.web.frontcontroller.v3;

@WebServlet(name = "frontControllerServletV3", urlPatterns = "/front-controller/v3/*") // 해당 하위 모든 url의 요청은 현 servlet을 모두 거쳐 간다.
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(); // client url 추출
        ControllerV3 controller = controllerMap.get(requestURI); // 관련 controller 꺼내기
        if (controller == null) {
            response.setStatus(HttpServletResponse.SC_NOT_FOUND);
            return;
        }

        // 2. request 기본 정보가 저장된 map 생성
        Map<String, String> paramMap = createParamMap(request);
        // 3. paramMap controller 구현체에 보내기
        ModelView mv = controller.process(paramMap);

        // 4. ViewResolver 만들기
        String viewName = mv.getViewName(); // "new-form"
        // 5. 논리 path -> 물리 path로 바꾼 MyView 생성
        MyView view = viewResolver(viewName); // "/WEB-INF/views/new-form.jsp"
        // 6. 생성한 myView로 렌더링 하기
        view.render(mv.getModel(), request, response);
    }

    // 논리 이름 -> 물리 이름
    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;
    }
}

 

 

5. 실용적인 컨트롤러 (v4)

• ModelView 객체 생성하고 반환하는 부분이 번거로움
• ModelView 사용안함 - 나머진 v3와 동일
  • 논리명 path를 return
  • 보낼 정보를 hashmap에 담기 - 해당 hashmap은 frontController에서 제공

ModelView 반환 X,  ViewName 만 반환

 

5.1. Controller

• v3: ModelView process(Map<String, String> paramMap); // modelView에 String, Map 존재
• v4: String process(Map<String, String> paramMap, Map<String ,Object> model); // String은 return으로 Map은 model 매개변수로 분리
  
  
• 반환값: String - frontController에서 ViewName 논리이름을 물리 이름으로 변경우 MyView 생성하는데 사용
• model: frontController에서 생성 후 전달 한 map
• 참고 : 반환 값이 많은 경우는 v3 과정을 거친 후 v4 과정으로 변환 하는 것을 추천

package hello.servlet.web.frontcontroller.v4;

public interface ControllerV4 {
    /**
     * @param paramMap frontController의 request 기본 정보 가짐
     * @param model ModelView의 model 역할
     * @return String ModelView의 viewPath 논리명 역할 
     */
    String process(Map<String, String> paramMap, Map<String ,Object> model);
}

// Controller 구현체 - form, save, list
// 보기 쉽게 한 block에 다 넣음. 원래 class 3개 존재

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

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

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은 참조변수의 객체 주소값만 주는 것으로 frontController에 이미 존재. 객체는 하나, 주소만 공유
        // 그래서 controller 구현체에서 변경해도 객체 자체의 값이 변경된다.
        model.put("member", member);
        return "save-result";
    }
}

public class MemberListControllerV3 implements ControllerV3 {
    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";
    }
}

 

5.2. FrontControllerservletV4

• ModelView의 model 역할 : model 이름의 hashMap만 생성해서 controller params에 넘겨주면 된다.

package hello.servlet.web.frontcontroller.v4;

@WebServlet(name = "frontControllerServletV4", urlPatterns = "/front-controller/v4/*") // 해당 하위 모든 url의 요청은 현 servlet을 모두 거쳐 간다.
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(); // client url 추출
        ControllerV4 controller = controllerMap.get(requestURI); // 관련 controller 꺼내기
        if (controller == null) {
            response.setStatus(HttpServletResponse.SC_NOT_FOUND);
            return;
        }

        // 2. request 기본 정보가 저장된 map 생성
        Map<String, String> paramMap = createParamMap(request);
        // 3. ModelView의 model 역할
        Map<String, Object> model = new HashMap<>();
        // 4. 논리 이름 받기 - ModelView의 view 논리명 역할
        String viewName = controller.process(paramMap, model); // "new-form"
        // 5. 논리 path -> 물리 path로 바꾼 MyView 생성
        MyView view = viewResolver(viewName); // "/WEB-INF/views/new-form.jsp"
        // 6. 생성한 myView로 렌더링 하기
        view.render(model, request, response);
    }

    // 논리 이름 -> 물리 이름
    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;
    }
}

 

6. 유연한 컨트롤러1 (v5)

• summary
  • 핵심 
    1. handdlerMapping : controller와 같은 구현체들이 map으로 보관된 것 - 그 이상, 그 이하도 아니다.
    2. handdlerAdapter : handdlerMapping 구현체들마다 처리할 수 있는 이전에 쓰던 frontController -> 이제는 adapter로 변경되면서 v5frontController를 통해서 req, res를 주입 받는다.
  • 동작
    1. frontController는 handdlerMapping에서 실제 client가 호출한 url과 관련된 handler 가져온다.
    2. frontController는 handler를 이용해서 핸들러 어댑터 목록의 어댑터를 가져온다.
    3. 각각 가져온 handdlerMapping과 handdlerAdapter를 이용
    4. handdleradapter.handle(request, response, handler);
       • 이전 버전에서 수행하던 로직 수행, frontController로 부터 req, res 받은 것말고는 큰 차이 없음

 

⭐️ 6.1. 어뎁터 패턴

• 여러방식의 컨트롤러 인터페이스를 호환해서 사용하고 싶은 경우 사용

 

1. 핸들러 매핑 정보 (핸들러 조회)
   • frontController의 private final Map<String, Object> handlermappingMap = new HashMap<>();
2. 핸들러 어뎁터 목록 (핸들러를 처리할 수 있는 핸들러 어댑터 조회)
   • frontController의 private final List<MyHandlerAdapter> handlerAdapters = new ArrayList<>();
3. 핸들러 어뎁터(handle(handler))
   • frontController의 ModelView mv = adapter.handle(request, response, handler);
   • 핸들러 내부에서 v3, v4의 반환 type이 다르더라도 핸들러 어뎁터 내부처리에 의해 frontController에서 반환하는 type을 항상 ModelView를 반환하도록 한다.
   • 그렇기 때문에 frontController에서 v3형식의 요청이 오든 , v4 형식의 요청이 오든 다 처리가 가능해진다.
   • ex
     
     • 220v 콘센트 == frontController
     • 220v용 냉장고와 110v용 냉장고 존재  ==  핸들러
     • 각각 냉장고에 맞는 220v용 어뎁터와 110v용 어뎁터가 존재 == 핸들러 어뎁터
     • 왜 220v 콘센트인데 220v 냉장고를 어뎁터를 쓰는지 의문일 수 있지만 안써도 되고 써도 되는데 현재 v5형식에 맞춰 예를 든 것. code 상에서는 type과 관련된 여러 조건에 의해 이렇게 하는 것이 맞는 방식이다.
4. 핸들러(컨트롤러) (handler 호출)
   • 컨트롤러의 이름을 더 넓은 범위인 핸들러로 변경

 

6.2. adapter

package hello.servlet.web.frontcontroller.v5;

public interface MyHandlerAdapter {
    boolean supports(Object handler);

    /** adapter pattern
     * @param request
     * @param response
     * @param handler 핸들러 adapter에서 사용하는 controller
     * @return controller의 반환 타입에 관계 없이 항상 ModelView를 반환해준다.
     */
    ModelView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws ServletException, IOException;
}

    6.2.1. v3 adapter

package hello.servlet.web.frontcontroller.v5.adapter;

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

    6.2.2. v4 adapter

package hello.servlet.web.frontcontroller.v5.adapter;

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

        /* adapter 핵심 기능
        * 반환타입인 String인 v4도 frontController에서  동일하게 해결하기 위한 변환 과정
        */
        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;
    }
}

 

6.3. frontConrtoller

• adapter pattern으로 frontController는 여러가지 핸들러를 받을 수 있게 된다.
• OCP 준수 : 확장(handler, adapter)에 열려 있고 변경(ModelView)에는 닫혀 있다.

package hello.servlet.web.frontcontroller.v5;

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

        // v4 추가
        handlermappingMap.put("/front-controller/v5/v4/members/new-form", new MemberFormControllerV3());
        handlermappingMap.put("/front-controller/v5/v4/members/save", new MemberSaveControllerV3());
        handlermappingMap.put("/front-controller/v5/v4/members", new MemberListControllerV3());
    }

    // 초기화 분리 - 핸들러 어뎁터 목록
    private void initHandlerAdapters() {
         handlerAdapters.add(new ControllerV3HandlerAdapter());
         handlerAdapters.add(new ControllerV4HandlerAdapter());
    }

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // * 핸들러 == controller 구현체 찾는 method()
        Object handler = getHandler(request);

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

        // ** adapter 찾는 method - support, handle 이 핵심 method()
        MyHandlerAdapter adapter = getHandlerAdapter(handler);

        // 찾은 핸들러(= controller 구현체)와 해당 핸들러를 처리할 수 있는 adapter를 이용해서 내부로직 수행
        // 어떤 것이든 공통적으로 modelView 반환하도록 함. -> 참고: spring에서는 modelview 및 string 반환등 다양하게 존재한다.
        ModelView mv = adapter.handle(request, response, handler);

        // 나머지 로직은 동일 - 항상 ModelView를 반환하기 때문에 동일
        String viewName = mv.getViewName(); // "new-form"
        MyView view = viewResolver(viewName); // "/WEB-INF/views/new-form.jsp"

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

    // * 핸들러 == controller 구현체 찾는 method()
    private Object getHandler(HttpServletRequest request) {
        String requestURI = request.getRequestURI(); // client url 추출
        return handlermappingMap.get(requestURI); // 관련 controller 꺼내기
    }

    // ** adapter 찾는 method - support, handle 이 핵심 method()
    private MyHandlerAdapter getHandlerAdapter(Object handler) {
        for (MyHandlerAdapter adapter : handlerAdapters) {
            if (adapter.supports(handler)){
                return adapter;
            }
        }
        throw new IllegalArgumentException("handler adapter를 찾을 수 없습니다." + handler);
    }

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

}

 

 

 

이전 발행글 : 스프링 MVC 2 - 서블릿, jsp, MVC 패턴

 

다음 발행글 : 스프링 MVC 4 - 스프링 MVC 구조 이해

 

---

출처 인프런 김영한의 스프링 MVC 1편 - 백엔드 웹 개발 핵심 기술