[MVC] 프론트 컨트롤러 패턴

 

 

 

 

🧐 들어가기에 앞서

앞으로 등장하는 컨트롤러(Controller)는 MVC 패턴에서의 Controller를 의미합니다.

이때 Controller의 역할은 다음과 같습니다.

• HTTP 요청을 받아파라미터를 검증합니다.
• 비즈니스 로직을 실행합니다. (이때 보통 Service 계층의 클래스를 통해 실행합니다.)
• 뷰(View)에 전달할 결과 데이터를 조회하여 모델(Model)에 보관합니다.

 

 

 

 

 

 

 

 

 

 

🧐 프론트 컨트롤러 패턴을 사용하지 않았을 때의 문제점

프론트 컨트롤러 패턴에 대해 알아보기 전에, 프론트 컨트롤러를 왜 써야 하는지, 사용하지 않으면 어떤 문제가 발생하는지 알아보도록 하겠습니다.

 

간단한 회원 관리 애플리케이션을 통해 살펴보도록 하겠습니다.

 

우선 요청이 들어오면 회원 가입 화면을 보여주는 Controller 입니다.

 

👉  회원 가입 화면을 보여주는 Controller

@WebServlet(name = "mvcMemberFormServlet", urlPatterns = "/servlet-mvc/members/new-form")
public class MvcMemberFormServlet extends HttpServlet {

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // VIEW PATH 설정
        String viewPath = "/WEB-INF/views/new-form.jsp";
        RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);

        // FORWARD, 다른 서블릿이나 jsp로 이동할 수 있는 기능, 서버 내부에서 다시 호출이 발생
        dispatcher.forward(request, response);
    }
}

 

 

 

 

 

 

👉  회원 정보를 저장하는 Controller 

@WebServlet(name = "mvcMemberSaveServlet", urlPatterns = "/servlet-mvc/members/save")
public class MvcMemberSaveServlet extends HttpServlet {

    private final MemberRepository memberRepository = MemberRepository.getInstance();

    @Override
    protected void service(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);

        // VIEW PATH 설정
        String viewPath = "/WEB-INF/views/save-result.jsp";

        // FORWARD
        RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
        dispatcher.forward(request, response);
    }
}

 

 

 

 

 

 

👉  저장된 회원들의 목록을 보여주는 Controller

@WebServlet(name = "mvcMemberListServlet", urlPatterns = "/servlet-mvc/members")
public class MvcMemberListServlet extends HttpServlet {

    private final MemberRepository memberRepository = MemberRepository.getInstance();

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        List<Member> members = memberRepository.findAll();

        // Model 에 데이터 보관
        request.setAttribute("members", members);

        // VIEW PATH 설정
        String viewPath = "/WEB-INF/views/members.jsp";

        // FORWARD
        RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
        dispatcher.forward(request, response);
    }
}

 

 

 

 

 

위 코드들을 살펴보면 다음과 같은 코드의 중복이 있다는 것을 알 수 있습니다.

// VIEW PATH 설정
String viewPath = "***";

// FORWARD
RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
dispatcher.forward(request, response);

 

또한 HttpServletRequest request, HttpServletResponse response는 사용하지 않는 경우도 있으며, 심지어 response는 한번도 사용하지 않았습니다.

 

 

이러한 이유로 인해, 기능이 복잡해지고 프로젝트의 규모가 커질 수록 공통으로 처리해주어야 하는 부분이 계속해서 증가할 것입니다.

결국은 공통되는 기능을 처리하기가 어려워진다는 문제가 발생합니다.

 

 

이러한 문제를 프론트 컨트롤러 패턴을 도입함으로써 해결할 수 있습니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

🧐 프론트 컨트롤러 패턴

컨트롤러 호출 전에 공통되는 기능을 처리하기 위한 컨트롤러를 사용하는 패턴을 의미합니다.

 

이때 사용되는 컨트롤러는 모든 요청이 처음으로 들어오는 입구의 역할을 하게 되며, 이를 프론트 컨트롤러라 부릅니다.

 

그림을 통해 알아보도록 하겠습니다. 

(사용되는 그림은 김영한 선생님의 스프링 MVC 1편 - 백엔드 웹 개발 핵심 기술의 자료에서 발췌하였습니다.)

 

