스프링 MVC 구조 이해하기

본 포스팅은 인프런 - 스프링 MVC 1편을 강의를 바탕으로 공부하고 정리한 글입니다.

 

스프링 MVC - 전체 구조

---

이전 포스팅에서 직접 만들어본 MVC 프레임워크의 구조와 스프링 MVC 구조를 비교해보자.

 

• 직접 만든 MVC 프레임워크 구조
  
• 스프링 MVC 구조
  

 

대부분의 구조가 거의 똑같지만, 다음과 같이 명칭이 조금 달라졌다.

• 직접 만든 프레임 워크 ➡ 스프링 MVC 비교
  • FrontController ➡ DispatcherServlet
  • handlerMappingMap ➡ HandlerMapping
  • MyHandlerAdapter ➡ HandlerAdapter
  • ModelView ➡ ModleAndView
  • viewResolver ➡ ViewResolver
  • MyView ➡ View

 

DispatcherServlet

스프링 MVC도 프론트 컨트롤러 패턴으로 구현되어 있다.

스프링 MVC의 프론트 컨트롤러가 바로 디스패처 서블릿(DispatcherServlet)이다.

 

디스패처 서블릿도 부모 클래스에서 HttpServlet을 상속받아 사용하므로, 서블릿으로 동작한다.

• DispatcherServlet  ➡  FrameworkServlet  ➡  HttpServletBean  ➡  HttpServlet

스프링 부트는 DispatcherServlet을 자동으로 서블릿으로 등록하며, 모든 경로(urlPatterns="/")에 대해 디스패처 서블릿으로 매핑한다. (참고로 더 자세한 경로가 매핑의 우선순위를 가진다. 따라서 기존에 등록한 서블릿도 함께 동작한다.)

 

💡 요청 흐름

• DispatcherServlet이 호출되면 HttpServlet이 제공하는 service()가 호출된다.
• 스프링 MVC는 DispatcherServlet의 부모인 FrameworkServlet에서 service()를 오버라이딩 해두었다.
• FrameworkServlet.service()를 시작으로 여러 메소드가 호출되면서 DispatcherServlet.doDispatch()가 호출된다.

 

💡 DispatcherServlet.doDispatch() 핵심 로직 분석

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) 
throws Exception {
    HttpServletRequest processedRequest = request;
    HandlerExecutionChain mappedHandler = null;
    ModelAndView mv = null;
    
    // 1. 핸들러 조회
    mappedHandler = getHandler(processedRequest);
    if (mappedHandler == null) {
        noHandlerFound(processedRequest, response);
        return;
	}

    // 2. 핸들러 어댑터 조회 - 핸들러를 처리할 수 있는 어댑터
    HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

    // 3. 핸들러 어댑터 실행 -> 4. 핸들러 어댑터를 통해 핸들러 실행 -> 5. ModelAndView 반환
    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
    processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
}

private void processDispatchResult(HttpServletRequest request, HttpServletResponse response, 
HandlerExecutionChain mappedHandler, ModelAndView mv, Exception exception) throws Exception {
    // 뷰 렌더링 호출
    render(mv, request, response);
}

protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) 
throws Exception {
    View view;
    String viewName = mv.getViewName();
    
    // 6. 뷰 리졸버를 통해서 뷰 찾기, 7. View 반환
    view = resolveViewName(viewName, mv.getModelInternal(), locale, request);
    
    // 8. 뷰 렌더링
    view.render(mv.getModelInternal(), request, response);
}

 

동작 순서

