[Spring] MVC 패턴이란, V1~V5로 MVC 프레임워크 만들기

« 2025/02 »
일	월	화	수	목	금	토
						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

Link

🌱 GitHub

Notice

🍀 깃허브 / 티스토리 닉네임의 의미

관리 메뉴

DevLog 😶

[Spring] MVC 패턴이란, V1~V5로 MVC 프레임워크 만들기 본문

Back-end/Spring

[Spring] MVC 패턴이란, V1~V5로 MVC 프레임워크 만들기

dolmeng2 2022. 8. 16. 15:44

- 김영한 님의 '스프링 MVC 1편 - 백엔드 웹 개발 핵심 기술'을 보고 정리한 글입니다 😊

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

웹 애플리케이션을 개발할 때 필요한 모든 웹 기술을 기초부터 이해하고, 완성할 수 있습니다. 스프링 MVC의 핵심 원리와 구조를 이해하고, 더 깊이있는 백엔드 개발자로 성장할 수 있습니다., -

www.inflearn.com

- 지난 포스팅과 이어집니다 :D

[Spring] 서블릿이란? HttpServletRequest, HttpServletResponse

- 김영한 님의 '스프링 MVC 1편 - 백엔드 웹 개발 핵심 기술'을 보고 정리한 글입니다 😊 스프링 MVC 1편 - 백엔드 웹 개발 핵심 기술 - 인프런 | 강의 웹 애플리케이션을 개발할 때 필요한 모든 웹 기

cl8d.tistory.com

- 간단하게 회원 관리 웹 애플리케이션을 만들어보자.

[SMember.java]

@Getter @Setter
@NoArgsConstructor
public class SMember {
    private Long id;
    private String username;
    private int age;

    public SMember(String username, int age) {
        this.username = username;
        this.age = age;
    }
}

- 이전의 스프링 핵심원리 강의와 동일한 프로젝트를 사용하고 있어서 도메인 이름을 변경하였다. Member라고 해도 무방하다.

[SMemberRepository.java]

public class SMemberRepository {
    private static Map<Long, SMember> store = new ConcurrentHashMap<>();
    private static AtomicLong sequence = new AtomicLong(0L);

    private static final SMemberRepository repository
            = new SMemberRepository();

    private SMemberRepository() {
    }

    public static SMemberRepository getRepository() {
        return repository;
    }

    public SMember save(SMember member) {
        member.setId(sequence.incrementAndGet()); // ++sequence와 동일한 의미
        store.put(member.getId(), member);
        return member;
    }

    public SMember findById(Long id) {
        return store.get(id);
    }

    public List<SMember> findAll() {
        return new ArrayList<>(store.values());
    }

    public void clearStore() {
        store.clear();
    }
}

- 전반적으로 싱글톤 패턴을 사용하였다. 생성자를 private로 막았고, repository 역시 getRepository()로만 가져올 수 있다.

- 싱글톤이다 보니까 동시성 이슈 때문에 ConcurrentHashMap과 AtomicLong을 사용해주었다. 예제에서는 사용하지 않아도 무방하다.

- static으로도 관리할 필요는 없다. static은 공유 변수로 사용할 때 쓰이지만, 싱글톤이면 어차피 이에 대해서 보장받기 때문이다.

- 추가적으로, findAll()의 경우 new ArrayList<>()로 store.values()의 값을 복사해서 전달하는 걸 볼 수 있는데, 이는 자바의 레퍼런스 참조로 인해서 store 자체를 넘겨버리면 store의 값이 변경될 수 있는 문제 때문에 위와 같이 선언하였다.

✔ Test

class SMemberRepositoryTest {
    SMemberRepository repository = SMemberRepository.getRepository();

    @AfterEach
    void afterEach() {
        repository.clearStore();
    }

    @Test
    public void save() throws Exception {
        // given
        SMember member = new SMember("hi", 22);

        // when
        SMember savedMember = repository.save(member);

        // then
        SMember findMember = repository.findById(savedMember.getId());
        assertThat(findMember).isEqualTo(member);
    }