프론트 컨트롤러 도입 전에는 아래와 같이 각각의 컨트롤러마다 공통되는 기능과 추가적인 기능을 모두 작성하여야 했습니다.

 

 

 

 

 

그러나 프론트 컨트롤러 도입 이후에는 아래와 같이 프론트 컨트롤러에서 공통 기능을 수행한 뒤, 각각의 요청에 대응되는 컨트롤러를 호출함으로써 공통 기능의 처리가 가능해집니다.

 

 

 

 

위 그림을 통해 알 수 있듯이, 프론트 컨트롤러 패턴은 아래와 같은 특징을 갖습니다.

 

 

 

👉 프론트 컨트롤러 패턴의 특정

프론트 컨트롤러 서블릿 하나를 통해 클라이언트의 모든 요청을 받습니다.

프론트 컨트롤러는 요청(Request)에 매핑(mapping)되는 컨트롤러를 찾아서 호출합니다.

모든 요청의 입구가 프론트 컨트롤러가 됩니다.

프론트 컨트롤러에서는 공통되는 로직을 처리할 수 있습니다.

또한 프론트 컨트롤러를 제외한 나머지 컨트롤러는 서블릿을 사용할 필요가 없어집니다.
(프론트 컨트롤러에서 단순 메서드를 호출하는 것을 통해 다른 컨트롤러들을 호출할 수 있기 때문입니다.)

 

 

 

 

 

스프링 웹 MVC도 Front Controller 패턴을 사용하며,
이때 DispatcherServlet 이 Front Controller의 역할을 수행합니다.

 

 

 

 

 

 

 

 

 

 

 

 

🧐 프론트 컨트롤러 패턴의 적용

앞서 살펴본 코드에 대하여, 프론트 컨트롤러 패턴을 적용하며 코드를 개선하는 과정을 통해 프론트 컨트롤러 패턴에 대해 학습해 보도록 하겠습니다.

 

창 두 개를 띄운 후, 이전 버전과 비교해 가며 보는 것을 추천드립니다.

 

 

 

 

 

 

📕 V1: 요청(Request)에 매핑(Mapping)되는 컨트롤러를 찾아서 호출하는 프론트 컨트롤러

V1에서는 다음과 같은 코드의 개선이 이루어집니다.

모든 요청에 대해서 프론트 컨트롤러 서블릿이 해당 요청에 매핑되는 컨트롤러를 찾아서 호출하게 됩니다.

프론트 컨트롤러 이외의 다른 컨트롤러에서는 서블릿을 사용하지 않게 됩니다.

 

 

 

 

 

 

 

V1의 최종적인 구조는 다음과 같습니다.

(구조 자료 역시 김영한 선생님의 스프링 MVC 1편 - 백엔드 웹 개발 핵심 기술의 자료에서 발췌하였습니다.)

 

 

 

 

 

 

 

프론트 컨트롤러 이외의 다른 컨트롤러에서는 서블릿을 사용하지 않도록 만들기 위해, 아래와 같이 서블릿과 비슷한 생김새를 갖는 Controller 인터페이스를 선언하겠습니다.

public interface ControllerV1 {

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

 

(프론트 컨트롤러를 제외한) 각 컨트롤러는 해당 인터페이스를 구현합니다.

 

프론트 컨트롤러에서는 해당 인터페이스를 구현한 컨트롤러들 중 요청에 매핑되는 컨트롤러를 찾아 호출하는 일관적인 로직을 통해 여러 요청을 처리할 수 있습니다.

 

 

 

 

 

 

 

👉  회원 가입 화면을 보여주는 Controller V1

public class MemberFormControllerV1 implements ControllerV1 {

    @Override
    public void process(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // VIEW PATH 설정
        String viewPath = "/WEB-INF/views/new-form.jsp";
        RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);

        // FORWARD, 다른 서블릿이나 jsp로 이동할 수 있는 기능, 서버 내부에서 다시 호출이 발생
        dispatcher.forward(request, response);
    }
}

 

 

 

 

 

 

 

👉  회원 정보를 저장하는 Controller V1

public class MemberSaveControllerV1 implements ControllerV1 {

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

        // VIEW PATH 설정
        String viewPath = "/WEB-INF/views/save-result.jsp";

        // FORWARD
        RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
        dispatcher.forward(request, response);
    }
}

 

 

 

 

 

 

 

👉  저장된 회원들의 목록을 보여주는 Controller V1

