[Spring] #4. MVC 프레임워크 만들기 (김영한_인프런_스프링MVC1)

bien·2023년 4월 18일

springMVC

Spring_MVC1

목록 보기

5/8

프론트 컨트롤러 패턴 소개

프론트 컨트롤러 도입 전

이전에는 공통 로직들을 각각의 컨트롤러에 전부 구현해야 했음.

프론트 컨트롤러 도입 후

서블릿으로 문지기 역할을 수행하는 Front Controller를 구현하면, 여기에 공통 로직을 두고 각각의 로직은 각 컨트롤러가 수행하도록 함.

FrontController 패턴 특징

프론트 컨트롤러 서블릿 하나로 클라이언트의 요청을 받음
프론트 컨트롤러가 요청에 맞는 컨트롤러를 찾아서 호출
이전처럼 고객 요청으로 서블릿 매핑을 통해 직접 요청되는게 아니라, 고객의 요청을 프론트 컨트롤러가 모두 받고 어떤 컨트롤러가 로직을 수행할지 연결해준다.
입구를 하나로!
공통 처리 가능
프론트 컨트롤러를 제외한 나머지 컨트롤러는 서블릿을 사용하지 않아도 됨.
클라이언트와 서버가 HTTP라는 통신 프르토콜을 통해 의사소통하기 위해서 클라이언트가 요구하는 핵심 비즈니스 로직 외에도 많은 절차가 필요했다. 서블릿은 이 부가적이고 공통적인 절차들을 대신 수행한다. URL 매핑을 통해 클라이언트에게서 요청이 들어오면, WAS 서버에서 처음 요청하는 곳이 서블릿이다. url 매핑과 같은 서블릿 작업들을 Front Controller에서 모두 공통적으로 수행하므로, 다른 컨트롤러들은 서블릿과 관련된 코드를 구현하지 않아도 된다.

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

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

프론트 컨트롤러 도입 -v1

프론트 컨트롤러 단계적 도입. 기존의 코드는 최대한 유지하면서, 프론트 컨트롤러를 도입하자. 먼저 구조를 맞추어 두고 점진적으로 리펙터링 할 예정!

개선할 때는 한번 에 하나씩 하는게 좋다. 구조 건들일 때는 구조만. 디테일 한 부분 개선할 때는 디테일 부분만. 준위가 다른(레벨이 다른)부분을 개선할 때는, 같은 부분만 고치고 나서 문제가 없을 때 세세한 부분 수정하는 방식으로 해야 한다. 한 번에 하면 짬뽕되어버린다!

v1 구조

controller 부분은 다형성을 구현해서 인터페이스로 만들예정.

ControllerV1

package hello.servlet.web.frontcontroller.v1;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public interface ControllerV1 {

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

서블릿과 비슷한 모양의 컨트롤러 인터페이스를 도입했다. 각 컨틀롤러들은 이 인터페이스를 구현하면 된다. 프론트 컨트롤러는 이 인터페이스를 호출해서 구현과 관계없이 로직의 일관성을 가져갈 수 있다.

이제 이 인터페이스의 구현체들을 만들어보자! 지금 단계에선 기존 로직을 최대한 유지하는게 핵심!

MmemberFormControllerV1 - 회원등록 컨트롤러

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

import hello.servlet.web.frontcontroller.v1.ControllerV1;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

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

MemberSaveControllerV1 - 회원 저장 컨트롤러

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

import hello.servlet.domain.member.Member;
import hello.servlet.domain.member.MemberRepository;
import hello.servlet.web.frontcontroller.v1.ControllerV1;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class MemberSaveControllerV1 implements ControllerV1 {

    private MemberRepository memberRepository = MemberRepository.getInstance();

    @Override
    public void process(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        String username = request.getParameter("username");
        int age = Integer.parseInt(request.getParameter("age"));

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

        request.setAttribute("member",member);

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

MemberListControllerV1 - 회원 목록 컨트롤러

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

import hello.servlet.domain.member.Member;
import hello.servlet.domain.member.MemberRepository;
import hello.servlet.web.frontcontroller.v1.ControllerV1;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;

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

내부 로직은 기존 서블릿과 거의 같다. 이제 프론트 컨트롤러를 만들어 보자.

FrontControllerServlet1 - 프론트 컨트롤러

package hello.servlet.web.frontcontroller.v1;

import hello.servlet.web.frontcontroller.v1.controller.MemberFormControllerV1;
import hello.servlet.web.frontcontroller.v1.controller.MemberListControllerV1;
import hello.servlet.web.frontcontroller.v1.controller.MemberSaveControllerV1;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

@WebServlet(name = "frontControllerServletV1", urlPatterns = "/front-controller/v1/*")
// v1 하위의 모든 url은 다 이 파일이 호출됨.
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);
    }
}

