스프링 웹 MVC 1편 - 4. MVC 프레임워크 만들기

링딩·2022년 7월 27일
0

스프링 MVC

목록 보기
4/18

이 글은 김영한 강사님의 강의를 참고하여 작성하였습니다.

Chap 4. MVC 프레임워크

이 곳에서 가장 많이 다룰 것은 각각의 차이점이 될 것 같은데
이 중 핵심만 작성하기 위해 간결하게 작성하였다.



프론트 컨트롤러의 도입 전 후

*다 공통된 처리를 필요로 하는데 입구부터 다 따로 감

프론트 컨트롤러 도입 후


  • 프론트 컨트롤러 패턴 특
    - '프론트 컨트롤러 서블릿' 하나만으로 '클라이언트의 요청'을 받음
    • 얘가 알아서 '매핑정보' 보고 요청에 맞는 Controller를 찾아서 호출
    • 입구도 하나, 공통처리도 가능
    • '프론트 컨트롤러' 외에 다른 컨트롤러는 '서블릿' 사용 x
    • 스프링 웹 MVC의 DispatcherServlet이 FrontController 패턴으로 구현되어 있음


📢 단계적으로 프론트 컨트롤러가 어떻게 도입이 되면서 시도되었는지 보고, 우리가 아는 스프링 MVC 까지의 과정을 볼 수 있도록 점진적으로 리팩터링 할 것이다.


V1 - 프론트 컨트롤러 도입부

V1 에서의 목표
1. 기존 코드를 최대한 유지하며 '프론트 컨트롤러' 도입
2. 구조를 맞춰놓기

✨ V1 과정

ControllerV1

public interface ControllerV1 {
 void process(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException;
}
  • 서블릿과 비슷한 모양의 컨트롤러 '인터페이스'
    *각 컨트롤러들은 이 인터페이스를 구현한다. => 다형성
  • '프론트 컨트롤러'는 이 인터페이스를 호출함

✔컨트롤러 목록들 (MemberFormControllerV1, MemberSaveControllerV1, MemberListControllerV1)

내부 로직은 기존 '서블릿'과 거의 똑같음

[MemberFormControllerV1]

@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]

@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

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

✨ 프론트 컨트롤러