public class MemberListControllerV1 implements ControllerV1 {

    private final MemberRepository memberRepository = MemberRepository.getInstance();

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

        // Model 에 데이터 보관
        request.setAttribute("members", members);

        // VIEW PATH 설정
        String viewPath = "/WEB-INF/views/members.jsp";

        // FORWARD
        RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
        dispatcher.forward(request, response);
    }
}

 

위 세 코드 모두에서 process() 메서드 내부에 들어있는 로직은 이전과 바뀐 것이 없습니다.

 

그러나 이들은 이제 HttpServlet을 상속받지 않고 구현되었기 때문에 더이상 Servlet이 아닙니다. 

 

이제 프론트 컨트롤러를 구현하여, 들어온 요청에 매핑되는 Controller를 찾아 호출하도록 하겠습니다.

 

 

 

 

 

 

 

 

👉 Front Controller V1

@WebServlet(name = "frontControllerServletV1", urlPatterns = "/front-controller/v1/*")
public class FrontControllerServletV1 extends HttpServlet {

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

    /**
     * 프론트 컨트롤러 생성 시 요청(Request)별로 매핑(Mapping)되는 컨트롤러(Controller) 등록
     */
    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("---------- [FRONT CONTROLLER V1 실행] ----------");

        String requestURI = request.getRequestURI();  // 요청 URI 가져오기

        // 요청(Request)에 매핑(Mapping)되는 컨트롤러(Controller) 가져오기
        ControllerV1 controller = getController(requestURI);
        if (controller == null) {
            response.setStatus(HttpServletResponse.SC_NOT_FOUND);  // 404 NOT FOUND
            return;
        }
        
        // Controller 호출
        controller.process(request, response);
    }

    private ControllerV1 getController(String requestURI) {
        return controllerMap.get(requestURI);
    }
}

 

모든 요청에 대해 Front Controller가 동작하도록 하기 위해서는 urlPatterns를 "*"로 설정하여야 하겠지만, 이전 버전들을 유지시키며 코드를 개선시켜 나갈 것이기 때문에 비교를 위해 /front-controller/v1 의 하위 경로들에 대한 모든 요청에 대해서만 FrontControllerServletV1이 요청을 처리하도록 구현하였습니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

📙 V2 - View 분리 (View Path 설정과 Dispatcher.forward() 중복의 개선)

V2 에서는 다음 코드의 중복을 개선해 보도록 하겠습니다.

// VIEW PATH 설정
String viewPath = "***";

// FORWARD
RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
dispatcher.forward(request, response);

해당 부분의 분리를 위해 뷰(View)의 처리를 담당하는 객체를 만들도록 하겠습니다.

 

 

 

V2의 최종적인 구조는 다음과 같습니다.

이전까지는 Controller에서 JSP를 직접 반환하였습니다.

 

 

 

그러나 V2에서는 Controller에서는 MyView를 Front Controller에 반환하게 한 뒤,

FrontContrller에서 MyView.render()를 호출하여 JSP를 반환합니다.

 

 

 

 

 

 

👉 MyView

public class MyView {

    private String viewPath;

    public MyView(String viewPath) {
        // VIEW PATH 설정
        this.viewPath = viewPath;
    }

    public void render(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // FORWARD
        RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
        dispatcher.forward(request, response);
    }
}

 

이전에 중복되었던 코드들이 MyView에서 공통으로 처리되는 것을 알 수 있습니다.

 

 

 

 

 

 

 

 

👉 ControllerV2

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

V1에서는 반환 타입이 없었으나, 이제는 MyView를 반환하도록 변경되었습니다.

 

 

 

 

 

 

 

 

 

👉  회원 가입 화면을 보여주는 Controller V2

public class MemberFormControllerV2 implements ControllerV2 {

    @Override
    public MyView process(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // VIEW PATH 설정
        String viewPath = "/WEB-INF/views/new-form.jsp";
        return new MyView(viewPath);
    }
}

 

RequestDispatcher.forward() 를 호출한 부분이 사라지고, MyView를 반환하는 것으로 코드가 개선된 것을 알 수 있습니다.

 

 

 

 

 

 

 

 

 

👉  회원 정보를 저장하는 Controller V2

public class MemberSaveControllerV2 implements ControllerV2 {

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