1. 핸들러 조회 : 핸들러 매핑을 통해 요청 URL에 매핑되는 핸들러(컨트롤러)를 찾는다.
2. 핸들러 어댑터 조회 : 핸들러를 실행할 수 있는 핸들러 어댑터를 찾는다.
3. 핸들러 어댑터 실행 : 핸들러 어댑터를 실행한다.
4. 핸들러 실행 : 핸들러 어댑터는 실제 핸들러(컨트롤러)를 실행한다.
5. ModelAndView : 핸들러 어댑터는 핸들러가 반환하는 정보를 ModelAndView로 변환해 디스패처 서블릿에 반환한다.
6. viewResolver 호출 : 뷰 리졸버 찾아 실행한다.
   • JSP의 경우 : InternalResourceViewResolver가 자동으로 등록되고 사용된다.
7. View 반환 : 뷰 리졸버는 뷰의 논리이름을 물리이름으로 바꾸고, 렌더링에 필요한 View객체를 반환한다.
   • JSP의 경우 : InternalResourceView(JstlView)를 반환하며, 이 객체 내부에 forward() 로직이 들어있다.
8. 뷰 렌더링 : View를 통해 렌더링 한다.

 

주요 인터페이스

스프링 MVC의 큰 강점은 DispatcherServlet 코드의 변경 없이, 원하는 기능을 변경하거나 확장할 수 있다는 점이다.

스프링 MVC는 대부분을 확장 가능할 수 있도록 인터페이스로 제공한다.

이런 인터페이스들을 구현해 DispatcherServlet에 등록하면 우리들만의 컨트롤러를 만들 수 있다!

 

💡 주요 인터페이스 목록

• 핸들러 매핑 : org.springframework.web.servlet.HandlerMapping
• 핸들러 어댑터 : org.springframework.web.servlet.HandlerAdapter
• 뷰 리졸버 : org.springframework.web.servlet.ViewResolver
• 뷰 : org.springframework.web.servlet.View

 

 

핸들러 매핑, 핸들러 어댑터

---

이전에는 핸들러 매핑과 핸들러 어댑터를 단순하게 Map, List 컬렉션을 사용해 등록한 뒤 매핑시켜 사용했다.

스프링 MVC에서는 핸들러 매핑과 핸들러 어댑터를 어떻게 사용하는지 알아보자.

 

웹 브라우저의 URL 요청이 왔을 때 핸들러(컨트롤러)를 호출하기 위해서는 핸들러 매핑과 핸들러 어댑터가 필요하다.

스프링 부트에서는 자동으로 다양한 핸들러 매핑과 핸들러 어댑터를 등록해준다.

 

💡 HandlerMapping(핸들러 매핑)

• 핸들러 매핑에서 해당 핸들러(컨트롤러)를 찾을 수 있어야한다.
• 예) 스프링 빈의 이름으로 핸들러를 찾을 수 있는 핸들러 매핑이 필요하다. →BeanNameUrlHandlerMapping

0 = RequestMappingHandlerMapping  :  애노테이션 기반의 컨트롤러인 @RequestMapping에서 사용
1 = BeanNameUrlHandlerMapping     :  스프링 빈의 이름으로 핸들러를 찾는다.

 

💡 HandlerAdapter(핸들러 어댑터)

• 핸들러 매핑을 통해 찾은 핸들러를 실행할 수 있는 핸들러 어댑터가 필요하다.
• 예) Controller 인터페이스를 실행할 수 있는 핸들러 어댑터를 찾고 실행한다. → SimpleControllerHandlerAdapter

0 = RequestMappingHandlerAdapter    :  애노테이션 기반의 컨트롤러인 @RequestMapping에서 사용
1 = HttpRequestHandlerAdapter       :  HttpRequestHandler 처리
2 = SimpleControllerHandlerAdapter  :  Controller 인터페이스(애노테이션X, 과거에 사용) 처리

 

다양한 핸들러 매핑과 핸들러 어댑터 중 가장 우선순위가 높은 것은 다음과 같다.

• 핸들러 매핑 : RequestMappingHandleMapping
• 핸들러 어댑터 : RequestMappingHandlerAdapter

@RequestMapping의 앞글자를 따서 만든 이름으로, 이것이 바로 스프링에서 주로 사용하는 어노테이션 기반의 컨트롤러를 지원하는 매핑과 어댑터이다.