프론트 컨트롤러 분석

urlPatterns

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

controllerMap

key: 매핑 URL
value: 호출될 컨트롤러

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

JSP
JSP는 이전 mvc에서 사용했던 것을 그대로 사용한다.

실행

기존 서블릿, JSP로 만든 MVC와 동일하게 실행 되는 것을 확인할 수 있다.

View 분리 - v2

모든 컨트롤러에서 뷰로 이동하는 부분에 중복이 있고, 깔끔하지 않다.

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

뷰를 처리하는 객체 생성: 해당 부분을 깔끔하게 분리하자!

v2 구조

과거와 달리 컨트롤러에서 JSP로 직접 forward하지 않고, MyView라는 객체를 만들어서 프론트 컨트롤러에 반환하면 프론트 컨트롤러가 대신 render()를 호출하고 JSP로 forward 하도록 할 것!
-> 더이상 컨트롤러가 jsp forward를 고려하지 않아도 된다!

MyView

뷰 객체는 이후 다른 버전에서도 함께 사용하므로 패키지 위치를 frontcontroller에 두었다.

package hello.servlet.web.frontcontroller;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

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

package hello.servlet.web.frontcontroller.v2;

import hello.servlet.web.frontcontroller.MyView;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public interface ControllerV2 {

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

}

MemberFormControllerV2 -회원등록 폼

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

import hello.servlet.web.frontcontroller.MyView;
import hello.servlet.web.frontcontroller.v2.ControllerV2;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.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()를 직접 생성해서 호출하지 않아도 된다. 단순히 MyView 객체를 생성하고 거기에 뷰 이름만 넣고 반환하면 된다.

ControllerV1을 구현한 클래스와 controllerV2를 구현한 클래스를 비교해보면, 이 부분의 중복이 확실하게 제거된 것을 확인할 수 있다.

v1의 코드 3줄을 추출해서 MyView(viewPath) 구현체를 만들엇다. 이제 viewPath만 MyView객체에 넣어서 프론트 컨트롤러로 넣어주면 된다. 추상화의 위력이 참 대단한것 같다. ~~근데 내가 이렇게 뽑아내서 추상화 할 수 있을까? 코드 이해만 하는데도 머리 터지는줄 알앗따.~~

MemberSaveControllerV2 - 회원 저장

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

import hello.servlet.domain.member.Member;
import hello.servlet.domain.member.MemberRepository;
import hello.servlet.web.frontcontroller.MyView;
import hello.servlet.web.frontcontroller.v2.ControllerV2;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;


public class MemberSaveControllerV2 implements ControllerV2 {

    private MemberRepository memberRepository = MemberRepository.getInstance();

    @Override
    public MyView process(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        String username = request.getParameter("username");
        int age = Integer.parseInt(request.getParameter("age"));

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

        request.setAttribute("member",member);

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

MemberListControllerV2 - 회원 목록

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

import hello.servlet.domain.member.Member;
import hello.servlet.domain.member.MemberRepository;
import hello.servlet.web.frontcontroller.MyView;
import hello.servlet.web.frontcontroller.v2.ControllerV2;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;

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;

import hello.servlet.web.frontcontroller.MyView;
import hello.servlet.web.frontcontroller.v1.ControllerV1;
import hello.servlet.web.frontcontroller.v1.controller.MemberFormControllerV1;
import hello.servlet.web.frontcontroller.v1.controller.MemberListControllerV1;
import hello.servlet.web.frontcontroller.v1.controller.MemberSaveControllerV1;
import hello.servlet.web.frontcontroller.v2.controller.MemberFormControllerV2;
import hello.servlet.web.frontcontroller.v2.controller.MemberListControllerV2;
import hello.servlet.web.frontcontroller.v2.controller.MemberSaveControllerV2;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

@WebServlet(name = "frontControllerServletV2", urlPatterns = "/front-controller/v2/*")
// v1 하위의 모든 url은 다 이 파일이 호출됨.
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);
    }
}

