[Spring] MVC 1편 - 04. MVC 프레임워크 만들기

somyeong·2022년 4월 26일
MVCSpring
0

Spring

목록 보기
14/17
post-thumbnail
post-custom-banner

이 글은 스프링 [스프링 MVC 1편]을 듣고 정리한 내용입니다

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

프론트 컨트롤러 도입 전

🌱 Front Controller 패턴 특징

  • 프론트 컨트롤러라는 별도의 서블릿 하나로 클라이언트의 요청을 받는다
  • 프론트 컨트롤러가 요청에 맞는 컨트롤러를 찾아서 호출한다.
  • 입구를 하나로 하는 형태이고, 공통 처리가 가능하다. 또한 프론트 컨트롤러를 제외한 나머지 컨트롤러는 서블릿을 사용하지 않아도 된다.

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

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

📌 프론트 컨트롤러 도입 - v1

  • 기존 코드를 최대한 유지하면서, 프론트 컨트롤러를 도입해보도록 하자.
  • 먼저 구조를 맞춰두고, 점진적으로 리팩토링 하자.

ControllerV1

package hello.servlet.web.frontcontroller.v1;

//이것을 왜 만드냐면, ControllerV1을 이용해서 구현을 여러개 할 것임(회원 폼, 회원 저장, 회원 리스트 컨트롤러)
public interface ControllerV1 {

    //서블릿과 똑같은 형태
    void process(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException;
}
  • 서블릿과 비슷한 모양의 컨트롤러 인터페이스를 도입한다.
  • 각 컨트롤러는 이 인터페이스를 구현하면 되고, 프론트 컨트롤러는 이 인터페이스를 호출해서 구현과 관계없이 로직의 일관성을 챙길 수 있다.

MbmerFormControllerV1- 회원 등록 컨트롤러

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

public class MemberFormControllerV1 implements ControllerV1 {

    //MvcMemberFormServlet 코드와 같음 (process, service 이름만 다름)

    @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); //서블릿에서 JSP 호출
    }
}

MemberSaveControllerV1 - 회원 저장 컨트롤러

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

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);
        //여기까진 이전 서블릿코드와 똑같음

        //Model에 데이터를 보관한다
        request.setAttribute("member",member); //requset객체의 내부 저장소에 저장함. (map같은것들이 있음)

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

MemberListControllerV1- 회원 목록 컨트롤러

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

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

    }
}
  • 내부로직은 기존 서블릿과 거의 똑같다

FrontControllerV1 - 프론트 컨트롤러

package hello.servlet.web.frontcontroller.v1;


@WebServlet(name="frontControllerServletV1", urlPatterns = "/front-controller/v1/*") //v1를 포함한 하위의 어떤 url이 들어와도 이 서블릿이 호출된다.
public class FrontControllerServletV1 extends HttpServlet {

    //매핑정보, 어떤 url이 호출되면 ControllerV1을 꺼내서 호출하라는 의미
    private Map<String, ControllerV1> controllerMap = new HashMap<>();


    //매핑정보를 담아둠
    public FrontControllerServletV1() { //각각이 key-value 형태
        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); //페이지가 없거나 못찾으면 404에러 보내줌
            return;
        }

        controller.process(request,response);

    }
}

프론트 컨트롤러 분석

  • controllerMap
    • key: 매핑 URL
    • value: 호출될 컨트롤러
  • service()
    • 먼저 requestURI를 조회해서 실제 호출할 컨트롤러를 controllerMap에서 찾는다. 없다면 404(SC_NOT_FOUND) 상태코드를 반환한다
    • 컨트롤러를 찾고 controller.process(request,response);를 호출해서 해당 컨트롤러를 실행한다.
  • JSP는 이전 MVC에서 사용한것을 그대로 사용한다

📌 View 분리 - v2

  • 각각의 컨트롤러에서 뷰로 이동하는 부분에 다음과 같은 코드가 중복된다
tring viewPath = "/WEB-INF/views/new-form.jsp";
  RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
  dispatcher.forward(request, response);
  • 이 부분을 깔끔하게 분리하기 위해 별도로 뷰를 처리하는 객체를 만들자.

MyView

package hello.servlet.web.frontcontroller;

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 MyView {

    private String viewPath; //"WEB-INF/views/new-form.js["

    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 인터페이스
package hello.servlet.web.frontcontroller.v2;

public interface ControllerV2 {

    // ControllerV1과 같은데 반환타입이 MyView이다.
    MyView process(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException;
}

MemberFormControllerV2 - 회원 등록 폼

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"); //control+T 'inline'검색해서 엔터
    }
}
  • 이제 각 컨트롤러는 dispatcher.forward()를 직접 생성해서 호출하지 않아도 된다. 단순히 MyView객체를 생성하고 거기에 뷰 이름만 넣고 반환하면 된다.

