一、SpringMVC的核心组件

1、前端控制器（DispatcherServlet）

在传统 web.xml 配置中添加以下的配置：

<web-app>
    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-mvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

在SpringBoot项目中又SpringBoot项目自动配置，配置如下：

// Spring Boot 自动注册 DispatcherServlet
@AutoConfiguration
@ConditionalOnClass(DispatcherServlet.class)
public class DispatcherServletAutoConfiguration {
    
    @Bean(name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
    public DispatcherServlet dispatcherServlet() {
        return new DispatcherServlet();
    }
}

DispatcherServlet 是 Spring MVC 的中央调度器，负责协调所有组件的工作。

// DispatcherServlet 的核心工作流程
public class DispatcherServlet extends FrameworkServlet {
    
    protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        // 1. 获取处理器执行链
        HandlerExecutionChain mappedHandler = getHandler(processedRequest);
        
        // 2. 获取处理器适配器
        HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
        
        // 3. 执行前置拦截器
        if (!mappedHandler.applyPreHandle(processedRequest, response)) {
            return;
        }
        
        // 4. 实际调用处理器方法
        ModelAndView mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
        
        // 5. 应用默认视图名
        applyDefaultViewName(processedRequest, mv);
        
        // 6. 执行后置拦截器
        mappedHandler.applyPostHandle(processedRequest, response, mv);
        
        // 7. 处理渲染结果
        processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
    }
}

2、 处理器映射器（HandlerMapping）

根据请求的 URL 找到对应的处理器（Controller 方法）

职责：路由查找
根据请求的 URL 找到对应的处理器
建立请求路径与处理器的映射关系
不执行具体业务逻辑

在SSM项目中使用以下的配置进行启动处理映射器：

<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
<mvc:annotation-driven/>

其中 <mvc:annotation-driven/>相当于把所有的都注入到其中。

3、处理器（ Handler）

职责：业务处理

执行具体的业务逻辑
处理请求参数
返回处理结果
包含实际的业务代码

@Controller
@RequestMapping("/user")
public class UserController {  // ← 这是一个处理器
    
    @Autowired
    private UserService userService;  // 业务依赖
    
    // 具体的处理方法
    @GetMapping("/{id}")
    public String getUser(@PathVariable Long id, Model model) {
        // 【处理器】的核心工作：执行业务逻辑
        User user = userService.findById(id);  // 调用业务层
        model.addAttribute("user", user);      // 准备模型数据
        return "user/detail";                  // 返回视图名称
    }
    
    @PostMapping("/create")
    @ResponseBody
    public ResponseEntity<?> createUser(@Valid @RequestBody User user) {
        // 业务逻辑处理
        if (userService.existsByEmail(user.getEmail())) {
            return ResponseEntity.badRequest().body("邮箱已存在");
        }
        
        User savedUser = userService.save(user);
        return ResponseEntity.ok(savedUser);
    }
}

@PostMapping("/create")是处理器映射器的使用范围，下面的方法体是处理器适配器的使用范围。

4、处理器适配器（HandlerAdapter）

适配不同类型的处理器，提供统一的调用接口。是定义的每一个被@controller注解的类。

5、视图解析器（ViewResolver）

将逻辑视图名解析为具体的 View 对象。

    @GetMapping("/{id}")
    public String getUser(@PathVariable Long id, Model model) {
        // 【处理器】的核心工作：执行业务逻辑
        User user = userService.findById(id);  // 调用业务层
        model.addAttribute("user", user);      // 准备模型数据
        return "user/detail";                  // 返回视图名称
    }

根据这个返回视图，把"user/detail"变成具体文件路径。

6、视图（ViewResolver）

负责渲染模型数据，生成最终的响应内容。

1. JSP 视图 (JstlView)

public class JstlView extends InternalResourceView {
    
    @Override
    protected void renderMergedOutputModel(Map<String, Object> model,
                                         HttpServletRequest request,
                                         HttpServletResponse response) throws Exception {
        
        // 1. 将模型数据暴露为请求属性
        exposeModelAsRequestAttributes(model, request);
        
        // 2. 设置请求分发器
        RequestDispatcher rd = request.getRequestDispatcher(getUrl());
        
        // 3. 转发到 JSP 页面
        rd.forward(request, response);
    }
}

将路径下的文件渲染出来返回给用户，包括JSON数据、JSP视图、HTML页面等。

二、SpringMVC的各个组件间区分

1、处理器、处理器适配器、处理映射器区分

🗺️ 处理器映射器 (HandlerMapping)

// 职责：根据URL找到对应的处理器方法
@Controller
public class UserController {
    
    @GetMapping("/user/list")    // ← 映射器找到这个具体方法
    public String listUsers() {   // ← 不是找到整个Controller文件
        return "user/list";
    }
}

🔄 处理器适配器 (HandlerAdapter)

// 职责：调用找到的处理器方法
public class RequestMappingHandlerAdapter {
    
    public ModelAndView handle(HttpServletRequest request, 
                             Object handler) {  // ← handler是具体的方法对象
        // 调用：userController.listUsers()
        // 不是调用整个UserController文件
    }
}

👨‍💻 处理器 (Handler)

@Controller
public class UserController {
    
    // 处理器1：这个具体的方法就是处理器
    @GetMapping("/user/list")
    public String listUsers() {   // ← 这是一个处理器
        return "user/list";
    }
    
    // 处理器2：另一个方法也是独立的处理器  
    @GetMapping("/user/detail")
    public String userDetail() {  // ← 这是另一个处理器
        return "user/detail";
    }
}

处理映射器是根据用户提供的路径找到对应的Controller文件。
处理器适配器是用户找到的Controller文件。
处理器是Controller文件中每一个对应的方法体。

2、视图解析器和视图的区别

🗺️ 视图解析器 (ViewResolver)
职责：名称解析 → 视图对象

public interface ViewResolver {
    // 输入：逻辑视图名  输出：具体的View对象
    View resolveViewName(String viewName, Locale locale) throws Exception;
}

🎨 视图 (View)
职责：数据渲染 → 最终输出

public interface View {
    // 输入：模型数据  输出：渲染后的内容
    void render(Map<String, ?> model, 
                HttpServletRequest request, 
                HttpServletResponse response) throws Exception;
}