LostCatBox

SpringMVC-CH04

Spring Basic
Word count: 3.1kReading time: 19 min
2022/12/24 Share

스프링 MVC 1편 CH04

Created Time: June 26, 2022 7:42 PM
Last Edited Time: June 28, 2022 12:45 AM

MVC 프레임 워크 만들기

  • MVC 프레임 워크를 하나씩 발전 시켜서 결국 Spring이 이런것들의 이유로 만들어졌구나 이해! 목표

프론트 컨트롤러 패턴 소개

스크린샷 2022-06-26 오후 7.46.06.png

  • 프론트 컨트롤러 도입 후

스크린샷 2022-06-26 오후 7.46.11.png

FrontController 패턴 특징

  • 프론트 컨트롤러 서블릿 하나로 클라이언트의 요청을 받음
  • 프론트 컨트롤러가 요청에 맞는 컨트롤러를 찾아서 호출
  • 입구를 하나로!
  • 공통 처리 가능
  • 프론트 컨트롤러를 제외한 나머지 컨트롤러는 서블릿을 사용하지 않아도 됨
    • httpServlet상속 필요없음…서블릿ㄴㄴ
    • 어떤식으로 그럼 프론트 컨트롤러를 발전시키고 활용해야하나?

스프링 웹 MVC와 프론트 컨트롤러
스프링 웹 MVC의 핵심도 바로 FrontController
스프링 웹 MVC의 DispatcherServlet이 FrontController 패턴으로 구현됨

프론트 컨트롤러 도입 - v1

  • 프론트 컨트롤러를 단계적으로 도입해보자.
    이번 목표는 기존 코드를 최대한 유지하면서, 프론트 컨트롤러를 도입하는 것이다.
    먼저 구조를 맞추어두고 점진적으로 리펙터링 해보자.
  • 구조

스크린샷 2022-06-26 오후 8.38.29.png

ControllerV1

  • 서블릿과 비슷한 모양의 컨트롤러 인터페이스를 도입한다. 각 컨트롤러들은 이 인터페이스를 구현하면 된다. 프론트 컨트롤러는 이 인터페이스를 호출해서 구현과 관계없이 로직의 일관성을 가져갈 수 있다. 다형성이용
  • 이제 이 인터페이스를 구현한 컨트롤러를 만들어보자. 지금 단계에서는 기존 로직을 최대한 유지하는게 핵심이다.
1
2
3
public interface ControllerV1 {
    void process(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException;
}

MemberFormControllerV1 - 회원 등록 컨트롤러

  • ControllerV1 인터페이스 상속
1
2
3
4
5
6
7
8
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);//servlet에서 다른 servlet이나 jsp이동할수있는기능(서버 내부에서 다시 호출발생)(제어권넘어감)
    }
}

MemberSaveControllerV1 - 회원 저장 컨트롤러

  • ControllerV1 인터페이스 상속
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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);
        String viewPath="/WEB-INF/views/save-result.jsp";
        RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
        dispatcher.forward(request,response);
    }
}

MemberListControllerV1 - 회원 목록 컨트롤러

  • ControllerV1 인터페이스 상속
1
2
3
4
5
6
7
8
9
10
11
12
13
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);

        }
}

