Front-Controller 패턴

프론트 컨트롤러 패턴 

• 프론트 컨트롤러는 서블릿 하나로 클라이언트들의 요청을 받습니다.

기존 컨트롤러

• 기존에는 하나의 스레드가 하나의 컨트롤러를 받아 사용했지만 프론트 컨트롤러는 모든 클라이언트가 하나의 컨트롤러를 받아 사용( 공통 업무 처리) 한다는 차이가 있습니다.

프론트 컨트롤러

• 입구를 하나로 만들었기 때문에 프론트 컨트롤러에서 공통 처리가 가능합니다.

스프링 웹 MVC의 핵심도 바로 FrontController입니다.

 

DispatcherServlet이 FrontController 패턴으로 구현되어 있는데, 처음부터 최종적 FrontController 패턴을 설명하기엔 어려움이 있어 단계적으로 풀어 나가보도록 하겠습니다.

 

이번 포스팅에서는 FrontController 패턴을 버전 1부터 3까지 단계적으로 도입해보고 다음 포스팅에서 버전 4, 5를 도입해보겠습니다.

---

Ver 1. 프론트 컨트롤러 도입

Front Controller Version 1

1. Client 에서 HTTP 요청이 들어옵니다.
2. (Front Controller 에서) 요청 메시지로부터 받은 URI와 컨트롤러를 매핑합니다.
3. (Front Controller 에서) 매핑된 컨트롤러를 호출합니다.
4. (Controller 에서) JSP로  Forward를 합니다.
5. JSP로부터 Client에게 HTML 응답을 합니다.

말로 설명하는 것보다 코드를 알아보겠습니다.

 

ControllerV1 (Interface)

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

HTTP 요청에 따라 사용할 컨트롤러가 다르기 때문에 인터페이스를 사용한 다형성을 이용하기 위해 일단 인터페이스를 도입했습니다.

(process 메소드 : JSP로 forward)

 

Front-Controller

@WebServlet(name="frontControllerServletV1", urlPatterns = "/front-controller/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);
    }
}

 

1.  프론트 컨트롤러 생성자에서 URI와 컨트롤러를 매핑하여 ControllerMap에 저장 

(  등록 폼 URI ) - ( MemberFormControllerV1 )

(  저장 URI ) - ( MemberSaveControllerV1 ) 

(  목록 URI ) - ( MemberListControllerV1 ) 

 

2. service에서 request로 부터 URI를 get하여 ControllerMap으로 부터 컨트롤러 추출

 

3. 각 controller에서 process 메소드로 jsp로 forward (다형성 활용)

 

등록

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

 

1. process() 메소드에서 viewPath : /WEB-INF/views/new-form.jsp로 이동