    @Test
    public void findAll() throws Exception {
        // given
        SMember member1 = new SMember("hi", 22);
        SMember member2 = new SMember("hihi", 22);

        repository.save(member1);
        repository.save(member2);

        // when
        List<SMember> all = repository.findAll();

        // then
        assertThat(all.size()).isEqualTo(2);
        assertThat(all).contains(member1, member2);

    }

}

- 간단한 테스트 코드이다. 둘 다 잘 돌아가는 것을 볼 수 있다.

- 이제, 뷰 화면을 구성하기 위해서 JSP, 타임리프를 이용해서 진행을 해보자.

- 단순 서블릿과 자바 코드로도 구성할 수 있지만, 엄청난 하드코딩이 필요하고 잘 사용하지 않기 때문에 생략하겠다.

- 단순 JSP를 사용하는 방법은 뷰에 자바 코드가 들어가기 때문에 굉장히 복잡하다. 많이 사용하는 MVC 패턴을 사용해보자.

| MVC 패턴이란?

- JSP의 경우 비즈니스 로직, 뷰 렌더링까지 들어가기 때문에 유지보수 관점에서 매우 좋지 않다.

- MVC는 모델 - 뷰 - 컨트롤러를 통해서 각각의 역할에 더 집중할 수 있도록 도와준다.

✔ 모델 (Model)

- 뷰에 출력할 데이터를 담는 역할로, 모델을 통해 뷰에게 데이터를 전달한다고 보면 된다.

✔ 뷰 (View)

- 모델에 있는 데이터를 이용하여 화면을 구성한다. HTML을 통해 뷰를 만들어주는 작업을 진행한다.

✔ 컨트롤러 (Controller)

- HTTP 요청을 받아서 검증 및 비즈니스 로직을 실행하는 부분이다. 뷰에 전달할 데이터를 모델에 담아주는 역할을 한다.

- 보통 비즈니스 로직의 경우 별도의 Service 레이어를 통해서 실행한다.

- 개인적인 경험으로는 entity - repository - service - controller 구조를 가장 많이 사용하는 것 같다.

- 이 그림이 가장 정확하게 로직을 설명해주는 것 같다 :D

- 이제, 실제 코드에 적용해보자.

- build.gradle에 다음을 추가해주자. (JSP)

implementation 'org.apache.tomcat.embed:tomcat-embed-jasper'
implementation 'javax.servlet:jstl'

[new-form.jsp]

- main/webapp/WEB-INF/views 밑에 설정해두었다.

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <form action="save" method="post">
        username: <input type="text" name="username">
        age: <input type="text" name="age">
        <button type="submit">전송하기</button>
    </form>
</body>

- 간단하게 이름과 나이를 입력받아 post 방식으로 전송할 수 있도록 구성하였다.

- 현재의 계층 경로 + /save (action에 지정해준 경로)가 호출된다.

[save-result.jsp]

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    성공!
    <ul>
        <li>id=${member.id}</li>
        <li>username=${member.username}</li>
        <li>age=${member.age}</li>
    </ul>
</body>

- 회원 저장 결과를 띄워주는 뷰이다.

[members.jsp]

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<html>
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <table>
    <thead>
        <th>id</th>
        <th>username</th>
        <th>age</th>
    </thead>
    <tbody>
        <c:forEach var="item" items="${members}">
        <tr>
            <td>${item.id}</td>
            <td>${item.username}</td>
            <td>${item.age}</td>
        </tr>
        </c:forEach>
    </tbody>
    </table>
</body>

- jsp에서 제공하는 taglib 기능을 통해 편리하게 반복문을 처리하였다.

- items = {members}에 담긴 애들을 'item'이라는 이름으로 접근하며 각 요소들을 출력해주는 것이다.

- thead와 tbody의 경우 테이블의 헤더와 내용을 작성하는 부분이며, 그냥 섹션을 나누는 용도라고 보면 된다.

- th는 표의 제목, tr은 일종의 가로줄, td는 각각의 셀 내용을 작성해주는 문법이다.

- 이제, 본격적인 MVC 프레임워크를 제작하자!

| MVC 프레임워크

- MVC 프레임워크의 핵심은 '프론트 컨트롤러(Front Controller)'이다!