@WebServlet(name = "frontControllerServletV1", urlPatterns = "/frontcontroller/v1/*")
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/*" 등 하위 모든 요청은 이 '서블릿'에서 받아들임
    ex) /front-controller/v1, /front-controller/v1/a
  • controllerMap
    - key-value로 해당 key로 요청이 왔을 시에, value인 '컨트롤러 객체' 반환
  • service()에서 만약 해당되는 '매핑정보'를 찾지 못한다면 if문을 통해 404에러가 던져진다.


V2 - 프론트 컨트롤러 도입부

V2 에서의 목표 

String viewPath = "/WEB-INF/views/new-form.jsp";
RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
dispatcher.forward(request, response);
  • 기존) 모든 컨트롤러에서 '뷰'로 이동하는 부분으로 '중복'이 있고, 깔끔하지 x
    => '뷰'를 별도로 처리하는 객체를 만들자
  • 컨트롤러가 '뷰'를 반환하도록


✨ V2 과정

2. 코드

MyView _뷰 객체

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

controller 인터페이스

public interface ControllerV2 {
 	MyView process(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException;
}
  • 컨트롤러가 '뷰'를 반환

각 컨트롤러들..

[회원등록 폼]

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

	 return new MyView("/WEB-INF/views/new-form.jsp");
 }
  • 컨트롤러 들은 이제 dispatcher.forward() 를 매번 '직접 생성 및 호출' 하지 않게 되었다
    -> MyView 객체 생성 하고 '뷰 이름 경로"만 넣고 반환하면 끝.

[회원저장 컨트롤러]

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

[프론트 컨트롤러]

 @WebServlet(name = "frontControllerServletV2", urlPatterns = "/frontcontroller/v2/*")
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);
 
 }
 
}
  • MyView로 반환하기 때문에 iew.render() 호출 시, 내부의 forward 로직이 서버 내부에서 바로 이동시켜 JSP를 실행시킴.



3. V3 - Model 추가

⭐V2 에서의 목표

  • 서블릿 종속성 제거
    Q. 컨트롤러 입장에서 HttpServletRequest, HttpServletResponse이 꼭 필요할까?
    => '서블릿' 없이 만들자
  • 뷰 이름 중복 제거
    - 컨트롤러는 '뷰'의 "논리 이름"을 반환
    - 실제 물리 위치의 이름은 '프론트 컨트롤러'에서 처리
    ex)
    /WEB-INF/views/new-form.jsp => new-form [논리 이름]
    /WEB-INF/views/save-result.jsp => save-result [논리 이름]

✨ V3 과정


2. 코드

ModelView

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

public class ModelView {

	private String viewName;
    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));
 }
}
  • 뷰의 이름(논리 이름)과 뷰를 렌더링할 때 필요한 model 객체를 가지고 있다.
  • model은 단순히 map으로 되어 있으므로 컨트롤러에서 뷰에 필요한 데이터를 key, value로 넣어주면 된다

[ControllerV3]

public interface ControllerV3 {
 ModelView process(Map<String, String> paramMap);
}
  • '서블릿'이 아예 없다
    -> 구현 단순
  • HttpReqeust 등등의 자리는 '프론트 컨트롤러'가 paramMap에 담아 호출해준다.
  • ModelView 객체로 반환

[MemberSaveControllerV3 - 회원 저장]

public class MemberSaveControllerV3 implements ControllerV3 {
	private MemberRepository memberRepository = MemberRepository.getInstance();

	@Override
 	public ModelView process(Map<String, String> paramMap) {
 		String username = paramMap.get("username");
 		int age = Integer.parseInt(paramMap.get("age"));
 		Member member = new Member(username, age);
 		memberRepository.save(member);
 
 		ModelView mv = new ModelView("save-result");
 		mv.getModel().put("member", member);
 		return mv;
 }
}
  • ModelView 생성 시, "save-result"라는 view의 논리적 이름을 지정

[MyView]

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

[FrontControllerServletV3]

@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();
        
        MyView view = viewResolver(viewName);
        view.render(mv.getModel(), request, response);
    }
    
	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;
	}
      
	private MyView viewResolver(String viewName) {
		return new MyView("/WEB-INF/views/" + viewName + ".jsp");
	}
}
  • createParamMap()
    - HttpServletRequest에서 파라미터 정보를 꺼내서 Map으로 변환한다. 그리고 해당 Map( paramMap )을 컨트롤러에 전달하면서 호출
  • 뷰 리졸버
    MyView view = viewResolver(viewName)
    • 컨트롤러가 반환한 '논리 뷰 이름'을 실제 '물리 뷰 경로'로 변경 => MyView 객체로 반환

너무너무 중요!!

근데 왜 render()에 model을 넘겨주는거지? 🤷‍♂️🤷‍♂️


V2처럼 서블릿의 request, response의 사용을 자제하고, 이제는 모델객체를 ModelView에서 담아서 오기 때문.

mv.getModel().get("members", members)를 통해 '모델'에 '뷰'에서 필요한 member 객체를 담고 반환

  • 곧, ModelView에 세팅 되어 있는 model 데이터를 MyView에 세팅해주기 위해서!

참고

  • view.render(mv.getModel(), request, response)
    - 뷰 객체를 통해서 HTML 화면을 렌더링
    • 이 때 모델도 함께 넘겨주기.
    • JSP는 request.getAttribute() 로 데이터를 조회!!
      -> 모델의 데이터를 꺼내서 request.setAttribute() 로 담아둔다
    • JSP는 포워드 하여 JSP를 렌더링


V3 컨트롤러를 개발하면서 우리는 '서블릿 종속성'을 제거하였고, '뷰 경로의 중복'의 제거 등 잘 설계한 컨트롤러라 생각한다..

그런데 정말 제대로 이대로 ....괜찮은가? 🤔
생각해보면 ModelView가 굳이.. 필요할까?
왜냐하면 ModelView에서 찾아가서 또 모델을 꺼내서 viewResolver()에 넣어주고, 또 ModelView에 있는 '논리적 이름'을 데려오고...

번거롭지 않은가..?!


V4

단순하고 실용적인 컨트롤러를 목표로

위에 보듯이 우리는 v3에서 조금 변경하여 실제 구현에 편리하게 개발할 수 있게끔 해보자.

구조


코드

[인터페이스]

public interface ControllerV4 {
    /**
     * @param paramMap
     * @param model
     * @return viewName
     */
    String process(Map<String, String> paramMap, Map<String, Object> model);
}