        // VIEW PATH 설정
        String viewPath = "/WEB-INF/views/save-result.jsp";
        return new MyView(viewPath);
    }
}

 

 

 

 

 

 

 

 

 

👉  저장된 회원들의 목록을 보여주는 Controller V2

public class MemberListControllerV2 implements ControllerV2 {

    private final MemberRepository memberRepository = MemberRepository.getInstance();

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

        // Model 에 데이터 보관
        request.setAttribute("members", members);

        // VIEW PATH 설정
        String viewPath = "/WEB-INF/views/members.jsp";

        return new MyView(viewPath);
    }
}

 

 

 

 

 

 

 

 

 

👉 Front Controller V2

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

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

    /**
     * 프론트 컨트롤러 생성 시 요청(Request)별로 매핑(Mapping)되는 컨트롤러(Controller) 등록
     */
    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("---------- [FRONT CONTROLLER V2 실행] ----------");

        String requestURI = request.getRequestURI();  // 요청 URI 가져오기

        // 요청(Request)에 매핑(Mapping)되는 컨트롤러(Controller) 가져오기
        ControllerV2 controller = getController(requestURI);
        if (controller == null) {
            response.setStatus(HttpServletResponse.SC_NOT_FOUND);  // 404 NOT FOUND
            return;
        }

        // Controller 호출
        MyView view = controller.process(request, response);
        
        // V2 추가
        view.render(request, response);
    }

    private ControllerV2 getController(String requestURI) {
        return controllerMap.get(requestURI);
    }
}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

📗 V3 - Model 추가 (컨트롤러에서 Sevlet 종속성 제거와 View 이름의 중복 제거)

V3 에서는 컨트롤러에서 서블릿으로의 종속성을 제거하면서, 뷰 이름의 중복도 제거해 보도록 하겠습니다.

 

 

 

👉 Servlet 종속성 제거

컨트롤러에서 HttpServletRequest와 HttpServletResponse을 사용하는 대신

요청 파라미터 정보를 Map을 통해 넘기도록 하면 HttpServletRequest에 대한 의존성을 없앨 수 있습니다.

또한 request에서 setAttribute를 통해 데이터를 보관하는 대신, 별도의 Model 객체를 만들어 반환함으로써 의존성을 없앨 수 있습니다.

 

또한 현재 컨트롤러에서는 HttpServletResponse를 사용하지 않기 때문에 이 역시 의존성을 없앨 수 있습니다.

 

 

 

 

 

👉 View 이름의 중복 제거

현재 컨트롤러에서 지정하는 뷰 이름에는 아래처럼 중복이 있는 것을 확인할 수 있습니다.

// [/WEB-INF/views/] 가 중복
String viewPath = "/WEB-INF/views/members.jsp";
String viewPath = "/WEB-INF/views/new-form.jsp";
String viewPath = "/WEB-INF/views/save-result.jsp";

 

V3에서는 컨트롤러는 뷰의 논리적인 이름만 반환하고, 실제 물리적인 위치는 프론트 컨트롤러에서 처리하도록 변경해 보도록 하겠습니다.

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

 

 

 

 

 

V3의 최종적인 구조는 다음과 같습니다.

 

 

 

 

 

 

 

 

👉 ViewModel

/**
 * View 와, View에서 사용할 Model 담당
 */
public class ModelView {

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

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

    public String viewName() {
        return viewName;
    }

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

    public void setAttribute(String key, Object value) {
        model.put(key, value);
    }
}

 

 

 

 

 

 

 

 

 

👉 ControllerV3

public interface ControllerV3 {

    ModelView process(Map<String, String> request);
}

ControllerV3에서는 HttpServletRequest 대신 Map을 통해 Request Parameter를 받으며,

반환 타입은 MyView에서 ModelView로 변경된 것을 알 수 있습니다.

 

 

 

 

 

 

 

 

 

👉  회원 가입 화면을 보여주는 Controller V3

public class MemberFormControllerV3 implements ControllerV3 {

    @Override
    public ModelView process(Map<String, String> request) {
        return new ModelView("new-form");
    }
}

view의 이름이 /WEB-INF/views/new-form.jsp 에서 new-form으로 변경된 것을 알 수 있습니다.

 

 

 

 

 

 

 

 

 

 

👉  회원 정보를 저장하는 Controller V3

public class MemberSaveControllerV3 implements ControllerV3 {

    private final MemberRepository memberRepository = MemberRepository.getInstance();