실무에서는 99.9% 이 방식의 컨트롤러를 사용한다 !

Controller 인터페이스

👉🏻 Controller 인터페이스

public interface Controller {
	ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception;
}

• org.springframework.web.servlet.mvc.Controller
• 과거 스프링은 이러한 형식의 컨트롤러 인터페이스를 제공했다.

이 Controller 인터페이스를 구현해 간단하게 핸들러 매핑 테스트를 해보자.

👉🏻 OldController (구현체)

@Component("/springmvc/old-controller") // 스프링 빈 이름
public class OldController implements Controller {

    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        System.out.println("OldController.handleRequest");
        return null;
    }
}

• @Component("/springmvc/old-controller")
  • 컴포넌트 스캔에 의해 /springmvc/old-controller 이름의 스프링 빈으로 등록된다.
  • 이 스프링 빈 이름으로 URL 매핑을 한다.
• 실행
  • http://localhost:8080/springmvc/old-controller
  • 콘솔에 OldController.handleRequest 출력 시 성공

URL(/springmvc/old-controller )을 통해 해당 핸들러(컨트롤러)를 어떻게 찾을 수 있을까?
핸들러 매핑과 핸들러 어댑터에서 모두 순서대로 찾은 뒤 만약 없다면 다음 순서로 넘어간다.

 

✅ 동작 순서

1. 핸들러 매핑으로 핸들러 조회
   • 핸들러 매핑을 순서대로 실행하며 적절한 핸들러를 찾는다.
   • 예제같은 경우 빈 이름으로 핸들러를 찾아야 하기 때문에 BeanNameUrlHandlerMapping이 실행에 성공하고, 핸들러로 OldController이 매핑되어 반환한다.
2. 핸들러 어댑터 조회
   • 핸들러 어댑터에서 해당 핸들러(OldController)를 처리할 수 있는 어댑터를 찾는다.
   • SimpleControllerHandlerAdapter가 Controller 인터페이스를 지원하므로 핸들러 어댑터로 선택되어 반환된다.
3. 핸들러 어댑터 실행
   • 디스패처 서블릿이 반환된 어댑터(SimpleControllerHandlerAdapter)를 호출하며 핸들러(OldController) 정보를 넘겨준다.
   • 어댑터는 내부에서 핸들러(OldController)를 실행하고, 그 결과를 반환한다.

 

HttpRequestHandler

핸들러 매핑과, 핸들러 어댑터를 더 잘 이해하기 위해 이번에는 Controller 인터페이스가 아닌 HttpRequestHandler 핸들러(컨트롤러)를 알아보자.

👉🏻 HttpRequestHandler 인터페이스

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

이를 간단하게 구현해 간단하게 핸들러 매핑 테스트를 해보자.

👉🏻 MyHttpRequestHandler (구현체)

@Component("/springmvc/request-handler")
public class MyHttpRequestHandler implements HttpRequestHandler {

    @Override
    public void handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println("MyHttpRequestHandler.handleRequest");
    }
}

• @Component("/springmvc/request-handler")
  • 컴포넌트 스캔에 의해 /springmvc/request-handler 이름의 스프링 빈으로 등록된다.
  • 이 스프링 빈 이름으로 URL 매핑을 한다.
• 실행
  • http://localhost:8080/springmvc/request-handler
  • 콘솔에 MyHttpRequestHandler.handleRequest 출력시 성공

 

✅ 동작 순서

1. 핸들러 매핑으로 핸들러 조회
   • 핸들러 매핑을 순서대로 실행해 적절한 핸들러를 찾는다.
   • 예제의 경우 빈 이름으로 핸들러를 찾아야 하기 때문에 BeanNameUrlHandlerMapping이 실행에 성공하고,
     핸들러로 MyHttpRequestHandler이 매핑되어 반환한다.