• ❗️/WEB-INF/* 경로는 외부 접근 불가 

2. RequestDispatcher를 통해 JSP로 이동

• dispatcher.forward() : 다른 Servlet이나 JSP로 이동할 수 있는 기능으로 서버 내부에서 호출이 일어나기 때문에 redirect와 달리 클라이언트는 인지할 수 없습니다.

저장

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

/new-form.jsp 에서 파라미터로 등록된 값을 조회해서 /save 에 POST 한 상태입니다.

 

1. 파라미터 매핑을 통해 값들을 추출합니다.
2. 인스턴스를 만들어 리포지토리에 저장합니다.
3. 이 때 이전과 동일하게 request에 setAttribute를 하여 Model처럼 사용했습니다.
4. dispatcher로 forward하여 JSP로 이동

리스트

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

1. 리포지토리로 부터 findAll해서 members(List)에 대입
2. request(Model) 에 members(List) 저장 by setAttribute
3. dispatcher로 forward하여 members.jsp 로 이동 

members.jsp

<c:forEach var="item" items="${members}">
    <tr>
        <td>${item.id}</td>
        <td>${item.username}</td>
        <td>${item.age}</td>
    </tr>
</c:forEach>

member.jsp는 iterator하여 각 인스턴스 필드 출력합니다. 

---

Ver2. View 분리

앞 ver1 에서는 다음과 같이 모든 컨트롤러에 뷰로 이동하는 부분에 중복이 있고 깔끔하지 않습니다.

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

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

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

이 부분을 깔끔하게 분리하기 위해 별도로 뷰를 처리하는 객체를 만들고 ver1을 조금 리펙터링해서 ver2를 만들어보도록 하겠습니다.

Front Controller Ver 2

ControllerV2 (interface)

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

 

FrontControllerV2

@WebServlet(name="frontControllerServletV2",urlPatterns = "/front-controller/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 {
        System.out.println("FrontControllerServletV2.service");
        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);
    }
}

 

ver1에서 MyView가 추가되었습니다.

 

MyView를 먼저 살펴보고 로직을 살펴보겠습니다.

 

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

}

1. 인스턴스 필드로 viewPath를 가짐.
2. render()를 통해 viewPath JSP로 forward하도록 함.

FrontControllerV2에서는 이제 다음 작업을 수행합니다.

• 각 컨트롤러가 process 한 뒤에 (JSP forward 하기 전 작업들 ex) 파라미터 매핑, 리포지토리 저장 등등.. ) viewPath를 리턴 
• view에서 render()를 통해 JSP forward 

등록

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

이전과 동일하게 폼만 제시

저장

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

이제 파라미터 매핑만 수행 후 리포지터리에 저장만 하고 뷰를 리턴합니다. ( JSP forward 는 수행 x )

목록

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

멤버 리스트를 파라미터 매핑만하고 뷰를 리턴 ( JSP forward는 Front-Controller 의 render()로 수행 ) 

ver1 ▷ ver2

1. 이제 컨트롤러가 view를 반환합니다.

2. 기존 ver 1 : Controller가 process()를 통해 JSP forward 수행

            ver 2: FrontController에서 Controller(컨트롤러는 JSP 이전 작업 수행)에서 리턴된 view를 통해 render()를 사용해서 JSP forward 수행

 

---

Ver3. Model 추가

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

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

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

 

우선 ver2의 각 컨트롤러 입장에서 봤을 때, HttpServletRequest, HttpServletResponse는 요청정보를 Map으로 대신 넘기도록 설정하면 컨트롤러가 서블릿 기술을 몰라도 동작할 수 있습니다.

 

1. 구현했던 컨트롤러가 서블릿 기술을 전혀 사용하지 않도록 변경해보겠습니다.

 

2. 또 각 컨트롤러의 뷰 이름에는 중복이 있는 것을 볼 수 있는데 ( /WEB-INF/views/~~~.jsp) 컨트롤러는 뷰의 논리 이름을 반환하고,

실제 물리적 위치의 이름은 프론트 컨트롤러에서 처리하도록 단순화해보겠습니다.

 

3. 그리고 request 객체를 Model로 사용하지 않고 별도의 Model 객체를 만들어서 사용하도록 하겠습니다.

• 이렇게 하면 구현 코드도 단순해지고, 테스트 코드 작성도 쉬워집니다. 왜 why -> request를 ObjectMapper를 사용해서 만들어주지 않아도 되니까.

조금 복잡해졌습니다. 

ver2 ➣ ver3

• 뷰 이름 중복 제거
• 서블릿 종속성 제거 
• request객체가 아닌 실제 Model 도입

ControllerV3 ( Interface )

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

ControllerV2 (interface)

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

 

기존 Ver2와 달리 request, response를 파라미터로 받지 않습니다.

 

1. 대신 Map을 Model처럼 사용해 request 파라미터 정보를 저장하도록 함. process 메소드를 통해 파라미터 매핑이 끝나고 난 뒤 ViewPath를 ModelView에 필드로 주입해서 리턴할 예정.

2. JSP로 forward하는 작업은 render 메소드에 파라미터로 앞서 저장한 ModelView를 넘겨주어 ModelView의 ViewPath 필드값을 통해 진행할 예정. 

 

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

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

 

ModelView는 복잡하게 생각할 것 없이 그냥 Model+View라고 생각하시면 됩니다. 

 

Model -> Map<String, Object> -> <jsp에 넘겨줄 객체 이름, 객체> 

ex) (key,value) = ("member",member), ("members",members)

View -> 뷰 논리 이름 저장

 

FrontControllerV3

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

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

    public FrontControllerServletV3()
    {
        controllerMap.put("/front-controller/v2/members/new-form", new MemberFormControllerV3());
        controllerMap.put("/front-controller/v2/members/save", new MemberSaveControllerV3());
        controllerMap.put("/front-controller/v2/members", new MemberListControllerV3());
    }

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("FrontControllerServletV3.service");
        String requestURI = request.getRequestURI();

        ControllerV3 controller = controllerMap.get(requestURI);
        if (controller == null) {
            response.setStatus(HttpServletResponse.SC_NOT_FOUND);
            return;
        }

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

 

큰 그림을 보자면 아래 순서대로 로직이 실행됩니다.

 

1. HTTP 요청

 

2. URI - Controller 매핑정보 ControllerMap에 저장합니다.

 

3. request URL을 보고 매핑된 컨트롤러 추출합니다.

 

4. request에 대한 파라미터 맵을 만들어 paramMap에 저장 ( iterator로 저장 / createParamMap 메소드 참조 )

 

5. 컨트롤러에서 paramMap을 통한 process(paramMap) 수행

( process() 메소드에서는 이제 request객체가 아니라 paramMap을 사용해서 파라미터 값 참조) 하고 ModelView("뷰 논리이름(viewName)") 리턴합니다.

 

6. 리턴된 ModelView의 필드값 viewName을 viewResolver에게 넘겨줍니다.

 

7. ViewResolver는 받은 viewName을 통해 MyView("/WEB-INF/views" + viewName + ".jsp") 리턴하여 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));
}

8. 생성된 MyView에서 ModelView의 model인스턴스를 파라미터로 받아서 model(key,value) -> request로 setAttribute(key,value) 하여 파라미터 값을 저장해줍니다.

 

9. 이전과 동일하게 RequestDispatcher 객체에 파라미터로 8번에서 파라미터 값이 셋팅된 request 객체를 사용해 JSP로 forward합니다. 

 

 

등록

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

ModelView를 생성할때 "new-form"이라는 view의 논리적인 이름을 지정합니다.

실제 물리적인 이름은 뷰 논리이름을 통해서 프론트컨트롤러의 viewResolver에서 처리하도록 했습니다. (FrontController 코드 참조)

 

저장

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 

필드 1. model에는 뷰에서 필요한 member 객체를 담았습니다.

필드 2. ViewName에는 뷰의 논리주소 저장했습니다.

 

목록 

public class MemberListControllerV3 implements ControllerV3 {

    private MemberRepository memberRepository = MemberRepository.getInstance();

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

        return mv;
    }
}

ModelView

필드 1. model 에는 뷰에서 필요한 객체인 members(List) 저장했습니다.

필드 2. ViewName 에는 뷰의 논리이름을 저장했습니다.

 

역할 분담과 분리가 생기면서 많이 복잡해졌습니다.

 

특히 ModelView를 생성하고 리턴하는 부분이 조금 번거롭기도 합니다. 다음 포스팅에서는 ver 4,5를 통해 이 번거로움을 개선해 보도록 하겠습니다.

---

Ver 4. Ver3 리펙터링

ControllerV3 (Interface)

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

 

ControllerV4 (interface)

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

 

각 컨트롤러는 process이후 ModelView 리턴 ( Model : JSP에 전달 될 객체이름-객체 매핑, View : 뷰 논리 이름 )

➣ Ver4에서는 파라미터로 model을 추가적으로 받아 ViewName을 String으로 리턴한다. 

즉, Front-Controller에서 미리 ModelView를 만들어 놓고 ModelView의 model 필드를 get으로 받아, 컨트롤러 호출 시 파라미터로 넘겨주도록 설정하였습니다.

 

FrontControllerServletV4

package hello.servlet.web.frontcontroller.v4;

import hello.servlet.web.frontcontroller.ModelView;
import hello.servlet.web.frontcontroller.MyView;
import hello.servlet.web.frontcontroller.v3.ControllerV3;
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.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 controllerV4 = controllerMap.get(requestURI);

        Map<String,String> paramMap = createParamMap(request);
        ModelView mv = new ModelView();
        String viewName = controllerV4.process(paramMap, mv.getModel());

        MyView view = new MyView(viewResolver(viewName));

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

    }

    private Map<String, String> createParamMap(HttpServletRequest request) {

        Map<String, String> pm = new HashMap<>();

        request.getParameterNames().asIterator()
                .forEachRemaining(paramName-> pm.put(paramName,request.getParameter(paramName)));

        return pm;
    }

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

파라미터 매핑을 위한 paramMap과 JSP로 forward 할 때 사용할 model을 미리 service단계에서 설정해주었습니다.

모델 객체를 프론트 컨트롤러에서 생성해서 넘겨주기 때문에, 컨트롤러에서 모델 객체에 값을 담으면 여기에 그대로 담겨있게 됩니다.

 

등록

public class MemberFormControllerV4 implements ControllerV4 {
    @Override
    public String process(Map<String, String> paramMap, Map<String, Object> model) throws IOException, ServletException
    {
        return "new-form";
    }
}

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

저장

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

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

import javax.servlet.ServletException;
import java.io.IOException;
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) throws IOException, ServletException
    {
        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";
    }
}

paramMap에 저장된 값을 통해 멤버 인스턴스 생성

-> 리포지토리 저장

-> model에 put

-> 뷰 논리이름 (ViewName) 리턴

조회

public class MemberListControllerV4 implements ControllerV4 {
    private MemberRepository memberRepository = MemberRepository.getInstance();

    @Override
    public String process(Map<String, String> paramMap, Map<String, Object> model) throws IOException, ServletException
    {
        List<Member> members = memberRepository.findAll();
        model.put("members",members);

        return "members";
    }
}

model에 리포지토리에서 멤버들 꺼내서 put

-> 뷰 논리이름 리턴 

---

<참고자료>

https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-mvc-1/dashboard

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