    @Override
    public ModelView process(Map<String, String> request) {
        String username = request.get("username");
        int age = Integer.parseInt(request.get("age"));

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

        // Model 에 데이터 보관
        ModelView modelView = new ModelView("save-result");
        modelView.setAttribute("member", member);
        return modelView;
    }
}

 

 

 

 

 

 

 

 

 

 

👉  저장된 회원들의 목록을 보여주는 Controller V3

public class MemberListControllerV3 implements ControllerV3 {

    private final MemberRepository memberRepository = MemberRepository.getInstance();

    @Override
    public ModelView process(Map<String, String> request) {
        List<Member> members = memberRepository.findAll();

        // Model 에 데이터 보관
        ModelView modelView = new ModelView("members");
        modelView.setAttribute("members", members);
        return modelView;
    }
}

 

 

 

 

 

 

 

 

 

 

 

👉 Front Controller V3

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

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

    /**
     * 프론트 컨트롤러 생성 시 요청(Request)별로 매핑(Mapping)되는 컨트롤러(Controller) 등록
     */
    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("---------- [FRONT CONTROLLER V3 실행] ----------");

        String requestURI = request.getRequestURI();  // 요청 URI 가져오기

        // 요청(Request)에 매핑(Mapping)되는 컨트롤러(Controller) 가져오기
        ControllerV3 controller = getController(requestURI);
        if (controller == null) {
            response.setStatus(HttpServletResponse.SC_NOT_FOUND);  // 404 NOT FOUND
            return;
        }

        // (1) HttpServletRequest -> Map 으로 변환
        HashMap<String, String> requestParamMap = createParamMap(request);

        // Controller 호출
        ModelView modelView = controller.process(requestParamMap);

        // (2) View 생성
        MyView view = viewResolver(modelView.viewName());

        // (3) Model 추가
        view.render(modelView.model(), request, response);
    }

    private static HashMap<String, String> createParamMap(HttpServletRequest request) {
        HashMap<String, String> requestParamMap = new HashMap<>();
        request.getParameterNames()
                .asIterator()
                .forEachRemaining(it -> requestParamMap.put(it, request.getParameter(it)));
        return requestParamMap;
    }

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

    private ControllerV3 getController(String requestURI) {
        return controllerMap.get(requestURI);
    }
}

추가된 부분은 다음과 같습니다.

 

우선 (1)에서는 HttpServlerRequest를 Map으로 변환하여 Controller를 호출합니다.

 

이후 (2)에서 반환된 ModelView에서 ViewName의 정보를 가지고 MyView를 생성합니다.

 

(3)에서는 view.render() 시 ModelView에 담긴 Model의 정보를 함께 전달합니다.

 

 

 

 

 

 

MyView는 아래와 같이 메서드가 추가됩니다.

 

 

 

 

👉 MyView

public class MyView {

    private String viewPath;

    public MyView(String viewPath) {
        // VIEW PATH 설정
        this.viewPath = viewPath;
    }

    public void render(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // FORWARD
        RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
        dispatcher.forward(request, response);
    }

    public void render(Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // Model -> Attribute
        modelToRequestAttribute(model, request);

        // FORWARD
        RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
        dispatcher.forward(request, response);
    }

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

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

📘 V4 - 사용하기 쉬운 실용적인 컨트롤러

V3에서 대부분의 개선이 이루어졌으나, 항상 ModelView 객체를 생성하고 반환하는 코드를 컨트롤러마다 작성해 주어야 했습니다.

 

V4에서는 이러한 중복 작업의 귀찮음을 개선해 보도록 하겠습니다.

V4 에서는 ModelView 대신 View의 이름만 반환하도록 개선됩니다.

 

 

 

 

 

 

 

V4의 최종적인 구조는 다음과 같습니다.

 

 

 

 

 

 

 

 

 

👉 ControllerV4

public interface ControllerV4 {

    String process(Map<String, String> request, Map<String, Object> model);
}

 

 

 

 

 

 

 

👉  회원 가입 화면을 보여주는 Controller V4

public class MemberFormControllerV4 implements ControllerV4 {

    @Override
    public String process(Map<String, String> request, Map<String, Object> model) {
        return "new-form";
    }
}

 

 

 

 

 

 

 

 

 

 

 

👉  회원 정보를 저장하는 Controller V4

public class MemberSaveControllerV4 implements ControllerV4 {