FrontControllerServletV1 - 프론트 컨트롤러

  • 프론트 컨트롤러는 반드시 Servlet!!
  • urlPatterns = “/front-controller/v1/*” : /front-controller/v1 를 포함한 하위 모든 요청은 이 서블릿에서 받아들인다.
  • controllerMap
    • key: 매핑 URP
    • value: 호출될 컨트롤러
  • service()
    • 먼저 requestURI 를 조회해서 실제 호출할 컨트롤러를 controllerMap 에서 찾는다. 만약 없다면 404(SC_NOT_FOUND) 상태 코드를 반환한다.
      컨트롤러를 찾고 controller.process(request, response); 을 호출해서 해당 컨트롤러를 실행한다.
  • JSP
    • JSP는 이전 MVC에서 사용했던 것을 그대로 사용한다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@WebServlet(name="frontControllerServletV1", urlPatterns = "/front-controller/v1/*") // v1 이하주소요청은 무조건 이 서블릿 호출
public class FrontControllerServletV1 extends HttpServlet {
    private Map<String, ControllerV1> controllerV1Map = new HashMap<>();

    public FrontControllerServletV1() { //map구조에 key주소, value ControllerV1의 구현체로 넣어줌
        controllerV1Map.put("/front-controller/v1/members/new-form", new MemberFormControllerV1());
        controllerV1Map.put("/front-controller/v1/members/save", new MemberSaveControllerV1());
        controllerV1Map.put("/front-controller/v1/members", new MemberListControllerV1());
    }

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("FrontControllerServletV1.service");
        String requestURI = request.getRequestURI();
        ControllerV1 controller = controllerV1Map.get(requestURI);
        if (controller ==null){
            response.setStatus(HttpServletResponse.SC_NOT_FOUND);
            return;
        }
        controller.process(request, response);

    }
}

View 분리 - V2

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

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

이 부분을 깔끔하게 분리하기 위해 별도로 뷰를 처리하는 객체를 만들자.

구조

  • controller가 직접 forward안함
  • controller가 MyView 반환하면, 해당 render()호출 > JSP forward >JSP> html응답
  • 뷰를 만드는 행위를 렌더링한다고표현한다!!!!

스크린샷 2022-06-26 오후 11.23.35.png

controller

FrontControllerServletV2

  • 가장 앞단에있는 프론트 컨트롤러,
  • FrontController에서 해당 하위 컨트롤러를 찾아 process가 실행되며, 그이후 MyView.render() 실행하게된다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@WebServlet(name="frontControllerServletV2", urlPatterns = "/front-controller/v2/*") // v1 이하주소요청은 무조건 이 서블릿 호출
public class FrontControllerServletV2 extends HttpServlet {
    private Map<String, ControllerV2> controllerV2Map = new HashMap<>();

    public FrontControllerServletV2() { //map구조에 key주소, value ControllerV1의 구현체로 넣어줌
        controllerV2Map.put("/front-controller/v2/members/new-form", new MemberFormControllerV2());
        controllerV2Map.put("/front-controller/v2/members/save", new MemberSaveControllerV2());
        controllerV2Map.put("/front-controller/v2/members", new MemberListControllerV2());
    }

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("FrontControllerServletV2.service");
        String requestURI = request.getRequestURI();
        ControllerV2 controller = controllerV2Map.get(requestURI);
        if (controller ==null){
            response.setStatus(HttpServletResponse.SC_NOT_FOUND);
            return;
        }
        MyView view = controller.process(request, response);
        view.render(request,response);
    }
}

controllerV2

  • hello.servlet.web.frontcontroller.v2
  • 프론트 컨트롤러를 제외한 controller는 모두 MyView를 반환하도록 인터페이스지정
  • MyView를 반환시 render()함수호출하여, 렌더링함!
1
2
3
public interface ControllerV2 {
    MyView process(HttpServletRequest request, HttpServletResponse response);
}

MemberFormControllerV2

  • hello.servlet.web.frontcontroller.v2.controller
1
2
3
4
5
6
7
public class MemberFormControllerV2 implements ControllerV2 {
    @Override
    public MyView process(HttpServletRequest request, HttpServletResponse response) {
        return new MyView("/WEB-INF/views/new-form.jsp");
    }

}

MemberSaveControllerV2

  • hello.servlet.web.frontcontroller.v2.controller
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class MemberSaveControllerV2 implements ControllerV2 {
    MemberRepository memberRepository = MemberRepository.getInstance();
    @Override
    public MyView process(HttpServletRequest request, HttpServletResponse response) {
        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

  • hello.servlet.web.frontcontroller.v2.controller
1
2
3
4
5
6
7
8
9
10
11
public class MemberListControllerV2 implements ControllerV2 {
    MemberRepository memberRepository = MemberRepository.getInstance();

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

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

View

MyView

  • hello.servlet.web.frontcontroller
  • MyView는 v1에서 공통된 render하는 부분을 추출해서 역할을 분리하였다고생각하자.
1
2
3
4
5
6
7
8
9
10
11
12
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);
    }
}

Model 추가 - V3

개선할점

서블릿 종속성 제거

  • 컨트롤러 입장에서 HttpServletRequest, HttpServletResponse이 꼭 필요할까?
    요청 파라미터 정보는 자바의 Map으로 대신 넘기도록 하면 지금 구조에서는 컨트롤러가 서블릿 기술을 몰라도 동작할 수 있다.
  • 그리고 request 객체를 Model로 사용하는 대신(request.setAttribute()사용했었음)에 별도의 Model 객체를 만들어서 반환하면 된다. 우리가 구현하는 컨트롤러가 서블릿 기술을 전혀 사용하지 않도록 변경해보자. 이렇게 하면 구현 코드도 매우 단순해지고, 테스트 코드 작성이 쉽다.

뷰 이름 중복 제거

  • 컨트롤러에서 지정하는 뷰 이름에 중복이 있는 것을 확인할 수 있다.
    컨트롤러는 뷰의 논리 이름을 반환하고, 실제 물리 위치의 이름은 프론트 컨트롤러에서 처리하도록 단순화하자.이렇게 해두면 향후 뷰의 폴더 위치가 함께 이동해도 프론트 컨트롤러만 고치면 된다.
    • /WEB-INF/views/new-form.jsp → new-form
    • /WEB-INF/views/save-result.jsp → save-result
    • /WEB-INF/views/members.jsp → members

V3구조

스크린샷 2022-06-27 오전 10.10.58.png

  • 프론트 컨트롤러는 잡다한일 다 처리!!
  • 나머지는 기능 단순화를 위해 쪼개기(변경점 1개있을때, 1개만 변경가능하면 좋은 구조)

ModelView

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

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

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

V4 구조

  • 기본적인 구조는 V3와 같다. 대신에 컨트롤러가 ModelView 를 반환하지 않고, ViewName 만 반환한다.
  • ModelView역할을 그냥 호출시 model을 파라미터로 넘김. 컨트롤러에서 model에 데이터 추가
  • 이번 버전은 인터페이스에 ModelView가 없다. model 객체는 파라미터로 전달되기 때문에 그냥 사용하면 되고, 결과로 뷰의 이름만 반환해주면 된다.

스크린샷 2022-06-27 오후 12.29.44.png

Controller

FrontControllerServletV4

  • hello.servlet.web.frontcontroller.v4
  • model을 프론트컨트롤에서 만들어서, 하위 컨트롤러들은 ModelView를 활용할필요없어짐. 단지 String 으로 return “기능이름” 만 하면됨
  • 하위 컨트롤러는 훨씬 간단해 진것을 볼수있다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
@WebServlet(name="frontControllerServletV4", urlPatterns = "/front-controller/v4/*") // v1 이하주소요청은 무조건 이 서블릿 호출
public class FrontControllerServletV4 extends HttpServlet {
    private Map<String, ControllerV4> controllerV4Map = new HashMap<>();

    public FrontControllerServletV4() { //map구조에 key주소, value ControllerV1의 구현체로 넣어줌
        controllerV4Map.put("/front-controller/v4/members/new-form", new MemberFormControllerV4());
        controllerV4Map.put("/front-controller/v4/members/save", new MemberSaveControllerV4());
        controllerV4Map.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 = controllerV4Map.get(requestURI);
        if (controller ==null){
            response.setStatus(HttpServletResponse.SC_NOT_FOUND);
            return;
        }

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

        //paramMap넘겨줘야함
        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;
    }
}

ControllerV4

  • 이전과 다르게 프론트 컨트롤러에서 주는 model을 받을 필요가있다.
1
2
3
4
5
6
7
8
/**
 * @param paramMap
 * @param model
 * @return viewName
 */