- 프론트 컨트롤러는 앞단에서 서블릿 하나로 클라이언트의 요청을 받으며, 요청에 맞는 컨트롤러를 호출해주는 역할을 한다.

- 공통처리도 가능하며, 프론트 컨트롤러를 제외한 나머지는 서블릿을 사용할 필요가 없다.

- 그렇기 때문에, 기존에는 서블릿을 3개로 관리하였다면 이제는 1개만 관리해도 된다는 것이다.

- 스프링에서는 DispatcherServlet이 FrontController의 역할을 해준다!

- 단계적으로 하나씩 직접 구현해나가며 FrontController 패턴을 익혀보자.

✔ V1 - 컨트롤러 인터페이스 도입하기

[SMemberController.java]

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

- 인터페이스로 선언하여 해당 인터페이스를 구현한 컨트롤러들을 만들어보자.

[MemberFormController.java] - 회원 등록 컨트롤러

public class MemberFormController implements SMemberController{
    @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);
    }
}

[MemberSaveController.java] - 회원 저장 컨트롤러

public class MemberSaveController implements SMemberController{
    private final SMemberRepository repository
            = SMemberRepository.getRepository();

    @Override
    public void process(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String username = request.getParameter("username");
        int age = Integer.parseInt(request.getParameter("age"));

        SMember member = new SMember(username, age);
        repository.save(member);

        // JSP에게 데이터 전달하기 위해서 사용
        request.setAttribute("member", member);

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

    }
}

HttpServletRequest를 일종의 Model로 사용한다. setAttribute를 이용해 request에 데이터를 보관하여 뷰에 전달한다.

아까, view 구성할 때 사용한 ${} 문법이 일종의 getAttribute와 동일한 역할이라고 보면 된다 :D

여기서 RequestDispatcher는 클라이언트의 요청을 JSP로 넘겨주는 역할을 한다고 볼 수 있다.

🚩 이때, HttpServletResponse의 sendRedirect()를 이용하면 원하는 경로로 이동을 할 수 있지만, HTTP의 리다이렉션을 이용하는 것이기 때문에 브라우저에게 직접적인 response를 준 다음. 브라우저에서 지정받은 요청 경로로 또 다시 재요청을 하게 되어서 2번의 연산이 발생하게 된다.

: 즉, 위 방법은 클라이언트가 인지하기 때문에 실제 URL 경로까지 변경된다.

또한, 최초 요청을 처리한 내용을 리다이렉트 된 요청에서 공유가 안 되기 때문에 (이미 클라이언트에게 전달) 쿠키나 세션 같은 별도의 상태를 담아두는 보관소가 필요하게 된다. 그러나, 이는 cost 적으로 생각해보았을 때 매우 낭비이다.

그렇기 때문에, requestDispatcher의 forward 방식을 이용하면 서버 내부에서 호출할 수 있다.

이는 현재 요청을 처리 중인 서블릿이 속해있는 웹 애플리케이션 범위 내에서 범위를 조절할 수 있다!

즉, 1번의 HTTP 요청 내에서 처리가 가능해진다.

🎈 클라이언트가 a.jsp 요청 -> 서버 내부에서 forward를 통해 b.jsp 호출 -> 클라이언트에게 b.jsp 결과 응답.

[MemberListController.java] - 회원 목록 컨트롤러

public class MemberListController implements SMemberController{
    private final SMemberRepository repository
            = SMemberRepository.getRepository();

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

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

[FrontController.java] - 프론트 컨트롤러

@WebServlet(name = "frontController", urlPatterns = "/front-controller/*")
public class FrontController extends HttpServlet {
    private Map<String, SMemberController> controllerMap
             = new HashMap<>();

    public FrontController() {
        controllerMap.put("/front-controller/members/new-form", new
                MemberFormController());
        controllerMap.put("/front-controller/members/save", new
                MemberSaveController());
        controllerMap.put("/front-controller/members", new
                MemberListController());
    }

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("FrontController.service");
        String requestURI = req.getRequestURI();
        SMemberController controller = controllerMap.get(requestURI);

        if(controller == null) {
            resp.setStatus(HttpServletResponse.SC_NOT_FOUND);
            return;
        }
        controller.process(req, resp);
    }
}