    private final MemberRepository memberRepository = MemberRepository.getInstance();

    @Override
    public String process(Map<String, String> request, Map<String, Object> model) {
        String username = request.get("username");
        int age = Integer.parseInt(request.get("age"));

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

        // Model 에 데이터 보관
        model.put("member", member);
        return "save-result";
    }
}

 

 

 

 

 

 

 

 

 

 

👉  저장된 회원들의 목록을 보여주는 Controller V4

public class MemberListControllerV4 implements ControllerV4 {

    private final MemberRepository memberRepository = MemberRepository.getInstance();

    @Override
    public String process(Map<String, String> request, Map<String, Object> model) {
        List<Member> members = memberRepository.findAll();

        // Model 에 데이터 보관
        model.put("members", members);

        return "members";
    }
}

 

 

 

 

 

 

 

 

 

 

 

👉 Front Controller V4

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

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

    /**
     * 프론트 컨트롤러 생성 시 요청(Request)별로 매핑(Mapping)되는 컨트롤러(Controller) 등록
     */
    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 {
        System.out.println("---------- [FRONT CONTROLLER V4 실행] ----------");

        String requestURI = request.getRequestURI();  // 요청 URI 가져오기

        // 요청(Request)에 매핑(Mapping)되는 컨트롤러(Controller) 가져오기
        ControllerV4 controller = getController(requestURI);
        if (controller == null) {
            response.setStatus(HttpServletResponse.SC_NOT_FOUND);  // 404 NOT FOUND
            return;
        }

        // HttpServletRequest -> Map 으로 변환
        Map<String, String> requestParamMap = createParamMap(request);

        // Model 생성 - V4 추가
        HashMap<String, Object> model = new HashMap<>();

        // Controller 호출
        String viewName = controller.process(requestParamMap, model);

        // View 생성
        MyView view = viewResolver(viewName);
        
        view.render(model, request, response);
    }

    private static HashMap<String, String> createParamMap(HttpServletRequest request) {
        HashMap<String, String> requestParamMap = new HashMap<>();
        request.getParameterNames()
                .asIterator()
                .forEachRemaining(it -> requestParamMap.put(it, request.getParameter(it)));
        return requestParamMap;
    }

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

    private ControllerV4 getController(String requestURI) {
        return controllerMap.get(requestURI);
    }
}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

📓 V5: 어댑터 패턴을 적용한 유연한 컨트롤러

지금까지 ControllerV1 부터 ControllerV4까지 인터페이스를 총 4개를 만들었습니다.

 

사람마다 ControllerV3이 좋을 수도, ControllerV4가 좋을 수도 있기 때문에, 어떠한 컨트롤러 인터페이스를 구현하든지 상관 없이 모두 지원하기 위해서 어댑터 패턴을 도입하도록 하겠습니다.

 

프론트 컨트롤러에서 지원되지 않는 컨트롤러 형식을 지원하기 위해, 중간에 어댑터를 추가합니다.

즉 어댑터는 프론트 컨트롤러와 프론트 컨트롤러에서 지원되지 않는 타입의 컨트롤러 사이에서 이들을 맞춰주는 역할을 수행합니다.

 

 

V5에서는 어댑터를 통해 컨트롤러(Controller)가 아니더라도 해당하는 종류의 어뎁터만 있으면 이들을 다 처리(handle)할 수 있기 때문에, 컨트롤러 대신 핸들러(Handler)라는 용어를 사용하도록 하겠습니다.

 

 

 

 

 

 

 

V5의 최종적인 구조는 다음과 같습니다.

핸들러 매핑 정보는 요청(Request)에 매핑(Mapping)되는 핸들러(Hanlder = Controller)에 대한 정보를 의미합니다.

핸들러 어댑터는 핸들러(= 컨트롤러)를 처리(내부에서 핸들러의 메서드를 호출)합니다.

 

 

 

 

 

 

 

 

 

👉 MyHandlerAdapter

public interface MyHandlerAdapter {

    /**
     * 주어진 handler(Controller)를 처리할 수 있다면 true를 반환한다.
     */
    boolean supports(Object handler);

    /**
     * 어댑터는 HttpServletRequest 와 HttpServletResponse 를 가지고
     * 최종적으로 실제 handler(Controller)의 메서드를 호출하여 요청에 응답합니다.
     * -
     * ex) handler.process(request, response);
     */
    ModelView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws ServletException, IOException;
}

 

 

 

 