public interface ControllerV4 {
    String process(Map<String,String> paramMap, Map<String,Object> model);
}

MemberFormControllerV4

  • hello.servlet.web.frontcontroller.v4.controller
1
2
3
4
5
6
public class MemberFormControllerV4 implements ControllerV4 {
    @Override
    public String process(Map<String, String> paramMap, Map<String, Object> model) {
        return "new-form";
    }
}

MemberSaveControllerV4

  • hello.servlet.web.frontcontroller.v4.controller
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class MemberSaveControllerV4 implements ControllerV4 {
    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

  • hello.servlet.web.frontcontroller.v4.controller
1
2
3
4
5
6
7
8
9
10
11
public class MemberListControllerV4 implements ControllerV4 {
    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";
    }
}

모델객체 전달

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

뷰의 논리 이름을 직접 반환

  • 컨트롤로가 직접 뷰의 논리 이름을 반환하므로 이 값을 사용해서 실제 물리 뷰를 찾을 수 있다.
1
2
String viewName = controller.process(paramMap, model);
  MyView view = viewResolver(viewName);

정리

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

유연한 컨트롤러1 -v5

  • 만약 어떤 개발자는 ControllerV3 방식으로 개발하고 싶고, 어떤 개발자는 ControllerV4 방식으로 개발하고 싶다면 어떻게 해야할까?
  • 이전 버전들의 문제점은 프론트 컨트롤러의 controllerMap에서 타입으로 controller특정 인터페이스가 되어있다.