- ControllerMap을 두었다. key는 매핑 URL을, value는 호출될 컨트롤러를 의미한다.

- controller가 없는 경우 404, 있다면 process를 통해 컨트롤러를 실행해주었다.

🚩 참고로, FrontController의 경우 서블릿 컨테이너에 등록될 때 생성자가 호출되어 객체가 만들어진다고 이해하면 된다 :)

/front-controller/members/new-form

/front-controller/members/save

/front-controller/members

- 모두 다 잘 동작하는 것을 볼 수 있다. (실수로 2번 등록해서 같은 게 2번씩 들어갔다...ㅎㅎ)

✔ V2 - View 이동 분리하기

- 이전의 V1 같은 경우 viewPath를 지정하여 RequestDispatcher를 활용해 뷰로 이동시켰다.- 다만, 코드가 다 중복되는 부분이기 때문에 상당히 불편하다. 이에 대해 따로 처리하는 객체를 만들어보자!

[MyView.java]

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

- render()라는 함수를 따로 만들어서 공통적으로 처리할 수 있게 두었다.

[SMemberController.java] - 수정

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

[MemberFormController.java] - 수정

public class MemberFormController implements SMemberController{
    @Override
    public MyView process(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        return new MyView("/WEB-INF/views/new-form.jsp");
    }
}

- viewPath를 넘겨주는 MyView 객체를 새롭게 생성하였다. frontController에서 해당 myView 객체를 참조하여 render를 실행할 예정이다.

- 마찬가지로 남은 파일들도 수정해보자.

[MemberSaveController.java] - 수정

public class MemberSaveController implements SMemberController {
    private final SMemberRepository repository
            = SMemberRepository.getRepository();