MemberSaveControllerV2 - 회원 저장

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

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);
        //여기까진 이전 서블릿코드와 똑같음

        //Model에 데이터를 보관한다
        request.setAttribute("member",member); //requset객체의 내부 저장소에 저장함. (map같은것들이 있음)

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

    }
}

MemberListControllerV2 - 회원 목록

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

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

package hello.servlet.web.frontcontroller.v2;

@WebServlet(name="frontControllerServletV2", urlPatterns = "/front-controller/v2/*") //v1를 포함한 하위의 어떤 url이 들어와도 이 서블릿이 호출된다.
public class FrontControllerServletV2 extends HttpServlet {

    //매핑정보, 어떤 url이 호출되면 ControllerV1을 꺼내서 호출하라는 의미
    private Map<String, ControllerV2> controllerMap = new HashMap<>();


    //매핑정보를 담아둠
    public FrontControllerServletV2() { //각각이 key-value 형태
        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");

        String requestURI = request.getRequestURI();

        ControllerV2 controller = controllerMap.get(requestURI);
        if(controller==null){
            response.setStatus(HttpServletResponse.SC_NOT_FOUND); //페이지가 없거나 못찾으면 404에러 보내줌
            return;
        }

        //new MyView("/WEB-INF/views/new-form.jsp")
        MyView view = controller.process(request, response);
        view.render(request,response);

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

Myview.render()함수

   public void render(HttpServletRequest request, HttpServletResponse response)
  throws ServletException, IOException {
      RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
      dispatcher.forward(request, response);
  }
  • 프론트 컨트롤러의 도입으로 MyView객체의 render()를 호출하는 부분을 모두 일관되게 처리할 수 있다.
  • 각각의 컨트롤러는 MyView 객체를 생성만 해서 반환하면 된다.

📌 Model 추가 - v3

서블릿 종속성 제거

  • 컨트롤러 입장에서 HttpServletRequest, HttpServletResponse는 꼭 필요하지 않다.
  • 요청 파라미터 정보는 자바의 Map으로 대신 넘기도록 하면 서블릿 기술이 굳이 없어도 된다.
  • request 객체를 Model로사용하는 대신 별도의 Model객체를 만들어서 반환하자
  • 이렇게 하면, 코드가 단순해지고 테스트 작성도 쉬워진다

뷰 이름 중복 제거

  • 컨트롤러에서 지정하는 뷰 이름에 중복이 있는데 이를 제거하자
    ex)
    /WEB-INF/views/new-form.jsp (뷰의 실제 물리 위치의 이름) -> new-form (뷰의 논리 이름)
    /WEB-INF/views/save-result.jsp -> save-result
    /WEB-INF/views/members.jsp -> members
  • 컨트롤러는 뷰의 논리 이름은을 반환하고, 프론트컨트롤러에서 실제 물리 위치의 이름으로 처리하자.

ModelView

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

ModelView

package hello.servlet.web.frontcontroller;

import java.util.HashMap;
import java.util.Map;

public class ModelView {

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

    private Map<String, Object> model = new HashMap<>();

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

ControllerV3

package hello.servlet.web.frontcontroller.v3;

import hello.servlet.web.frontcontroller.ModelView;

import java.util.Map;

public interface ControllerV3 {

    //ControllerV2에서는 HttpServletRequest, HttpServletResponse같은 서블릿 기술들이 들어갔는데, V3에는 전혀 안들어감
    ModelView process(Map<String, String> paramMap); //프레임워크에 종속적일 뿐, 서블릿에 종속적이지 않음.

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

MemberFormControllerV3 - 회원 등록 폼

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"); //모델뷰 생성할때 논리적 이름으로 지정.
    }
}
  • ModelView를 생성할때 new-form 이라는 논리적 이름을 지정하고, 프론트 컨트롤러에서 실제 물리적 이름으로 처리한다.

MemberSaveControllerV3 - 회원 저장

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

public class MemberSaveControllerV3 implements ControllerV3 {

    private MemberRepository memberRepository = MemberRepository.getInstance();