어댑터 패턴

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

V5 구조

스크린샷 2022-06-27 오후 1.55.52.png

  • 핸들러 어댑터: 중간에 어댑터 역할을 하는 어댑터가 추가되었는데 이름이 핸들러 어댑터이다. 여기서어댑터 역할을 해주는 덕분에 다양한 종류의 컨트롤러를 호출할 수 있다.
  • 핸들러(=? 컨트롤러): 컨트롤러의 이름을 더 넓은 범위인 핸들러로 변경했다. 그 이유는 이제 어댑터가 있기 때문에 꼭 컨트롤러의 개념 뿐만 아니라 어떠한 것이든 해당하는 종류의 어댑터만 있으면 다 처리할 수 있기 때문이다.
  • 동작 설명
    1. 프론트 컨트롤러가 핸들러(=컨트롤러) 매핑 정보에서 해당 핸들러 가져옴
    2. 해당 핸들러를 컨트롤 할수있는 핸들러 어댑터를 조회(isinstanceof)
    3. 해당 핸들러 어댑터를 호출하여 내부적으로 핸들러 어댑터가 해당 핸들러를 호출하여 결과적으로 핸들러 어댑터가 ModelView를 반환하게함
    4. viewResolver로 논리 주소> 물리 주소로바꿈
    5. view로 render(mv.getmodel(),request,response) 호출하여 뷰 응답

MyHandlerAdapter(!!!)

꿀팁! Collection에서 반복문필요시 .iter를 하면 자동완성해줌

  • 프론트 컨트롤러가 핸들러(컨트롤러)를 직접 호출하는것이아닌
    핸들러 어댑터를 호출하여, 핸들러 어댑터가 핸들러는 호출하는 방식!!
1
2
3
4
5
public interface MyHandlerAdapter {
    boolean supports(Object handler);

    ModelView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws ServletException, IOException;
}
  • boolean supports(Object handler)
    • handler는 컨트롤러를 말한다.
    • 어댑터가 해당 컨트롤러를 처리할 수 있는지 판단하는 메서드다.
  • ModelView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
    • 어댑터는 실제 컨트롤러를 호출하고, 그 결과로 ModelView를 반환해야 한다.
      실제 컨트롤러가 ModelView를 반환하지 못하면, 어댑터가 ModelView를 직접 생성해서라도반환해야 한다.
    • 이전에는 프론트 컨트롤러가 실제 컨트롤러를 호출했지만 이제는 이 어댑터를 통해서 실제 컨트롤러가 호출된다.