2. 핸들러 어댑터 조회
   • 핸들러 어댑터에서 해당 핸들러(MyHttpRequestHandler)를 처리할 수 있는 어댑터를 찾는다.
   • HttpRequestHandlerAdapter가 HttpRequestHandler 인터페이스를 지원하므로 핸들러 어댑터로 선택되어 반환된다.
3. 핸들러 어댑터 실행
   • 디스패처 서블릿이 반환된 어댑터(HttpReqeustHandlerAdapter)를 실행하며 핸들러(MyHttpRequestHandler) 정보를 넘겨준다.
   • 어댑터는 핸들러(MyHttpRequestHandler)를 내부에서 실행하고, 그 결과를 반환한다.

 

 

뷰 리졸버

---

이전에는 View의 논리 이름을 물리 이름으로 완성 시켜주는 뷰 리졸버를 직접 자바 코드로 만들어 주었다.

스프링 MVC에서는 뷰 리졸버를 어떻게 만들어주는지 알아보자.

 

스프링 부트에서는 자동으로 다양한 뷰 리졸버를 등록해준다.

1 = BeanNameViewResolver          :  빈 이름으로 뷰를 찾아서 반환한다. (예: 엑셀 파일 생성기능에 사용)
2 = InternalResourceViewResolver  :  JSP를 처리할 수 있는 뷰를 반환한다.

• InternalResourceViewResolver
  • 스프링 부트는 InternalResourceViewResolver라는 뷰 리졸버를 등록할 때, application.properties라는 속성파일에 등록한 spring.mvc.view.prefix, spring.mvc.view.suffix 설정 정보를 사용해서 등록한다.
  • 따라서 application.properties에 설정 정보를 입력해 놓으면, 아래처럼 등록해줄 필요 없이 스프링 부트가 알아서 해준다.

@Bean
ViewResolver internalResourceViewResolver() {
    return new InternalResourceViewResolver("WEB/INF/views/", ".jsp");
}

 

예제

위에서 만든 OldController를 뷰 조회가 되도록 변경해보도록 하자.

📁 OldController

@Component("/springmvc/old-controller") // 스프링 빈 이름
public class OldController implements Controller {

    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        System.out.println("OldController.handleRequest");
        return new ModelAndView("new-form"); // 뷰 논리이름
    }
}

• View를 사용할 수 있도록 new ModelAndView("new-form")을 반환해준다.

변경해준 뒤 다시 http://localhost:8080/springmvc/old-controller 경로에 접속해 동작이 잘 되는지 확인해보면,

콘솔창에 OldController.handleRequest가 출력되며 컨트롤러는 정상 호출되지만, 뷰 논리 이름을 실제 물리이름으로 완성하지 못해 Whitelabel Error Page 오류가 발생한다.

 

따라서 뷰 논리이름을 물리이름으로 완성하는데 필요한 정보를 application.properties 파일에 추가해줘야 한다.

📁 resources/application.properties

// resources/application.properties에 추가
spring.mvc.view.prefix=/WEB-INF/views/
spring.mvc.view.suffix=.jsp

다시 구동해보면 정상적으로 회원가입 폼이 렌더링 된다.

 

동작 순서

1. 핸들러 어댑터 호출
   • 핸들러 어댑터를 통해 ModelAndView를 반환받아 뷰 논리 이름을 획득한다.
2. 뷰 리졸버 호출
   • 디스패처 서블릿은 뷰 논리이름으로 등록된 뷰 리졸버를 순서대로 호출한다.
   • BeanNameViewResolver는 new-form이라는 이름의 스프링 빈으로 등록된 뷰를 찾는데 없다. 
   • InternalResourceViewResolver가 호출된다.
3. InternalResourceViewResolver 호출
   
   • 이 뷰 리졸버는 InternalResourceView를 반환한다.
   • InternalResourceView는 JSP처럼 forward()를 호출해서 처리할 수 있는 경우에 사용한다.