ContorllerV2의 반환 타입이 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

1. 서블릿 종속성 제거

컨트롤러에 HttpServletRequet, HttpServletResponse는 필요없다.
지금 request, response는 데이터를 꺼내는 일만 하고 있다. 요청 파라미터 정보는 자바의 Map으로 대신 넘기도록 하면 지금 구조에서는 컨트롤러가 서블릿 기술을 몰라도 동작할 수 있다.
그리고 request 객체를 Model로 사용하는 대신에 별도의 Model 객체를 만들어서 반환하면 된다. 이렇게 하면 구현 코드도 매우 단순해지고, 테스트 코드 작성이 쉽다.
=> ModelView 객체 생성: 데이터를 꺼내는 역할만 하는 서블릿에 종속된 현재 상황에서, 수문장이 데이터를 모델에 담아 전송하도록 변경

2. 뷰 이름 중복 제거

컨트롤러에서 지정하는 뷰 이름에 중복이 많다. 컨트롤러는 뷰의 논리 이름을 반환하고, 실제 물리 위치의 이름은 프론트 컨트롤러에서 처리하도록 단순화하자. 이렇게 해두면 향후 뷰의 폴더 위치가 함께 이동해도 프론트 컨트롤러만 고치면 된다.

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

=> viewResolver(): 앞의 공통되는 부분을 프론트 컨트롤러에서 String으로 더해준다. ~~간단하게 반복되고 오류 가능성이 높은 부분을 해소할 수 있어서 명쾌하게 느껴지는 부분이었다.~~

변경이 있을 때 한 부분만 수정하면 되게 설계 => 굉장히 설계를 잘한 것! (아니라면 개선점이 있다는 의미!)

v3 구조

V2에서는 컨트롤러가 view를 반환했다. 이번 V3에서는 view와 model이 섞여있는 ModelView라는 객체를 반환할 것이다. 또한 논리이름만 반환할 예정이므로, viewResolver에서 이름을 수정해서 MyView를 반환할 예정이다.

ModelView

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

참고로 ModelView객체는 다른 버전에서도 사용하므로 패키지를 frontcontroller에 둔다.

package hello.servlet.web.frontcontroller;

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

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 객체를 가지고 있다. model은 단순히 map으로 되어있으므로 컨트롤러에서 뷰에 필요한 데이터를 key, value로 넣어주면 된다.

ControllerV3

package hello.servlet.web.frontcontroller.v3;

import hello.servlet.web.frontcontroller.ModelView;

import java.util.Map;

public interface ControllerV3 {

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

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

MemberFormControllerV3 - 회원 등록 폼

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

import hello.servlet.web.frontcontroller.ModelView;
import hello.servlet.web.frontcontroller.v3.ControllerV3;

import java.util.Map;

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

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

MemberServiceControllerV3 - 회원 저장

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

import hello.servlet.domain.member.Member;
import hello.servlet.domain.member.MemberRepository;
import hello.servlet.web.frontcontroller.ModelView;
import hello.servlet.web.frontcontroller.v3.ControllerV3;

import java.util.Map;

public class MemberSaveControllerV3 implements ControllerV3 {
    
    @Override
    public ModelView process(Map<String, String> paraMap) {

        MemberRepository memberRepository = MemberRepository.getInstance();

        String username = paraMap.get("username");
        int age = Integer.parseInt(paraMap.get("age"));

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

        ModelView mv = new ModelView("save-result");
        mv.getModel().put("member", member);
        return mv;
    }
}

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

MemberListControllerV3 - 회원 목록

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

import hello.servlet.domain.member.Member;
import hello.servlet.domain.member.MemberRepository;
import hello.servlet.web.frontcontroller.ModelView;
import hello.servlet.web.frontcontroller.v3.ControllerV3;

import java.util.List;
import java.util.Map;

public class MemberListControllerV3 implements ControllerV3 {

    private MemberRepository memberRepository = MemberRepository.getInstance();

