[스프링 MVC 1편] #5. 스프링 MVC - 구조 이해

[YuDeokRin]

스프링 MVC - 구조 이해

1️⃣스프링 MVC 전체 구조

➡️앞서 만든 MVC 프레임 구조

➡️스프링MVC 구조

✅직접 만든 프레임워크 스프링 MVC 비교

• FrontController → DispatcherServlet
• handlerMappingMap → HandlerMapping
• MyHandlerAdapter → HandlerAdapter
• ModelView → ModelAndView
• viewResolver → ViewResolver
• MyView → View

✅Dispatcher Servlet 구조 살펴보기

• Dispatcher Servlet는 스프링 MVC의 핵심구조이다.
• org.springframework.web.servlet.DispatcherServlet

앞서 직접 만들어본 MVC에서 쓰이는 Front Controller 패턴으로 구현되어 있다.

➡️Dispatcher Servlet 서블릿 등록

• DispatcherServlet 도 Front Controller와 마찬가지로 HttpServlet을 상속하고 있다. 또한 서블릿으로 동작한다.

1. Dispatcher Servlet

2. FrameworkServlet

3. HttpServletBean

4. HttpServlet

➡️요청 흐름

• 서블릿이 호출되면 HttpServlet이 제공하는 service()가 호출된다.
• 스프링 MVC는 DispatcherServlet의 부모인 FrameworkServlet에서 service()를 오버라이드 해두었다.

• FramewordServlet.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);
 }

➡️동작 흐름

• SpringMVC 구조

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

• ➡️인터페이스 분석
  • Spring MVC의 큰 강점은 DispatcherServlet의 코드 변경 없이 원하는 기능을 변경하거나 확장할 수 있다는 것이다.
  • 인터페이스들만 구현해서 DispatcherServlet에 등록하면 내가 원하는 데로 컨트롤러를 만들 수 있다.

2️⃣핸들러 매핑과 핸들러 어댑터

• 핸들러 매핑과 핸들러 어댑터에대해서 알아보자.
  • 지금은 애너테이션으로 사용하지만, 그 전에 사용했던 스프링이 제공하는 간단한 컨트롤러 매핑과 어댑터를 알아보자.

✅Controller 인터페이스

• 과거 버전 스프링 컨트롤러
• org.springframework.web.servlet.mvc.Controller

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

• 현재 버전 스프링 컨트롤러
  • @controller를 사용한다.
  • 여기서 과거의 interface Controller와 @controller는 전혀 다른 것이다.

@Controller

• 간단하게 Controller interface 구현해보기
  • @component: 이 컨트롤러는 /springmvc/old-controller 라는 이름의 스프링 빈으로 등록되었다.
  • 빈의 이름으로 URL을 매핑

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

• OldController.handleRequest는 어떻게 호출될 수 있을까?
  • 컨트롤러가 호출될려면 2가지가 필요
    1. HandlerMapping(핸들러 매핑)
       • 핸들러 매핑에서 이 컨트롤러를 찾을 수 있어야 한다.
       • Ex) 스프링 빈의 이름으로 핸들러를 찾을 수 있는 핸들러 매핑이 필요하다.
    2. HandlerAdapter(핸들러 어뎁터)
       • 핸들러 매핑을 통해서 찾은 핸들러를 실행할 수 있는 핸들러 어뎁터가 필요하다.
       • Ex) Controller 인터페이스를 실행할 수 있는 핸들러 어뎁터를 찾고 실행해야 한다.
  • 참고 ! - 스프링은 이미 필요한 핸들러 매핑과 핸들러 어댑터를 대부분 구현해두었다. 개발자가 직접 핸들러 매핑과 핸들러 어댑 터를 만드는 일은 거의 없다.

• 스프링 부트가 자동 등록하는 핸들러 매핑과 핸들러 어댑터(실제로는 더 많지만, 중요한 부분 위주로 설명하기 위해 일부 생략)

  • HandlerMapping

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

  • HandlerAdapter

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

핸들러 매핑도, 핸들러 어댑터도 모두 순서대로 찾고 만약 없으면 다음 순서로 넘어간다.

1. 핸들러 매핑으로 핸들러 조회

1. HandlerMapping을 순서대로 실행해서, 핸들러를 찾는다.