    @Override
    public ModelView process(Map<String, String> paramMap) {
        String username= paramMap.get("username"); //파라미터 정보는 map에 담겨있다. map에서 필요한 요청 파라미터를 조회하면 된다.
        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); // 모델은 단순한 map이므로 뷰에서 필요한 member객체를 담고 반환한다.
        return mv;

    }
}

MemberListControllerV3 - 회원 목록

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

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

FrontControllerServletV3

package hello.servlet.web.frontcontroller.v3;

@WebServlet(name="frontControllerServletV3", urlPatterns = "/front-controller/v3/*")
public class FrontControllerServletV3 extends HttpServlet {

    //매핑정보, 어떤 url이 호출되면 ControllerV1을 꺼내서 호출하라는 의미
    private Map<String, ControllerV3> controllerMap = new HashMap<>();


    //매핑정보를 담아둠
    public FrontControllerServletV3() { //각각이 key-value 형태
        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");

        String requestURI = request.getRequestURI();

        ControllerV3 controller = controllerMap.get(requestURI);
        if(controller==null){
            response.setStatus(HttpServletResponse.SC_NOT_FOUND); //페이지가 없거나 못찾으면 404에러 보내줌
            return;
        }

        //paramMap

        Map<String, String> paramMap = createParamMap(request);
        ModelView mv= controller.process(paramMap);

        String viewName = mv.getViewName(); //논리이름 new-form
        MyView view = viewResolver(viewName);

        view.render(mv.getModel(), request, response);
    }
	
    
    // 컨트롤러가 반환한 논리 뷰 이름을 실제 물리 뷰 경로로 변경한다
    // 그리고 실제 물리 경로가 있는 MyView 객체를 반환한다.
    private MyView viewResolver(String viewName) {
        return new MyView("/WEB-INF/views/" + viewName + ".jsp");
    }

	// HttpServletRequest에서 파라미터 정보를 꺼내서 Map으로 변환. 해당 Map(paramMap)을 컨트롤러에 전달하면서 호출한다.
    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;
    }
}
  • view.render(mv.getModel(), request, response) (아래 MyView 코드 참고)
    • 뷰 객체를 통해서 HTML화면을 렌더링 한다.
    • 뷰 객체의 render()는 모델 정보도 함께 받는다
    • JSP는 request.getAttribute()로 데이터를 조회하기 때문에, 모델의 데이터를 꺼내서 request.setAttribute()로 담아둔다
    • JSP로 포워드해서 JSP를 렌더링한다.

MyView

package hello.servlet.web.frontcontroller;

public class MyView {

    private String viewPath; //"WEB-INF/views/new-form.js["

    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 {
        modelToRequesetAttribute(model,request);
        RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
        dispatcher.forward(request,response);

    }

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

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

  • v3 컨트롤러는 서블릿 종속성을 제거했고, 뷰 경로의 중복을 제거하였다.

  • 그러나 ModelView객체를 항상 생성하고 반환해야 해서 번거롭다

    좋은 프레임워크란?

  • 아키텍처도 중요하지만, 개발하는 개발자가 단순하고 편리하게 사용할 수 있어야 한다 (== 실용성이 있어야 한다)

  • v3을 수정하여 더 편리해진 v4버전을 개발해보자


    v3과 거의 같고, 컨트롤러가 ModelView객체를 반환하는 대신 그냥 ViewName만 반환한다.

ControllerV4

package hello.servlet.web.frontcontroller.v4;

public interface ControllerV4 {
    /**
     *
     * @param paramMap
     * @param model
     * @return viewName
     */
    //이번에는 ModelView가 아니라 String 타입의 process
    String process(Map<String, String> paramMap, Map<String, Object> model);
}

  • 인터페이스에 ModelView가 없다.

  • model 객체는 파라미터로 전달되기 때문에 그냥 사용하면 되고, 결과로 뷰의 논리이름만 반환하면 된다.

    MemberFormControllerV4

 package hello.servlet.web.frontcontroller.v4.controller;
 
import java.util.Map;

public class MemberFormControllerV4 implements ControllerV4 {

    @Override
    public String process(Map<String, String> paramMap, Map<String,Object> model) {
        return "new-form"; //뷰의 논리 이름만 반환하면됨. 모델을 생성할 필요 없음
    }
}

MemberSaveControllerV4

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

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

MemberListControllerV4

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

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"; //논리 뷰 이름

    }
}

FrontControllerServletV4