    @Override
    public MyView process(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String username = request.getParameter("username");
        int age = Integer.parseInt(request.getParameter("age"));

        SMember member = new SMember(username, age);
        repository.save(member);

        request.setAttribute("member", member);

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

[MemberListController.java] - 수정

public class MemberListController implements SMemberController {
    private final SMemberRepository repository
            = SMemberRepository.getRepository();

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

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

[FrontController.java] - 수정

@WebServlet(name = "frontController", urlPatterns = "/front-controller/*")
public class FrontController extends HttpServlet {
    private Map<String, SMemberController> controllerMap
             = new HashMap<>();

    public FrontController() {
        controllerMap.put("/front-controller/members/new-form", new
                MemberFormController());
        controllerMap.put("/front-controller/members/save", new
                MemberSaveController());
        controllerMap.put("/front-controller/members", new
                MemberListController());
    }

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        System.out.println("FrontController.service");
        String requestURI = req.getRequestURI();
        SMemberController controller = controllerMap.get(requestURI);

        if(controller == null) {
            resp.setStatus(HttpServletResponse.SC_NOT_FOUND);
            return;
        }
        MyView view = controller.process(req, resp);
        view.render(req, resp);
    }
}

- controller.process()를 통해 service() 함수로 리턴받은 MyView 객체를 이용하여 .render()를 호출해 뷰를 그려주었다.

- 마찬가지로 실행해보면 잘 동작하는 것을 볼 수 있다.

✔ V3 - Model 추가하기

- V2에서 중복을 제거해서 각 컨트롤러의 코드가 상당히 깔끔해졌다.

- 하지만, HttpServletRequest / Response를 내부적으로 꼭 사용을 해야 할까?

- 물론, 필요한 경우가 있을 수 있겠지만, 정확하게는 파라미터 정보가 필요한 것이지, req/resp가 필요한 것은 아니다.

- req 객체를 Model로 사용하는 것이 아니라, 별도의 Model 객체를 생성해서 반환해보자.

- 이렇게 하면 컨트롤러가 서블릿에 종속적이지 않아도 되기 때문에 코드가 더 단순해진다.

- 추가적으로, View의 이름이 중복되는 부분이 있기 때문에 (/WEB-INF/views) 뷰의 논리 이름을 반환하도록 해보자.

[ModelView.java]

@Getter @Setter
public class ModelView {
    private String viewName;
    private Map<String, Object> model = new HashMap<>();

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

- 뷰의 이름과 모델 객체를 함께 가지고 있다는 의미로 ModelView라는 이름을 지었다.

- 모델의 데이터는 파라미터 네임 - 실제 값 형태로 map에 저장해주면 된다.

[SMemberController.java] - 수정

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

- 이번에는 ModelView를 리턴하도록 변경하였다. 또한, 파라미터로 더 이상 서블릿 기술을 사용하지 않는다!

- HttpServletRequest를 model로 사용하지 않고, paramMap을 이용해서 파라미터를 전달해주자.

[MemberFormController.java] - 수정

public class MemberFormController implements SMemberController{
    @Override
    public ModelView process(Map<String, String> paramMap) {
        return new ModelView("new-form");
    }
}

- 이런 식으로 view의 논리적인 이름을 리턴하도록 변경하였다.

[MemberSaveController.java] - 수정

public class MemberSaveController implements SMemberController {
    private final SMemberRepository repository
            = SMemberRepository.getRepository();

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

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

- 파라미터 정보를 map에서 꺼내서 사용할 수 있다.

- 뷰에게 필요한 정보를 전달해주기 위해 ModelView에 model 필드에 put을 통해 집어넣는 식으로 진행하였다.

[MemberListController.java] - 수정

public class MemberListController implements SMemberController {
    private final SMemberRepository repository
            = SMemberRepository.getRepository();

    @Override
    public ModelView process(Map<String, String> paramMap) {
        List<SMember> members = repository.findAll();
        ModelView mv = new ModelView("members");
        mv.getModel().put("members", members);
        return mv;
    }
}

[FrontController.java] - 수정

@WebServlet(name = "frontController", urlPatterns = "/front-controller/*")
public class FrontController extends HttpServlet {
    private Map<String, SMemberController> controllerMap
             = new HashMap<>();

    public FrontController() {
        controllerMap.put("/front-controller/members/new-form", new
                MemberFormController());
        controllerMap.put("/front-controller/members/save", new
                MemberSaveController());
        controllerMap.put("/front-controller/members", new
                MemberListController());
    }

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("FrontController.service");
        String requestURI = req.getRequestURI();
        SMemberController controller = controllerMap.get(requestURI);

        if(controller == null) {
            resp.setStatus(HttpServletResponse.SC_NOT_FOUND);
            return;
        }

        Map<String, String> paramMap = createParamMap(req);
        ModelView mv = controller.process(paramMap);
        String viewName = mv.getViewName();
        MyView view = viewResolver(viewName);
        view.render(mv.getModel(), req, resp);
    }

    private Map<String, String> createParamMap(HttpServletRequest req) {
        Map<String, String> paramMap = new HashMap<>();
        req.getParameterNames().asIterator()
                .forEachRemaining(paramName -> {
            paramMap.put(paramName, req.getParameter(paramName))
        });
        return paramMap;
    }

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

}

createParamMap이라는 함수를 따로 두어서 HttpServletRequest에 있는 파라미터 정보를 꺼내 맵에 담았다.

즉, 클라이언트의 요청 URL과 파라미터가 request에 담겨있는데, 이를 꺼내서 쓴다는 것!

: 참고로, asIterator().forEachRemaining()을 쓰는 이유는 req.getParameterNames()를 했을 때 나오는 타입이 Enumeration형이어서 그렇다.

만든 맵을 controller.process()를 이용해서 전달하였으며, 반환 결과로 나온 ModelView 객체에서 논리 viewName을 꺼내준다.

이후, 꺼낸 viewName에 추가적으로 물리 경로를 설정해주었으며, 이를 viewResolver라는 이름으로 지었다!

[MyView.java] - 수정

public class MyView {
    private String viewPath;

    public MyView(String viewPath) {
        this.viewPath = viewPath;
    }

    public void render(Map<String, Object> model, HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        // model.forEach((key, value) -> request.setAttribute(key, value));
        model.forEach(request::setAttribute);
        RequestDispatcher dispatcher = request.getRequestDispatcher(viewPath);
        dispatcher.forward(request, response);
    }
}

다음과 같이 model에 담긴 파라미터를 request에 setAttribute를 통해 view에게 넘겨준다.

이때, 람다식을 사용해주면 더 쉽게 처리할 수 있다. - 마찬가지로 동일하게 결과가 나오는 걸 볼 수 있다!

✔ V4 - 단순한 게 좋아!

- V3 버전의 경우 설계가 잘 되어 있다. 다만, 코드가 비교적 복잡하고 ModelView를 개발자가 계속 만들어줘야 한다는 점이 단점이다.

- 그렇기 때문에, 우리는 위 코드를 조금 더 단순화시켜보자.

- ModelView 대신 ViewName만 반환하도록 설계할 것이다.

[SMemberController.java] - 수정

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

- 반환형을 String으로 바꾸었으며, model 객체를 파라미터로 전달하도록 변경하였다.

[MemberFormController.java] - 수정

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

- new-form이라는 논리 이름만 반환하도록 변경하였다.

[MemberSaveController.java] - 수정

public class MemberSaveController implements SMemberController {
    private final SMemberRepository repository
            = SMemberRepository.getRepository();

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

        SMember member = new SMember(username, age);
        repository.save(member);
        model.put("member", member);
        return "save-result";
    }
}

- 기존에는 ModelView 객체를 생성하여 그 내부에 있는 model 값을 넣어주는 식으로 진행하였다면, 이제는 파라미터로 전달받은 model에 추가해주면 된다. 또한, 마찬가지로 뷰의 논리 이름만 반환해주었다.

[MemberListController.java] - 수정

public class MemberListController implements SMemberController {
    private final SMemberRepository repository
            = SMemberRepository.getRepository();

    @Override
    public String process(Map<String, String> paramMap, Map<String, Object> model) {
        List<SMember> members = repository.findAll();
        model.put("members", members);
        return "members";
    }
}

[FrontController.java] - 수정

@WebServlet(name = "frontController", urlPatterns = "/front-controller/*")
public class FrontController extends HttpServlet {
    private Map<String, SMemberController> controllerMap
             = new HashMap<>();

    public FrontController() {
        controllerMap.put("/front-controller/members/new-form", new
                MemberFormController());
        controllerMap.put("/front-controller/members/save", new
                MemberSaveController());
        controllerMap.put("/front-controller/members", new
                MemberListController());
    }

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("FrontController.service");
        String requestURI = req.getRequestURI();
        SMemberController controller = controllerMap.get(requestURI);

        if(controller == null) {
            resp.setStatus(HttpServletResponse.SC_NOT_FOUND);
            return;
        }

        Map<String, String> paramMap = createParamMap(req);
        Map<String, Object> model = new HashMap<>();
        String viewName = controller.process(paramMap, model);
        MyView view = viewResolver(viewName);
        view.render(model, req, resp);
    }

    private Map<String, String> createParamMap(HttpServletRequest req) {
        Map<String, String> paramMap = new HashMap<>();
        req.getParameterNames().asIterator()
                .forEachRemaining(paramName -> {
            paramMap.put(paramName, req.getParameter(paramName));
        });
        return paramMap;
    }

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

}

- 이전과 달라진 점은 model 객체를 여기에서 만들어서 넘겨준다는 점과,

컨트롤러의 실행결과로 리턴받은 viewName을(논리 이름) viewResolver에 전달해준다는 점이다.

- 마찬가지로 이전과 동일하게 잘 실행된다 :D

✔ V5 - 여러 방법을 사용할 수 있도록 만들기

- 우리가 지금까지 개발했던 방법을 혼용하고 싶다면 어떻게 하면 좋을까?

- "어댑터 패턴"을 활용하여 다양한 방식의 컨트롤러를 처리할 수 있다!

- 중간에 핸들러 어댑터를 두어 다양한 종류의 컨트롤러를 호출할 수 있도록 하고, 우리가 지금까지 개발하였던 컨트롤러를 일종의 '핸들러'라고 생각하자.

[MyHandlerAdapter.java]

public interface MyHandlerAdapter {
    boolean supports(Object handler);
    ModelView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws ServletException, IOException;
}

- supports() 메서드를 두어서 파라미터로 핸들러를 받았다.

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

- 어댑터는 실제 컨트롤러를 호출 후 결과로 ModelView를 반환한다. 컨트롤러가 반환하지 못하면 어댑터가 직접 생성해서 반환한다.

- 이전에는 프론트 컨트롤러가 실제 컨트롤러를 호출했지만, 이제는 어댑터를 통해 컨트롤러를 호출한다.

[ControllerV3HandlerAdapter.java]

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 {
        SMemberController controller = (SMemberController) 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;
    }
}