ControllerV3HandlerAdapter

  • hello.servlet.web.frontcontroller.v5.adapter
  • supports()함수와 handle()함수를 지원하는 MyHandlerAdapter구현체
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class ControllerV3HandlerAdapter implements MyHandlerAdapter {

    @Override
    public boolean supports(Object handler){
        //true 반환시 ControllerV3를 처리할수있는 어댑터를 뜻한다.
        return (handler instanceof ControllerV3);
    }

    @Override
    public ModelView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws ServletException, IOException {
        //frontcontroller에서 이미 supports를 호출하여 확인하였으므로 형변환 후 사용할수있음
        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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
@WebServlet(name="frontControllerServletV5", urlPatterns = "/front-controller/v5/*")
public class FrontControllerServletV5 extends HttpServlet {
    //private Map<String, ControllerV4> controllerV4Map = new HashMap<>(); 차이점 다들어갈수있도록해야함
    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 {
        System.out.println("FrontControllerServletV5.service");

        //handler 찾음
        Object handler = getHandler(request);

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

        //handler 사용가능한 어뎁터 찾기
        MyHandlerAdapter adapter = getHandlerAdapter(handler);

        //adapter를 호출하여, 핸들러를 내부적으로 호출하게한다
        ModelView mv = adapter.handle(request, response, handler);

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

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

    }

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

    }

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

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

}
  • 컨트롤러(Controller) → 핸들러(Handler)
    • 이전에는 컨트롤러를 직접 매핑해서 사용했다. 그런데 이제는 어댑터를 사용하기 때문에, 컨트롤러 뿐만 아니라 어댑터가 지원하기만 하면, 어떤 것이라도 URL에 매핑해서 사용할 수 있다. 그래서 이름을 컨트롤러에서 더 넒은 범위의 핸들러로 변경했다.
  • 생성자
    • 생성자는 핸들러 매핑과 어댑터를 초기화(등록)한다
  • 핸들러 매핑(Object handler = getHandler(request))
    • 핸들러 매핑 정보인 handlerMappingMap 에서 URL에 매핑된 핸들러(컨트롤러) 객체를 찾아서 반환한다.
  • 핸들러를 처리할 수 있는 어댑터 조회(MyHandlerAdapter adapter = getHandlerAdapter(handler))
    • handler 를 처리할 수 있는 어댑터를 adapter.supports(handler) 를 통해서 찾는다. handler가 ControllerV3 인터페이스를 구현했다면, ControllerV3HandlerAdapter 객체가 반환된다.
  • 어댑터 호출(ModelView mv = adapter.handle(request, response, handler);)
    • 어댑터의 handle(request, response, handler) 메서드를 통해 실제 어댑터가 호출된다. 어댑터는 handler(컨트롤러)를 호출하고 그 결과를 어댑터에 맞추어 반환한다. ControllerV3HandlerAdapter 의 경우 어댑터의 모양과 컨트롤러의 모양이 유사해서 변환 로직이 단순하다.

유연한 컨트롤러2 - V5

  • FrontControllerServletV5 에 ControllerV4 기능도 추가해보자.

Controller

ControllerV4HandlerAdapter

  • 어뎁터는 handle()은 반드시 ModelView를 반환하기로 했으므로
    핸들러가 String viewName을 반환하면 정보를 취합하여 ModelView객체를 생성한다. >> mv.setModel(model)>>return mv
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class ControllerV4HandlerAdapter implements MyHandlerAdapter {
    @Override
    public boolean supports(Object handler) {
        return (handler instanceof ControllerV4);
    }

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

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

        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;
    }
}
  • handler 가 ControllerV4 인 경우에만 처리하는 어댑터이다.
  • handler를 ControllerV4로 케스팅 하고, paramMap, model을 만들어서 해당 컨트롤러를 호출한다. 그리고 viewName을 반환 받는다.
  • 어댑터 변환
    • 어댑터에서 이 부분이 단순하지만 중요한 부분이다.
    • 어댑터가 호출하는 ControllerV4 는 뷰의 이름을 반환한다. 그런데 어댑터는 뷰의 이름이 아니라 ModelView 를 만들어서 반환해야 한다. 여기서 어댑터가 꼭 필요한 이유가 나온다. ControllerV4 는 뷰의 이름을 반환했지만, 어댑터는 이것을 ModelView로 만들어서 형식을 맞추어반환한다. 마치 110v 전기 콘센트를 220v 전기 콘센트로 변경하듯이!

FrontControllerServletV5

  • 아래 내용만 기존에 추가해준다면, 모두 호환된다.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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());
    }

정리

  • 지금까지 v1 ~ v5로 점진적으로 프레임워크를 발전시켜 왔다. 지금까지 한 작업을 정리해보자.
    • v1: 프론트 컨트롤러를 도입→기존 구조를 최대한 유지하면서 프론트 컨트롤러를 도입
    • v2: View 분류→단순 반복 되는 뷰 로직 분리
    • v3: Model 추가→서블릿 종속성 제거, 뷰 이름 중복 제거
    • v4: 단순하고 실용적인 컨트롤러 →v3와 거의 비슷, 구현 입장에서 ModelView를 직접 생성해서 반환하지 않도록 편리한 인터페이스 제공
    • v5: 유연한 컨트롤러 →어댑터 도입, 어댑터를 추가해서 프레임워크를 유연하고 확장성 있게 설계
  • 여기에 애노테이션을 사용해서 컨트롤러를 더 편리하게 발전시킬 수도 있다. 만약 애노테이션을 사용해서 컨트롤러를 편리하게 사용할 수 있게 하려면 어떻게 해야할까? 바로 애노테이션을 지원하는 어댑터를 추가하면 된다!
    다형성과 어댑터 덕분에 기존 구조를 유지하면서, 프레임워크의 기능을 확장할 수 있다.
  • 스프링 MVC여기서 더 발전시키면 좋겠지만, 스프링 MVC의 핵심 구조를 파악하는데 필요한 부분은 모두 만들어보았다.
    사실은 여러분이 지금까지 작성한 코드는 스프링 MVC 프레임워크의 핵심 코드의 축약 버전이고, 구조도 거의 같다.스프링 MVC는 지금까지 우리가 학습한 내용과 거의 같은 구조를 가지고 있다.
  • (!!!)(꿀팁)전체적인 구조를 바꿀것이냐, 세세한부분을 바꿀것이냐? 한개만 하는것이좋다.