package hello.servlet.web.frontcontroller.v4;

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

    //매핑정보, 어떤 url이 호출되면 ControllerV1을 꺼내서 호출하라는 의미
    private Map<String, ControllerV4> controllerMap = new HashMap<>();


    //매핑정보를 담아둠
    public FrontControllerServletV4() { //각각이 key-value 형태
        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 {
        System.out.println("FrontControllerServletV4.service");

        String requestURI = request.getRequestURI();

        ControllerV4 controller = controllerMap.get(requestURI);
        if(controller==null){
            response.setStatus(HttpServletResponse.SC_NOT_FOUND); //페이지가 없거나 못찾으면 404에러 보내줌
            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 MyView viewResolver(String viewName) {
        return new MyView("/WEB-INF/views/" + viewName + ".jsp");
    }

    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<String, Object> model = new HashMap<>();
- 모델 객체를 프론트 컨트롤러에서 생성해서 넘겨준다 (처음에는 빈 모델)
- 컨트롤러에서 모델 객체에 값을 담을 담으면 여기에 그대로 담겨있게 된다.

뷰의 논리 이름을 직접 반환

//컨트롤러가 직접 뷰의 논리 이름을 반환하므로 이값을 String으로 반환 받아 viewResolver를 통해 실제 물리 뷰를 찾을 수 있다.
 String viewName = controller.process(paramMap, model);
 MyView view = viewResolver(viewName);

v4 정리

  • 기존 v3에다가, 모델을 파라미터로 넘기고, 뷰의 논리 이름을 반환한다는 아이디어를 적용한것 뿐이다.
  • 컨트롤러의 개발자 입장에서보면 더 편리해졌다.
  • 프레임워크나 공통 기능이 수고로워야 사용하는 개발자가 편리해진다

📌 유연한 컨트롤러1 - v5

어댑터 패턴

  • 어떤 개발자는 ControllerV3 방식을, 어떤 개발자는 ControllerV4방식으로 개발하고 싶다면?
  • 어댑터 패턴을 사용해서 프론트 컨트롤러가 다양한 방식의 컨트롤러를 처리할 수 있도록 변경하자

v5 구조

핸들러 어댑터

어댑터 역할을 하여, 덕분에 다양한 종류의 컨트롤러를 호출할 수 있다.

핸들러

컨트롤러의 이름을 더 넓은 범위인 핸들러로 변경

MyHandlerAdapter
어댑터의 구현 방식을 요약하는 어댑터용 인터페이스

package hello.servlet.web.frontcontroller.v5;

public interface MyHandlerAdapter {

    //해당 handler를 지원할 수 있으면 true, 없으면 false
    boolean supports(Object handler);

    ModelView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws ServletException, IOException;
}
  • boolean supports(Object handler)
    • handler는 컨트롤러를 뜻함
    • 어댑터가 해당 컨트롤러를 처리할 수 있는지 판단
  • `ModelView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
    • 어댑터는 실제 컨트롤러를 호출하고, 그 결과로 ModelView를 반환해야 한다
    • 실제 컨트롤러가 ModelView를 반환하지 못하면, 어댑터가 ModelView를 직접 생성해서라도 반환해야 한다
    • 이전에는 프론트 컨트롤러가 실제 컨트롤러를 호출했지만 이제는 이 어댑터를 통해서 실제 컨트롤러가 호출된다.
  • 실제 어댑터를 구현해보자
    ControllerV3HandlerAdapter - ControllerV3을 지언하는 어댑터
package hello.servlet.web.frontcontroller.v5.adapter;

public class ControllerV3HandlerAdapter implements MyHandlerAdapter {

    @Override
    public boolean supports(Object handler) {// ControllerV3을 처리할 수 있는 어댑터를 뜻함
        return (handler instanceof ControllerV3); // handler가 ControllerV3의 인터페이스이면 true, 아니면 false
    }

    @Override
    public ModelView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws ServletException, IOException {
    	// handler를 컨트롤러 V3으로 변환한 다음에 V3 형식에 맞도록 호출한다.
        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;
    }
}

FrontControllerServletV5

package hello.servlet.web.frontcontroller.v5;

@WebServlet(name="frontControllerServlet5", urlPatterns = "/front-controller/v5/*")
public class FrontControllerServletV5 extends HttpServlet {
	//매핑정보
    private final Map<String, Object> handlerMappingMap = new HashMap<>();  //Controller v1~v4 다 지원하기위해 Obejct를 map의 두번째 인자로 둠
    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
        Object handler = getHandler(request); //핸들러 매핑하는 부분
        if (handler == null) {
            response.setStatus(HttpServletResponse.SC_NOT_FOUND); //페이지가 없거나 못찾으면 404에러 보내줌
            return;
        }
        //ControllerV3HandlerAdapter
        MyHandlerAdapter adapter = getHandlerAdapter(handler); //핸들러를 처리할 수 있는 어댑터 조회

        ModelView mv = adapter.handle(request, response, handler);// 어댑터 호출
        //어댑터는 handler(컨트롤러)를 호출하고, 그 결과를 어댑터에 맞추어 반환한다.

        String viewName = mv.getViewName(); //논리이름 new-form
        MyView view = viewResolver(viewName);

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

    private MyHandlerAdapter getHandlerAdapter(Object handler){
    // handler를 처리할수 있는 어댑터를 adapter.supports(handler)를 통해서 찾는다. handlerrk ControllerV3 인터페이스를 구현했다면 ControllerV3HandlerAdapter객체가 반환된다.

        for (MyHandlerAdapter adapter : handlerAdapters) {
            if (adapter.supports(handler)) {
                return adapter;
            }
        }
        throw new IllegalArgumentException("handler adapter를 찾을 수 없습니다. handler = "+ handler);
    }

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

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

컨트롤러 -> 어댑터

이전에는 컨트롤러를 직접 매핑해서 사용했다.
이젠 어댑터를 사용하므로, 컨트롤러 뿐만 아니라 어댑터가 지원하기만 하면 어떤것이라도 URL에 매핑해서 사용할 수 있다. 그래서 이름 변경함.

📌 유연한 컨트롤러2 - v5

  • 지금까지는 V3 컨트롤러를 사용할 수 있는 어댑터와 ControllerV3만 들어있다.
  • ControllerV4를 사용할 수 있도록 기능을 추가해보자

FrontControllerServlet5에 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()); //V4 추가
}

ControllerV4HandlerAdapter

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

public class ControllerV4HandlerAdapter implements MyHandlerAdapter {
    @Override
    public boolean supports(Object handler) { //handler가 ControllerV4인 경우에만 처리
        return (handler instanceof ControllerV4);
    }

    @Override
    public ModelView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws ServletException, IOException {
    	//실행 로직
        // handler를 ControllerV4로 캐스팅하고, paramMap, model을 만들어서 해당 컨트롤러를 호출한다. 그리고 viewNamedmf 반환 받는다.	
    
        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, request.getParameter(paramName)));
        return paramMap;
    }
}

어댑터 변환(중요)

  //어댑터 변환 하는 부분
        ModelView mv = new ModelView(viewName);
        mv.setModel(model);

        return mv;

어댑터가 호출하는 ControllerV4는 뷰의 이름을 반환한다.
그런데 어댑터는 뷰의 이름이 아니라 ModelView를 반환해야 한다.
ControlelrV4는 뷰의 이름을 반환했지만, 어댑터는 이것을 ModelView로 만들어서 형식을 맞추어 반환한다. ---> 바로 이것이, 어댑터가 꼭 필요한 이유이다!!!

어댑터와 ControllerV4

public interface ControllerV4 {
      String process(Map<String, String> paramMap, Map<String, Object> model);
  }
  public interface MyHandlerAdapter {
      ModelView handle(HttpServletRequest request, HttpServletResponse response,
  Object handler) throws ServletException, IOException;
  }

📌 v1~v5 정리

v1: 프론트 컨트롤러를 도입

  • 기존 구조를 최대한 유지하면서 프론트 컨트롤러를 도입하였다.

v2: View 분류

  • 단순히 반복되는 뷰 로직을 분리하였다.

v3: Model 추가

  • 서블릿 종속성 제거
  • 뷰 이름 중복 제거

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

  • v3과 거의 비슷
  • 구현 입장에서 ModelView를 직접 생성해서 반환하지 않도록 편리한 인터페이스 제공

v5: 유연한 컨트롤러

  • 어댑터 도입
  • 어댑터를 추가해서 프레임워크를 유연하고 확장성 있게 설계

  • 만약 애노테이션을 사용해서 컨트롤러를 편리하게 사용하려면? -> 애노테이션을 지원하는 어댑터를 추가하면 된다.
  • 곧 배울 스프링 MVC 학습한 이 구조와 거의 같은 구조이다!!!
profile
somyeong
공부한 내용 잊어버리지 않게 기록하는 공간!
이전 포스트

[Spring] MVC 1편 - 03. 서블릿, JSP, MVC패턴

다음 포스트

[Spring] MVC 1편 - 05. 스프링 MVC - 구조 이해

post-custom-banner

0개의 댓글