4. view.render() 호출
   • 디스패처 서블릿은 반환받은 InternalResourceView를 통해 render()를 호출하고,
   • InternalResourceView는 forward()를 사용해 JSP를 실행한다.

JSTL 라이브러리가 있는 경우
• InternalResourceViewResolver는 JSTL 라이브러리가 있으면 InternalResourceView를 상속받은 JstlView를 반환한다.
• JstlView 는 JSTL 태그 사용시 약간의 부가 기능이 추가된다.

렌더링
• 다른 뷰는 실제 뷰를 렌더링하지만, JSP의 경우 forward() 통해서 해당 JSP로 이동(실행)해야 렌더링이 된다.
• JSP를 제외한 나머지 뷰 템플릿들은 forward() 과정 없이 바로 렌더링 된다.

Thymeleaf
• Thymeleaf 뷰 템플릿을 사용하면 ThymeleafViewResolver를 등록해야 한다.
• 최근에는 라이브러리만 추가하면 스프링 부트가 이런 작업도 모두 자동화해준다

 

 

@RequestMapping

---

스프링은 애노테이션을 활용한 매우 유연하고, 실용적인 컨트롤러를 만들었다.

 

기존에는 @WebSurvlet에서 urlPattern을 사용하거나 @Component에 빈 이름으로 URL을 작성해서 사용했지만, 스프링이 제공하는 @RequestMapping 어노테이션을 사용해 편리하게 컨트롤러 구현이 가능하다.

 

스프링이 자동 등록해주는 핸들러 매핑과 핸들러 어댑터 중 가장 우선순위가 높은 것은 RequestMappingHandlerMapping, RequestMappingHandlerAdapter이다.

• @RequestMapping
  • 핸들러 매핑    : RequestMappingHandlerMapping
  • 핸들러 어댑터 : RequestMappingHandlerAdapter

@RequestMapping 어노테이션은 이 핸들러 매핑과 어댑터 앞 글자를 따서 만든 어노테이션으로, 실무에서는 99.9% 이 방식의 컨트롤러를 사용한다.

그렇다면 이제 실제 코드를 작성해 어노테이션 기반의 컨트롤러를 사용해보자.

참고

RequestMappingHandlerMapping은 스프링 빈 중에서 @RequestMapping과 @Controller가 클래스 레벨에 붙어 있는 경우에도 매핑 정보로 인식한다. 따라서 다음 코드는 모두 동일하게 동작한다.

@Controller
public class SpringMemberFormControllerV1 {
    @RequestMapping("/springmvc/v1/members/new-form")
    public ModelAndView process() {
	    return new ModelAndView("new-form");
    }
}

@Component // 컴포넌트 스캔을 통해 스프링 빈으로 등록
@RequestMapping
public class SpringMemberFormControllerV1 {
    @RequestMapping("/springmvc/v1/members/new-form")
    public ModelAndView process() {
	    return new ModelAndView("new-form");
    }	
}

@RequestMapping
public class SpringMemberFormControllerV1 {
    @RequestMapping("/springmvc/v1/members/new-form")
    public ModelAndView process() {
    	return new ModelAndView("new-form");
    }
}

@Bean // 스프링 빈 직접 등록
TestController testController() {
	return new TestController();
}

 

v1 - 애노테이션 기반 컨트롤러

이전까지 직접 스프링 프레임워크를 만들어 사용했던 컨트롤러를 @RequestMapping 어노테이션 기반의 스프링 MVC 컨트롤러로 변경해보자.

👉🏻 회원 등록 폼 컨트롤러

📁 web.springmvc/v1/SpringMemberFormControllerV1

@Controller
public class SpringMemberFormControllerV1 {

    @RequestMapping("/springmvc/v1/members/new-form")
    public ModelAndView process() {
        return new ModelAndView("new-form");
    }
}