CATALOG
  1. 1. 스프링 MVC 1편 CH04
  2. 2. MVC 프레임 워크 만들기
    1. 2.1. 프론트 컨트롤러 패턴 소개
    2. 2.2. FrontController 패턴 특징
  3. 3. 프론트 컨트롤러 도입 - v1
    1. 3.1. ControllerV1
    2. 3.2. MemberFormControllerV1 - 회원 등록 컨트롤러
    3. 3.3. MemberSaveControllerV1 - 회원 저장 컨트롤러
    4. 3.4. MemberListControllerV1 - 회원 목록 컨트롤러
    5. 3.5. FrontControllerServletV1 - 프론트 컨트롤러
  4. 4. View 분리 - V2
    1. 4.1. 구조
    2. 4.2. controller
      1. 4.2.1. FrontControllerServletV2
      2. 4.2.2. controllerV2
      3. 4.2.3. MemberFormControllerV2
      4. 4.2.4. MemberSaveControllerV2
      5. 4.2.5. MemberListControllerV2
    3. 4.3. View
      1. 4.3.1. MyView
  5. 5. Model 추가 - V3
    1. 5.1. 개선할점
      1. 5.1.1. 서블릿 종속성 제거
      2. 5.1.2. 뷰 이름 중복 제거
    2. 5.2. V3구조
      1. 5.2.1. ModelView
  6. 6. 단순하고 실용적인 컨트롤러 - v4
    1. 6.1. V4 구조
    2. 6.2. Controller
      1. 6.2.1. FrontControllerServletV4
      2. 6.2.2. ControllerV4
      3. 6.2.3. MemberFormControllerV4
      4. 6.2.4. MemberSaveControllerV4
      5. 6.2.5. MemberListControllerV4
    3. 6.3. 모델객체 전달
    4. 6.4. 뷰의 논리 이름을 직접 반환
    5. 6.5. 정리
  7. 7. 유연한 컨트롤러1 -v5
    1. 7.1. 어댑터 패턴
    2. 7.2. V5 구조
    3. 7.3. MyHandlerAdapter(!!!)
      1. 7.3.1. ControllerV3HandlerAdapter
    4. 7.4. FrontControllerServletV5
  8. 8. 유연한 컨트롤러2 - V5
    1. 8.1. Controller
      1. 8.1.1. ControllerV4HandlerAdapter
    2. 8.2. FrontControllerServletV5
    3. 8.3. 정리







Total : 224
2024
2023
2022
2021
2020
2019
Review Book Spring Basic DB Mybatis Lombok MessageQ Kafka JPA Advance Vue Project CS Notion Domain Network Mysql API DRF hanbik Junior Devfest HTTPie WebBasic Http Tip Java Issue Elastic Beanstalk AWS Jquery Html FrontEnd Javascript Git Coding Structure Interview OS Web Session Logger R Univ Jenkins Thymeleaf AOP Basic. Python Library Python Tips Knowledge Socket Django ClassView Threading Data Mechanism Advanced Serializer Djagno Docker Dataminging Statistics Endofyear Finish Restart Realestate Excel Skill Aws Drf GDG Google Festival Frontend Ajax Gitlab CI-CD Important Css Front-End Https Ssl Server basic Apt Kakao Problem Nginx Proxy Outsourcing Wsgi QueryDSL Jpa How Linux Ubuntu Ssh PEP Building Analysis Form Thinking English Markdown HTTP Websocket Wordpress TDD Testcode
Review Maven Mybatis Spring ETC MessageQ JPA Vue CS Tips DB API Conference HTTPie Network WebBasic Issue Elastic-Beanstalk Java Jquery Javascript Git OS R Jenkins Basic Library Knowledge Chatting Django Data-Mining Coding DRF Skill Docker Statistics Endofyear realestate Excel Server Frontend Gitlab Tip Important Html-Css Project Kakao Outsourcing Python Report How Linux Analysis Form Thinking Ubuntu Html Markdown TDD