[MemberSaveControllerV4]

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

[FrontControllerV4]

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

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


목표 및 바꿀 점 (feat. ModelView를 삭제하자)

  1. FrontController는 파라미터로 Model 객체를 만들어 파라미터로 넘겨라.
    -> 대신 모델 객체를 FrontController에서 만들어서 넘겨주기 때문에
    • Map<String, Object> model = new HashMap<>(); -> 이전 V3에서는 ModelView 객체를 매번 생성하여 model에 값을 넣어주었지만
      => 이제는 그저 만들어진 모델 객체가 '파라미터'를 통해 전달되니 model.put("member", member)처럼 넣어주기만 하면 된다.
  1. 각 Controller의 반환 타입은 String으로 '논리적 이름'(뷰 이름)을 리턴하자.
String viewName = controller.process(paramMap, model);
MyView view = viewResolver(viewName);
  • (이전) V3에서는 ModelView 객체로 받아서 그 곳 들어가 '뷰 이름'을 꺼내줌
  • (현재) 컨트롤러에서 바로 '뷰이름(논리적 이름)'을 반환 받음
    -> 더 빠르고 직접 반환 받네?! 👍



V5-1

다른 컨트롤러도 호환할 수 있으면 좋겠다!

우리는 가만보면 FrontController에서 '한가지 방식'의 컨트롤러 인터페이스만 사용할 수 있었다.
ControllerV3와 ControllerV4는 완전히 다른 인터페이스로 이 둘을 호환해서 쓸 수 없었다.

호환하는 방법은 없을까,,?

방법은 있다 그건 바로 '어댑터'라는 것이다!!


구조

원래 : FrontController에서 바로 핸들러를 호출했다.
현재 : 핸들러 어댑터를 통해 핸들러를 호출한다.


🤔 핸들러와 핸들러 어댑터의 차이?

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

코드

[MyHandlerAdapter_ 인터페이스]

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] _ 인터페이스 구현체(어댑터)

public class ControllerV3HandlerAdapter implements MyHandlerAdapter {
    @Override
    public boolean supports(Object handler) {
        //handler가 V3로 구현한게 넘어와야 True 반환
        return (handler instanceof ControllerV3);
    }

    //(목표): 핸들러를 호출해주고 ModelView 타입으로 반환해줘야 함
    @Override
    public ModelView handle(HttpServletRequest request,
                            HttpServletResponse response, Object handler) {
        ControllerV3 controller = (ControllerV3) handler;

        //paramMap은 기본적으로 V3에서는 String타입으로 받아와야 한다.
        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;
    }
}

[FrontController]

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

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

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

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

    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);
        MyView view = viewResolver(mv.getViewName());
        view.render(mv.getModel(), request, response);
    }

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

    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");
    }
}
  • initHandlerMappingMap(); //핸들러 매핑 초기화
    initHandlerAdapters(); //어댑터 초기화

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

    Q. 왜 value를 Object로 받는 것일까? 🤔🤔🤔
    A. V5의 목표대로 다양한 인터페이스인 ControllerV3, ControlleV4등등 에서 호환할 수 있도록 하기 위해서

profile
링딩
초짜 백엔드 개린이
이전 포스트

스프링 웹 MVC 1편 - 3. 서블릿, JSP, MVC 패턴

다음 포스트

스프링 웹 MVC 1편 - 5. 스프링 MVC 구조 이해

0개의 댓글