- 이런 식으로 원하는 Controller에 맞춰서 처리하도록 넘겨주면 된다.

(V3, V4에 맞도록 갈아끼운다고 생각해주면 될 것 같다)

[ControllerV4HandlerAdapter.java]

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

- 여기서 중요한 점은, 기존에 viewName만 반환했던 V4의 특징을 위해서 '어댑터'에서 ModelView 객체를 생성하여 반환한다는 점이다.

- 핸들러가 아닌, 어댑터에서 ModelView를 만들고 setModel을 통해 모델을 넣어주는 역할까지 해준다.

- 즉, 어댑터가 형식에 맞춰서 반환해주는 역할을 하는 것이다!!

[FrontController.java] - 수정

@WebServlet(name = "frontController", urlPatterns = "/front-controller/*")
public class FrontController extends HttpServlet {
    private Map<String, SMemberController> handlerMappingMap
             = new HashMap<>();
    private List<MyHandlerAdapter> handlerAdapters = new ArrayList<>();

    public FrontController() {
        initHandlerMapping();
        initHandlerAdapters();
    }

    private void initHandlerAdapters() {
        handlerAdapters.add(new ControllerV3HandlerAdapter());
        handlerAdapters.add(new ControllerV4HandlerAdapter());
    }

    private void initHandlerMapping() {
        // V3
        handlerMappingMap.put("/front-controller/members/new-form", new
                MemberFormController());
        handlerMappingMap.put("/front-controller/members/save", new
                MemberSaveController());
        handlerMappingMap.put("/front-controller/members", new
                MemberListController());

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

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Object handler = getHandler(req);

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

        MyHandlerAdapter adapter = getHandlerAdapter(handler);
        ModelView mv = adapter.handle(req, resp, handler);

        MyView view = viewResolver(mv.getViewName());
        view.render(mv.getModel(), req, resp);
    }

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

}