• @Controller
  • 스프링이 자동으로 스프링 빈으로 등록한다. (내부에 @Component가 있어 컴포넌트 스캔의 대상)
  • 스프링MVC에서 어노테이션 기반의 컨트롤러로 인식한다.
    rarr; RequestMappingHandlerMapping에서 매핑시켜줄 수 있는 핸들러(컨트롤러)로 인식된다는 의미이다.
• @RequestMapping
  • 요청 정보를 매핑한다. 해당 URL로 요청이 오면 이 메소드가 호출된다.
  • 어노테이션을 기반으로 동작하기 때문에 메소드명은 임의로 작성하면 된다.
• ModelAndView
  • 모델과 뷰 정보(뷰 논리이름)을 담아 반환하면 된다.

 

👉🏻 회원 등록 컨트롤러

📁 web/springmvc/v1/SpringMemberSaveControllerV1

@Controller
public class SpringMemberSaveCotrollerV1 {

    private MemberRepository memberRepository = MemberRepository.getInstance();

    @RequestMapping("/springmvc/v1/members/save")
    public ModelAndView 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);

        // ModelAndView 생성 및 반환
        ModelAndView mv = new ModelAndView("save-result");
        mv.addObject("member", member);
        return mv;
    }
}

• mv.addObject("member", member)
  • 스프링이 제공하는 ModelAndView를 통해 모델 데이터를 추가할 때는 addObject()를 사용한다.
  • 이 데이터는 이후 뷰를 렌더링 할 때 사용된다.

 

👉🏻 회원 목록 조회 컨트롤러

📁 web/springmvc/v1/SpringMemberListControllerV1

@Controller
public class SpringMemberListControllerV1 {

    private MemberRepository memberRepository = MemberRepository.getInstance();

    @RequestMapping("/springmvc/v1/members")
    public ModelAndView process() {
        List<Member> members = memberRepository.findAll(); // 회원 목록 조회

        // ModelAndView 생성 및 반환
        ModelAndView mv = new ModelAndView("members");
        mv.addObject("members", members);
        return mv;
    }
}

 

👉🏻 동작 확인

• 회원 등록 : http://localhost:8080/springmvc/v1/members/new-form
• 회원 저장 : http://localhost:8080/springmvc/v1/members/save
• 회원 목록 : http://localhost:8080/springmvc/v1/members

 

v2 - 통합 컨트롤러

@RequestMapping을 잘보면 URL 매핑이 클래스 단위가 아니라 메소드 단위에 적용된 것을 확인할 수 있다.

따라서 컨트롤러 클래스를 유연하게 하나로 통합할 수도 있다.

 

📁 web/springmvc/v2/SpringMemberControllerV2

@Controller
@RequestMapping("/springmvc/v2/members")
public class SpringMemberControllerV2 {

    private MemberRepository memberRepository = MemberRepository.getInstance();

    /* 회원 등록 폼 */
    @RequestMapping("/new-form")
    public ModelAndView newForm() {
        return new ModelAndView("new-form");
    }

    /* 회원 저장 */
    @RequestMapping("/save")
    public ModelAndView save(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);

        ModelAndView mv = new ModelAndView("save-result");
        mv.addObject("member", member);
        return mv;
    }

    /* 회원 목록 */
    @RequestMapping("")
    public ModelAndView members() {
        List<Member> members = memberRepository.findAll();

        ModelAndView mv = new ModelAndView("members");
        mv.addObject("members", members);
        return mv;
    }
}

• 회원 등록 폼, 회원 저장, 회원 목록 메소드들을 모두 SpringMemberControllerV2라는 하나의 컨트롤러에 모아놨다.

 

💡 매핑 URL 조합

• 매핑 URL을 보면 중복되는 부분이 있다.
  • @RequestMapping("/springmvc/v2/members/new-form")
  • @RequestMapping("/springmvc/v2/members")
  • @RequestMapping("/springmvc/v2/members/save")