👉 ControllerV3를 지원하는 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) throws ServletException, IOException {
        ControllerV3 controller = (ControllerV3) handler;

        // Request Param 세팅
        Map<String, String> params = createParamMap(request);

        return controller.process(params);
    }

    private static Map<String, String> createParamMap(HttpServletRequest request) {
        Map<String, String> params = new HashMap<>();
        request.getParameterNames()
                .asIterator()
                .forEachRemaining(it -> params.put(it, request.getParameter(it)));
        return params;
    }
}

 

 

 

 

 

 

👉 ControllerV4를 지원하는 ControllerV4HandlerAdapter

public class ControllerV4HandlerAdapter implements MyHandlerAdapter {

    @Override
    public boolean supports(Object handler) {
        // ControllerV3 타입이면 지원 가능하다.
        return (handler instanceof ControllerV4);
    }

    @Override
    public ModelView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws ServletException, IOException {
        ControllerV4 controller = (ControllerV4) handler;

        // Request Param 세팅
        Map<String, String> params = createParamMap(request);
        Map<String, Object> model = new HashMap<>();

        String viewName = controller.process(params, model);

        ModelView modelView = new ModelView(viewName);
        modelView.setModel(model);

        return modelView;
    }

    private static Map<String, String> createParamMap(HttpServletRequest request) {
        Map<String, String> params = new HashMap<>();
        request.getParameterNames()
                .asIterator()
                .forEachRemaining(it -> params.put(it, request.getParameter(it)));
        return params;
    }
}

 

 

 

 

 

 

 

 

👉 Front Controller V5

@WebServlet(name = "frontControllerServletV5", urlPatterns = "/front-controller/v5/*")
public class FrontControllerServletV5 extends HttpServlet {

    // 핸들러 매핑 정보 - 요청(Request) URI에 대응되는 핸들러(= Controller)를 가지고 있다.
    private final Map<String, Object> handlerMappingMap = new HashMap<>();

    // 핸들러들을 처리 가능한 핸들러 어댑터의 목록이다.
    private final List<MyHandlerAdapter> handlerAdapters = new ArrayList<>();

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

    /**
     * 프론트 컨트롤러 생성 시 요청(Request)별로 매핑(Mapping)되는 핸들러(= Controller) 등록
     */
    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());

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

    /**
     * 핸들러를 처리할 수 있는 HandlerAdapter 등록
     */
    private void initHandlerAdapters() {
        handlerAdapters.add(new ControllerV3HandlerAdapter());
        handlerAdapters.add(new ControllerV4HandlerAdapter());
    }

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("---------- [FRONT CONTROLLER V5 실행] ----------");

        // 요청(Request)에 매핑(Mapping)되는 핸들러(= Controller) 가져오기
        Object handler = getHandler(request);
        if (handler == null) {
            response.setStatus(HttpServletResponse.SC_NOT_FOUND);  // 404 NOT FOUND
            return;
        }

        // 조회된 Handler를 처리한 수 있는 HandlerAdapter 조회
        MyHandlerAdapter adapter = getHandlerAdapter(handler);

        // handler 처리 Adapter에 위임
        ModelView modelView = adapter.handle(request, response, handler);

        // View 생성
        MyView view = viewResolver(modelView.viewName());

        view.render(modelView.model(), request, response);
    }

    /**
     * 요청(Request)에 매핑(Mapping)되는 핸들러(=Controller) 가져오기
     */
    private Object getHandler(HttpServletRequest request) {
        return handlerMappingMap.get(request.getRequestURI());
    }

    /**
     * Handler를 처리한 수 있는 HandlerAdapter 조회
     */
    private MyHandlerAdapter getHandlerAdapter(Object handler) {
        return handlerAdapters.stream()
                .filter(it -> it.supports(handler))
                .findAny()
                .orElseThrow(() -> new IllegalArgumentException("Handler Adapter를 찾을 수 없습니다. handler=%s".formatted(handler)));
    }

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

 

 

 

V2, V1은 조금 귀찮아지기 때문에 생략하도록 하겠습니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

📘 Reference

스프링 MVC 1편 - 백엔드 웹 개발 핵심 기술 - 인프런 | 강의