    @Override
    public ModelView process(Map<String, String> paraMap) {
        List<Member> members = memberRepository.findALl();
        ModelView mv = new ModelView("members");
        mv.getModel().put("members", members);

        return mv;
    }
}

FrontControllerServletV3

package hello.servlet.web.frontcontroller.v3;

import hello.servlet.web.frontcontroller.ModelView;
import hello.servlet.web.frontcontroller.MyView;
import hello.servlet.web.frontcontroller.v2.ControllerV2;
import hello.servlet.web.frontcontroller.v3.controller.MemberFormControllerV3;
import hello.servlet.web.frontcontroller.v3.controller.MemberListControllerV3;
import hello.servlet.web.frontcontroller.v3.controller.MemberSaveControllerV3;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

@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();// 논리이름 ex) new-form
        MyView view = viewResolver(viewName);

        view.render(mv.getModel(), 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;
    }
}

view.render(mv.getModel(), request, response)코드에서 컴파일 오류가 발생할 것이다. 다음 코드를 참고해서 MyView 객체에 필요한 메서드를 추가하자.

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

request에 model을 넣어주고 dispatcher로 forward 해준다.

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

뷰 리졸버

MyView view = viewResolver(viewName)
컨트롤러가 반환한 논리뷰 이름을 실제 물리 뷰 경로로 변경한다. 그리고 실제 물리 경로가 있는 MyView 객체를 반환한다.

논리 뷰 이름: members
물리 뷰 경로:/WEB-INF/views/members.jsp

왜 물리적인 경로를 분리했을까? -> 변경 요구 시, (수많은) 컨트롤러의 수정이 필요 없음.

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

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

MyView


import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Map;

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

실행

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

앞서 만든 v3 컨트롤러는 서블릿 종속성을 제거하고 뷰 경로의 중복을 제거하는 등, 잘 설계된 컨트롤러이다. 그런데 실제 컨트롤러 인터페이스를 구현하는 개발자 입장에서보면, 항상 ModelView 객체를 생성하고 반환해야 하는 부분이 조금은 번거롭다.
좋은 프레임워크는 아키텍처도 중요하지만, 그와 더불에 실제 개발자가 단순하고 편리하게 사용할 수 있어야 한다. 소위 실용성이 있어야 한다.
스프링은 구조적으로도 잘 만들어져 있는데, 원체 기능이 많아 되게 복잡함. 그러나 동시에 개발자들이 사용하기에도 매우 편리해 이렇게 많이 쓰이는 듯 하다!

이번에는 v3를 조금 변경해서 실제 구현하는 개발자들이 매우 편리하게 개발할 수 있는 v4 버전을 개발해보자.

v4 구조

기본적인 구조는 V3와 같다. 대신에 컨트롤러가 ModelView를 반환하지 않고, ViewName만 반환한다.

ControllerV4

package hello.servlet.web.frontcontroller.v4;

import java.util.Map;

public interface ControllerV4 {

    // /**하고 엔터하면 자동으로 만들어짐.
    /**
     *
     * @param paramMap
     * @param model
     * @return viewName
     */
    String process(Map<String, String> paramMap, Map<String, Object> model);

}

이번 버전은 인터페이스에 ModelView가 없다. model 객체는 파라미터로 전달되기 때문에 그냥 사용하면 되고, 결과로 뷰의 이름만 반환해주면 된다.
~~model의 참조변수(주소)를 클래스에 알려주므로, 해당 주소에 데이터를 저장할 수 있다. 다시 model을 retrun할 필요없다!~~