2. 이 경우 빈 이름으로 핸들러를 찾아야 하기 때문에 이름 그대로 빈 이름으로 핸들러를 찾아주는BeanNameUrlHandlerMapping 가 실행에 성공하고 핸들러인 OldController 를 반환한다.

3. 핸들러 어뎁터 조회

   1. HandlerAdapter 의 supports() 를 순서대로 호출한다.
   2. SimpleControllerHandlerAdapter 가 Controller 인터페이스를 지원하므로 대상이 된다.

4. 핸들러 어댑터 실행

   1. 디스패처 서블릿이 조회한 SimpleControllerHandlerAdapter 를 실행하면서 핸들러 정보도 함께 넘겨준다.
   2. SimpleControllerHandlerAdapter 는 핸들러인 OldController 를 내부에서 실행하고, 그 결과를 반환한다.

✅정리 - OldController 핸들러매핑, 어댑터

• OldController 를 실행하면서 사용된 객체는 다음과 같다.
• HandlerMapping = BeanNameUrlHandlerMapping
• HandlerAdapter = SimpleControllerHandlerAdapter

➡️HttpRequestHandler

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

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

1. 핸들러 매핑으로 핸들러 조회

1. HandlerMapping 을 순서대로 실행해서, 핸들러를 찾는다.

2. 이 경우 빈 이름으로 핸들러를 찾아야 하기 때문에 이름 그대로 빈 이름으로 핸들러를 찾아주는BeanNameUrlHandlerMapping 가 실행에 성공하고 핸들러인 MyHttpRequestHandler 를 반환한다.

3. 핸들러 어댑터 조회

   1. HandlerAdapter 의 supports() 를 순서대로 호출한다.
   2. HttpRequestHandlerAdapter 가 HttpRequestHandler 인터페이스를 지원하므로 대상이 된다.

4. 핸들러 어댑터 실행

   1. 디스패처 서블릿이 조회한 HttpRequestHandlerAdapter 를 실행하면서 핸들러 정보도 함께 넘겨준다.
   2. HttpRequestHandlerAdapter 는 핸들러인 MyHttpRequestHandler 를 내부에서 실행하고, 그 결과를반환한다.

✅정리 - MyHttpRequestHandler 핸들러매핑, 어댑터

• MyHttpRequestHandler 를 실행하면서 사용된 객체는 다음과 같다.
• HandlerMapping = BeanNameUrlHandlerMapping
• HandlerAdapter = HttpRequestHandlerAdapter

@RequestMapping**
조금 뒤에서 설명하겠지만, 가장 우선순위가 높은 핸들러 매핑과 핸들러 어댑터는 RequestMappingHandlerMapping, RequestMappingHandlerAdapter 이다.
@RequestMapping 의 앞글자를 따서 만든 이름인데, 이것이 바로 지금 스프링에서 주로 사용하는 애노테이션 기반의
컨트롤러를 지원하는 매핑과 어댑터이다. 실무에서는 99.9% 이 방식의 컨트롤러를 사용한다.	

3️⃣뷰 리졸버

• OldController 에 new ModelAndView("new-form"); 추가 한다.
  • 추가하고 실행하면 Whitelabel Error Page 가 나온다.
  • 이유는 뷰 리졸버가 없어서이다.

@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"); // return null에서 변경 
     }
}

• application.properties

spring.mvc.view.prefix=/WEB-INF/views/
spring.mvc.view.suffix=.jsp

스프링 부트의 경우 InternalResourceViewResolver라는 뷰 리졸버를 자동으로 등록하는데, 이때 위에 application.properties안에 등록한 코드 정보를 사용해서 등록한다.

✅ 스프링 부트가 자동 등록하는 뷰 리졸버

핵심적인 부분만 원래는 더 많다.

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

1. 핸들러 어댑터 호출

핸들러 어댑터를 통해 new-form 이라는 논리 뷰 이름을 획득한다.

1. ViewResolver 호출

new-form 이라는 뷰 이름으로 viewResolver를 순서대로 호출한다.
BeanNameViewResolver 는 new-form 이라는 이름의 스프링 빈으로 등록된 뷰를 찾아야 하는데 없다.
InternalResourceViewResolver 가 호출된다.

1. InternalResourceViewResolver

이 뷰 리졸버는 InternalResourceView를 반환한다.

1. 뷰 - InternalResourceView

InternalResourceView 는 JSP처럼 포워드 forward() 를 호출해서 처리할 수 있는 경우에 사용한다.

1. view.render()