• 중복 URL을 클래스 레벨의 @RequestMapping으로 두면, 메소드 레벨의 @RequestMapping과 조합된다.
  • 클래스 레벨 @RequestMapping("/springmvc/v2/members")
    • 메서드 레벨 @RequestMapping("/new-form")  ➡  /springmvc/v2/members/new-form
    • 메서드 레벨 @RequestMapping("/save")           ➡  /springmvc/v2/members/save
    • 메서드 레벨 @RequestMapping                        ➡  /springmvc/v2/members

👉🏻 동작 확인

• 회원 등록 : http://localhost:8080/springmvc/v2/members/new-form
• 회원 저장 : http://localhost:8080/springmvc/v2/members/save
• 회원 목록 : http://localhost:8080/springmvc/v2/members

 

v3 - 실용적인 컨트롤러

v2에서 컨트롤러를 하나로 통합하는 것까지 해보았다.

 

v3에서는 스프링 MVC의 다음과 같은 기능을 사용해 개발자가 조금 더 편하게 개발할 수 있도록 개선해볼 것이다.

실제 실무에서는 v3 방식을 주로 사용한다!

• 스프링이 제공하는 Model 도입
• @RequestParam 사용
• viewName 직접 반환
• @RequestMapping(value="", method="") → @GetMapping, @PostMapping

 

👉🏻 회원 통합 컨트롤러

📁 web/springmvc/v3/SpringMemberControllerV3

@Controller
@RequestMapping("/springmvc/v3/members")
public class SpringMemberControllerV3 {

    private MemberRepository memberRepository = MemberRepository.getInstance();

    /* 회원 등록 폼 */
    // @RequestMapping(value = "/new-form", method = RequestMethod.GET)
    @GetMapping("/new-form")
    public String newForm() {
        return "new-form";
    }

    /* 회원 저장 */
    // @RequestMapping(value = "/save", method = RequestMethod.POST)
    @PostMapping("/save")
    public String save(
            @RequestParam("username") String username,
            @RequestParam("age") int age,
            Model model) {

        // 회원 생성 및 저장
        Member member = new Member(username, age);
        memberRepository.save(member);

        // 모델에 저장
        model.addAttribute("member", member);

        // 뷰 이름 반환
        return "save-result";
    }

    /* 회원 목록 */
    // @RequestMapping(method = RequestMethod.GET)
    @GetMapping
    public String members(Model model) {
        List<Member> members = memberRepository.findAll(); // 회원 목록 조회
        model.addAttribute("member", members); // 모델에 저장
        return "members"; // 뷰 이름 반환
    }
}

• Model model
  • save(), members() 메소드를 보면 Model을 파라미터로 받는다.
  • Model에 저장할 데이터는 addAttribute()를 사용해 추가해주면 된다.
  • 스프링이 제공하는 Model을 사용해 ModelAndView 객체를 만들 필요가 없어졌다.
• viewName 직접 반환
  • 애노테이션 기반의 컨트롤러는 ModelAndView 뿐만 아니라 ViewName(논리 이름)을 직접 반환해주는 것이 가능하다.
• @RequestParam 사용
  • 스프링은 HTTP 요청 파라미터를 @RequestParam으로 받을 수 있다.
  • 코드에서 사용된 @RequestParam("username")은 request.getParameter("username")과 같은 역할을 한다고 보면 된다.
  • GET POST From 방식 모두 지원한다.
• @RequestMapping  → @GetMapping, @PostMapping
  • @RequestMapping은 URL만 매칭하는 것이 아니라, HTTP Method도 함께 구분할 수 있다.
    • 예) @RequestMapping(value = "/new-form", method = RequestMethod.Get)
  • 이것을 @GetMapping, @PostMapping으로 더 편리하게 사용할 수 있다.
    • 예) @GetMapping("/new-form")
  • Get, Post, Put, Delete, Patch 모두 관련 애노테이션이 존재한다.