/** + 엔터 : param과 retrun에 대한 양식을 제공하는 주석이 생긴다

MemberFormControllerV4

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

import hello.servlet.web.frontcontroller.v4.ControllerV4;

import java.util.Map;

public class MemberFormControllerV4 implements ControllerV4 {

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

정말 단순하게 new-form이라는 뷰의 논리 이름만 반환하면 된다.

MemberSaveControllerV4

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

import hello.servlet.domain.member.Member;
import hello.servlet.domain.member.MemberRepository;
import hello.servlet.web.frontcontroller.ModelView;
import hello.servlet.web.frontcontroller.v3.ControllerV3;
import hello.servlet.web.frontcontroller.v4.ControllerV4;

import java.util.Map;

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.put("member", member)
모델이 파라미터로 전달되기 때문에, 모델은 직접 생성하지 않아도 된다.

MemberListControllerV4

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

import hello.servlet.domain.member.Member;
import hello.servlet.domain.member.MemberRepository;
import hello.servlet.web.frontcontroller.v4.ControllerV4;

import java.util.List;
import java.util.Map;

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;

import hello.servlet.web.frontcontroller.MyView;
import hello.servlet.web.frontcontroller.v4.controller.MemberFormControllerV4;
import hello.servlet.web.frontcontroller.v4.controller.MemberListControllerV4;
import hello.servlet.web.frontcontroller.v4.controller.MemberSaveControllerV4;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

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

FrontControllerServletV4는 이전 버전과 거의 동일하다.

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

뷰의 논리 이름을 직접 반환

String viewName = controller.process(paramMap, model);
MyView view = viewResolver(viewName);

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

정리
이번 버전의 컨트롤러는 매우 단순하고 실용적이다. 기존 구조에서 모델을 파라미터로 넘기고, 뷰의 논리이름을 반환한다는 작은 아이디어를 적용했을 뿐인데, 컨트롤러를 구현하는 개발자 입장에서 보면 이제 군더더기 없는 코드를 작성할 수 있다.
또한 중요한 사실은 여기가지 한번에 온 것이 아니라는 점이다. 프레임워크가 점진적으로 발전하는 과정 속에서 이런 방법도 찾을 수 있었다.

프레임워크나 공통 기능이 수고로워야 사용하는 개발자가 편리해진다.

공통되는 부분을 수문장을 지정해서 몰아준다는 아이디어가 참 좋은것 같다. 버전을 거쳐가면서 한부분씩 추출해 입구 부분이 수행하도록 수정하는데 코드가 훨씬 간결하고 이해하기 쉬워져서 좋다.

유연한 컨트롤러1 - v5

만약 (하나의 프로젝트 안에서) 어떤 개발자는 ControllerV3방식으로 개발하고 싶고, 어떤 개발자는 ControllerV4방식으로 개발하고 싶다면 어떻게 해야할까?
사용하고 싶은 컨트롤러 버전을 개발자가 마음대로 선택할 수 있게 바꿔보자!!!

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

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

어댑터 패턴

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

v5 구조

핸들러 어댑터 : 중간에 어댑터 역할을 하는 어댑터가 추가되었는데 이름이 핸들러 어댑터이다. 여기서 어댑터 역할을 해주는 덕분에 다양한 종류의 컨트롤러를 호출할 수 있다.
핸들러: 컨트롤러의 이름을 더 넓은 범위인 핸들러로 변경했다. 그 이유는 이제 어댑터가 있기 때문에 꼭 컨트롤러의 개념 뿐만 아니라 어떤 것이든 해당하는 종류의 어댑터만 있으면 다 처리할 수 있기 때문이다.

MyHandlerAdapter

어댑터는 이렇게 구현해야 한다는 어댑터용 인터페이스이다.

boolean spport(Object handler)

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

ModelView handle(HttpServletRequest request, HttpServletResponse response, Object handler)

어댑터는 실제 컨트롤러를 호출하고, 그 결과로 ModelView를 반환해야 한다.
실제 컨트롤러가 ModelView를 반환하지 못하면, 어댑터가 ModelView를 직접 생성해서라도 반환해야 한다.
이전에는 프론트 컨트롤러가 실제 컨트롤러를 호출했지만 이제는 이 어댑터를 통해서 실제 컨트롤러가 호출된다.

support(): 넘어온 핸들러가 내가 넘겨줄 컨트롤러랑 맞는지 확인하는 기능.
handle(): 넘어온 핸들러를 실제 컨트롤러에 보내 기능을 수행하도록 하는 기능.

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

ControllerV3HandlerAdapter

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

import hello.servlet.web.frontcontroller.ModelView;
import hello.servlet.web.frontcontroller.v3.ControllerV3;
import hello.servlet.web.frontcontroller.v5.MyHandlerAdapter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

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 {
        // Front에서 support를 통해 CV3가 맞는지 확인하고 이 메서드를 호출할 예정 -> 캐스팅 가능!
        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;
    }
}

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

ControllerV3을 처리할 수 있는 어댑터를 뜻한다.

        ControllerV3 controller = (ControllerV3) handler;

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

        return mv;

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

FrontControllerServletV5

package hello.servlet.web.frontcontroller.v5;

import hello.servlet.web.frontcontroller.ModelView;
import hello.servlet.web.frontcontroller.MyView;
import hello.servlet.web.frontcontroller.v3.controller.MemberFormControllerV3;
import hello.servlet.web.frontcontroller.v3.controller.MemberListControllerV3;
import hello.servlet.web.frontcontroller.v3.controller.MemberSaveControllerV3;
import hello.servlet.web.frontcontroller.v5.adapter.ControllerV3HandlerAdapter;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

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

    // 이전 코드.
    // private Map<String, ControllerV4> controllerMap = new HashMap<>();
    // ControllerV4 -> Object로 반경.(모든 컨트롤러를 다 넣을 수 있다.)

    private final Map<String, Object> handlerMappingMap = new HashMap<>();
    private final List<MyHandlerAdapter> handlerAdapters = new ArrayList<>();

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

    private void initHandlerMappingMap() {
        handlerMappingMap.put("/front-controller/v5/v3/members/new-form", new MemberFormControllerV3());
        handlerMappingMap.put("/front-controller/v5/v3/members/save", new MemberSaveControllerV3());
        handlerMappingMap.put("/front-controller/v5/v3/members", new MemberListControllerV3());
    }

    private void initHandlerAdapters() {
        handlerAdapters.add(new ControllerV3HandlerAdapter());
    }
    // 여기까지 초기화 완료.

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

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

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

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

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

    private MyHandlerAdapter getHandlerAdapter(Object handler) {
        // 컬렉션.iter => for문 자동으로 만들어 준다. 최고..
        for (MyHandlerAdapter adapter : handlerAdapters) {
            if(adapter.supports(handler)) {
                return adapter;
            }
        }
        throw new IllegalArgumentException("handler adapter를 찾을 수 없습니다. handler = " + handler);
    }

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

컨트롤러(Controller) => 핸들러(Handler)
이전에는 컨트롤러를 직접 매핑해서 사용했다. 그런데 이제는 어댑터를 사용하기 때문에, 컨트롤러 뿐만 아니라 어댑터가 지원하기만 하면, 어떤 것이라도 URL에 매핑해서 사용할 수 있다. 그래서 이름을 컨트롤러에서 더 넓은 범위의 핸들로 변경했다.

생성자

    public FrontControllerServletV5() {
        initHandlerMappingMap(); //핸들러 매핑 초기화
        initHandlerAdapters(); //어댑터 초기화
    }

생성자는 핸들러 매핑과 어댑터를 초기화(등록)한다.

매핑 정보

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

매핑정보의 값이 ControllerVx와 같은 인터페이스에서 아무 값이나 받을 수 있는 Object로 변경되었다.

핸들러 매핑
Object handler = getHandler(request)

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

핸들러 매핑 정보인 handlerMappingMap에서 URL에 매핑된 핸들러(컨트롤러) 객체를 찾아서 반환한다.

핸들러를 처리할 수 있는 어댑터 조회
MyHandlerAdapter adapter = getHandlerAdapter(handler)

for (MyHandlerAdapter adapter : handlerAdapters) {
	if (adapter.supports(handler)) {
		return adapter; 
	}
}

컬렉션.iter + 엔터 => for문 자동 생성. ~~최고..~~

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

어댑터 호출
ModelView mv = adapter.handle(request, response, handler);
어댑터의 handle(request, response, handler) 메서드를 통해 실제 어댑터가 호출된다.
어댑터는 handler(컨트롤러)를 호출하고 그 결과를 어댑터에 맞추어 반환한다. ControllerV3HandlrAdapter의 경우 어댑터의 모양과 컨트롤러의 모양이 유사해서 변환 로직이 단순하다.

정리
지금은 V3 컨트롤러를 사용할 수 있는 어댑터와 ControllerV3만 들어 있어서 크게 감흥이 없을 것이다. ControllerV4를 사용할 수 있도록 기능을 추가해보자.

유연한 컨트롤러2 - v5

FrontControllerServletV5에 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 추가
}

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

ControllerV4HandlerAdapter

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

import hello.servlet.web.frontcontroller.ModelView;
import hello.servlet.web.frontcontroller.v4.ControllerV4;
import hello.servlet.web.frontcontroller.v5.MyHandlerAdapter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;
import java.util.Map;

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

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

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

실행로직

ControllerV4 controller = (ControllerV4) handler;

Map<String, String> paramMap = createParamMap(request);
Map<String, Object> model = new HashMap<>();

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

handler를 ControllerV4로 캐스팅하고, paramMap, model을 만들어서 해당 컨트롤러를 호출한다.
그리고 viewName을 반환받는다.

어댑터 변환

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

return mv;

어댑터에서 이 부분이 단순하지만 중요한 부분이다.

어댑터가 호출하는 ControllerV4는 뷰의 이름을 반환한다. 그런데 어댑터는 뷰의 이름이 아니라 ModelView를 만들어서 반환해야 한다. 여기서 어댑터가 꼭 필요한 이유가 나온다.
Controller4는 뷰의 이름을 반환했지만, 어댑턴느 이것을 ModelView로 만들어서 형식을 맞추어 반환한다. 마치 110v 전기 콘센트를 220v 전기 콘센트로 변경하듯이!

어댑터와 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: Modle 추가

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

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

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

v5: 유연한 컨트롤러

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

여기에 애노테이션을 사용해서 컨트롤러를 더 편리하게 발전시킬 수도 있다. 만약 애노테이션을 사용해서 컨트롤러를 편리하게 사용할 수 있게 하려면 어떻게 해야할까? 바로 애노테이션을 지원하는 어댑터를 추가하면 된다!
다형성과 어댑터 덕분에 기존 구조를 유지하면서, 프레임워크의 기능을 확장할 수 있다.

스프링 MVC

여기서 더 발전시키면 좋겠지만, 스프링 MVC의 핵심 구조를 파악하는데 필요한 부분은 모두 만들어 보았다. 사실은 여러분이 지금까지 작성한 코드는 스프링 MVC 프레임워크의 핵심 코드의 축약버전이고, 구조도 거의 같다.

스프링 MVC는 지금까지 우리가 학습한 내용과 거의 같은 구조를 가지고 있다.

bien

Good Luck!

이전 포스트

[Spring] #3. 서블릿, JSP, MVC 패턴 (김영한_인프런_스프링MVC1)

다음 포스트

[Spring] #4. MVC 프레임워크 만들기 (김영한_인프런_스프링MVC1)

Spring_MVC1

프론트 컨트롤러 패턴 소개

프론트 컨트롤러 도입 전

프론트 컨트롤러 도입 후

FrontController 패턴 특징

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

프론트 컨트롤러 도입 -v1

v1 구조

ControllerV1

MmemberFormControllerV1 - 회원등록 컨트롤러

MemberSaveControllerV1 - 회원 저장 컨트롤러

MemberListControllerV1 - 회원 목록 컨트롤러

FrontControllerServlet1 - 프론트 컨트롤러

프론트 컨트롤러 분석

View 분리 - v2

v2 구조

MyView

ControllerV2

MemberFormControllerV2 -회원등록 폼

MemberSaveControllerV2 - 회원 저장

MemberListControllerV2 - 회원 목록

프론트 컨트롤러 V2

Model 추가 - v3

1. 서블릿 종속성 제거

2. 뷰 이름 중복 제거

v3 구조

ModelView

ControllerV3

MemberFormControllerV3 - 회원 등록 폼

MemberServiceControllerV3 - 회원 저장

MemberListControllerV3 - 회원 목록

FrontControllerServletV3

뷰 리졸버

MyView

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

v4 구조

ControllerV4

MemberFormControllerV4

MemberSaveControllerV4

MemberListControllerV4

FrontControllerServletV4

유연한 컨트롤러1 - v5

어댑터 패턴

v5 구조

MyHandlerAdapter

ControllerV3HandlerAdapter

FrontControllerServletV5

유연한 컨트롤러2 - v5

ControllerV4HandlerAdapter

어댑터와 ControllerV4

정리

스프링 MVC

[Spring] #3. 서블릿, JSP, MVC 패턴 (김영한_인프런_스프링MVC1)

[Spring] #5. 스프링 MVC - 구조 이해 (김영한_인프런_스프링MVC1)

0개의 댓글