view.render() 가 호출되고 InternalResourceView 는 forward() 를 사용해서 JSP를 실행한다.

4️⃣스프링 MVC - 시작하기

• SpringMemberFormControllerV1 - 회원 등록폼

@Controller
public class SpringMemberFormControllerV1 {

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

➡️코드 설명

• @controller
  • 스프링이 자동으로 스프링 빈으로 등록
  • 스프링MVC에서 애노테이션 기반 컨트롤러로 인식 → RequestMappingHandlerMapping에서 대상이라고 인식해줌
• @RequestMapping
  • 요청 정보를 매핑한다. 해당 URL이 호출되면 이 메서드가 호출된다.
• ModelAndView
  • 모델과 뷰 정보를 담아서 반환하면 된다.

따라서 위의 코드와 아래의 코드는 같은 거라고 생각하면된다.

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

RequestMappingHandlerMapping가 인식할 수 있는 핸들러인지 찾는 기준
1. 스프링 빈에 등록된 것 중에서 
2. @RequestMapping 또는 @Controller가 클래스 레벨에 붙어 있는 경우에 매핑 정보로 인식

• RequestMappingHandlerMapping 내부 구조

 protected boolean isHandler(Class<?> beanType) {
      return AnnotatedElementUtils.hasAnnotation(beanType, Controller.class);
}

5️⃣스프링 MVC - 컨트롤러 통합

@RequestMapping의 쓰이는 위치는

1. 클래스 단위
2. 메서드 단위

• 결론 → 컨트롤러 클래스를 유연하게 하나로 통합이 가능

• SpringMemberControllerV2

package hello.servlet.web.springmvc.v2;

import hello.servlet.domain.member.Member;
import hello.servlet.domain.member.MemberRepository;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import java.util.List;

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

    private MemberRepository memberRepository = MemberRepository.getInstance();

    @RequestMapping("/new-form")
    public ModelAndView newForm() {
        return new ModelAndView("members/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 mav = new ModelAndView("save-result");
        mav.addObject("member", member);
        return mav;
    }

    @RequestMapping
    public ModelAndView members() {
        List<Member> members = memberRepository.findAll();

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

• 위의 코드를 보면 /springmvc/v2/members라는 부분이 중복이 있다.
  • @RequestMapping("/springmvc/v2/members/new-form")
  • @RequestMapping("/springmvc/v2/members")
  • @RequestMapping("/springmvc/v2/members/save")

✅조합 결과

• 클래스 레벨 @RequestMapping("/springmvc/v2/members")
  • 메서드 레벨 @RequestMapping("/new-form") →/springmvc/v2/members/new-form
  • 메서드 레벨 @RequestMapping("/save") → /springmvc/v2/members/save
  • 메서드 레벨 @RequestMapping → /springmvc/v2/members

6️⃣스프링 MVC - 실용적인 방식

이 전에 MVC를 손수 제작했을 때 V3는 ModelView를 직접 생성해서 반환했다 그것은 불편한 점이 많다.

그럼 스프링 MVC를 사용해서 V3를 제작하면 어떤 모습일지 확인해보자.

지금 이 방식은 실무에서 많이 쓰는 방식이다.

• SpringMemberControllerV3
  • model 파라미터 - save(), members()를 보면 model을 파라미터로 받음
  • ViewName 직접 반환 →뷰의 논리 이름으로 반환
  • @RequesstParam 사용 → 스프링 HTTP 요청 파라미터를 @RequestParam으로 받을 수 있음
  • @RequestMapping → @GetMapping, @PostMapping
    • @RequestMapping(value = "/new-form", method = RequestMethod.GET)도 가능

/**
* v3
* Model 도입
* ViewName 직접 반환
* @RequestParam 사용
* @RequestMapping -> @GetMapping, @PostMapping 
*/
 @Controller
 @RequestMapping("/springmvc/v3/members")
 public class SpringMemberControllerV3 {
     private MemberRepository memberRepository = MemberRepository.getInstance();
     
     @GetMapping("/new-form")
     public String newForm() {
         return "new-form";
     }
     
     @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";
     }
     
     @GetMapping
     public String members(Model model) {
         List<Member> members = memberRepository.findAll();
         model.addAttribute("members", members);
         return "members";
		 } 
}

[6om1n]

수고하셨습니당 ~~

[YuDeokRin]

감사합니당 반장님도 수고했습니다.