- handlerMappingMap에 URI과 매핑된 핸들러 객체를 저장하고 있다.

- getHandler를 통해서 핸들러 매핑 정보인 handlerMappingMap에서 URI에 매핑된 핸들러를 찾아서 반환한다.

- getHandlerAdapter에서 support 메서드로 해당 핸들러를 처리할 수 있는 어댑터를 찾는다.

- 반환받은 어댑터를 이용해 handle 메서드로 실제 핸들러가 호출되고, 프로세스를 처리한 결과인 ModelView를 반환받는다.

- 우리는 V1~V5까지 점진적으로 발전시켜나가며 MVC 구조를 익혔다.

- 여기에 더불어서, 어노테이션을 활용하면 컨트롤러를 더 발전시킬 수 있다!

- 이제 스프링에서 MVC를 어떻게 지원하는지 확인해보자.

'Back-end > Spring' 카테고리의 다른 글

[Spring] HTTP 요청 파라미터, 응답 데이터 생성, HttpMessageConverter와 ArgumentResolver (0)	2022.08.17
[Spring] DispatcherServlet의 동작 과정과 HanderMapping, HandlerAdapter, @RequestMapping (0)	2022.08.16
[Spring] 서블릿이란? HttpServletRequest, HttpServletResponse (0)	2022.08.10
[Spring] WAS, 서블릿, 멀티 스레드와 스레드 풀 (0)	2022.08.08
[Spring] 빈 생명주기 콜백, 빈 스코프 (0)	2022.08.07

'Back-end/Spring' Related Articles

Comments

DevLog 😶

[Spring] MVC 패턴이란, V1~V5로 MVC 프레임워크 만들기 본문

[Spring] MVC 패턴이란, V1~V5로 MVC 프레임워크 만들기

| MVC 패턴이란?

| MVC 프레임워크

'Back-end > Spring' 카테고리의 다른 글

티스토리툴바