第一期：Spring Web MVC 入门 [特殊字符]（基础概念 + 环境搭建）

前言

在现代Web开发中，Spring Web MVC 已成为Java开发者构建Web应用的首选框架之一。它基于 Model-View-Controller（MVC） 设计模式，提供了清晰的架构和强大的功能，帮助开发者更高效地管理HTTP请求、数据绑定、视图解析等Web开发中的核心问题。

本系列博客面向 Spring MVC 初学者，从 基本概念 到 高级应用，循序渐进地讲解Spring MVC的核心知识。无论你是 刚入门Spring，还是 希望深入理解Spring MVC的底层原理，本系列都能帮助你快速掌握Spring MVC的使用方法，并能在实际项目中灵活运用。

在学习过程中，你将了解：
✅ Spring MVC的工作原理 —— 如何处理请求并返回数据？
✅ 核心组件 —— DispatcherServlet、Controller、ViewResolver 等如何协作？
✅ 常见开发技巧 —— RESTful API、数据校验、拦截器、异常处理等
✅ 实战项目 —— 结合Spring Boot，构建一个完整的Web应用

如果你希望从 零基础掌握Spring MVC，那么这个系列博客将是你的最佳学习指南！💡 让我们开启Spring MVC的学习之旅吧！🚀

1 Spring Web MVC 概述

Spring Web MVC 是 Spring 框架中的一个子模块，它基于 Model-View-Controller（MVC） 设计模式，专门用于构建 Web 应用程序。

---

📌 什么是 Spring Web MVC？

Spring Web MVC 是 Spring 框架中的 Web 层解决方案，它提供了一种结构化的方式来处理 HTTP 请求，并将请求映射到合适的处理器方法。

它的核心思想是 MVC 设计模式，将应用程序的不同部分进行分离：

• Model（模型）： 是应⽤程序的主体部分，⽤来处理程序中数据逻辑的部分.（处理数据和业务逻辑）

• View（视图）： 指在应⽤程序中专⻔⽤来与浏览器进⾏交互，展⽰数据的资源.（负责页面展示）

• Controller（控制器）： 可以理解为⼀个分发器，⽤来决定对于视图发来的请求，需要⽤哪⼀个模型 来处理，以及处理完后需要跳回到哪⼀个视图。即⽤来连接视图和模型（负责接收请求，调用业务逻辑，并返回视图）

官⽅对于SpringMVC的描述是这样的：

Spring WebMVCistheoriginalwebframeworkbuiltontheServletAPIandhasbeenincluded in the Spring Frameworkfromtheverybeginning.Theformalname,"SpringWebMVC",comes from thenameofitssourcemodule(spring-webmvc)

引⽤来⾃：Spring Web MVC :: Spring Framework

翻译为中⽂：

Spring Web MVC是基于Servlet API构建的原始Web框架，从⼀开始就包含在Spring框架中。它的 正式名称“SpringWeb MVC”来⾃其源模块的名称(Spring-webmvc)，但它通常被称为"Spring MVC".

那么什么是Servlet呢? 

Servlet 是⼀种实现动态⻚⾯的技术.准确来讲Servlet是⼀套JavaWeb开发的规范，或者说是⼀套 Java Web开发的技术标准.只有规范并不能做任何事情，必须要有⼈去实现它.所谓实现Servlet规 范，就是真正编写代码去实现Servlet规范提到的各种功能，包括类、⽅法、属性等. Servlet 规范是开放的，除了Sun公司，其它公司也可以实现Servlet规范，⽬前常⻅的实现了 Servlet 规范的产品包括Tomcat、Weblogic、Jetty、Jboss、WebSphere等，它们都被称 为"Servlet 容器".Servlet 容器⽤来管理程序员编写的Servlet类

✅ Spring Web MVC 的特点

✔ 基于 Servlet，但提供更清晰的 MVC 架构
✔ 请求驱动，通过 DispatcherServlet 进行分发
✔ 灵活的视图解析（支持 JSP、Thymeleaf、Freemarker 等）
✔ 强大的数据绑定和校验
✔ 支持拦截器、异常处理、文件上传等高级功能

---

📌 Spring MVC 与 Servlet、Spring Boot 的关系

技术	作用
Servlet	Java Web 的基础组件，处理 HTTP 请求和响应
Spring MVC	基于 Servlet 的 Web 框架，提供 MVC 结构
Spring Boot	Spring 框架的简化版本，自动配置 Spring MVC

✅ Spring MVC vs Servlet

• Servlet 需要手动解析请求参数、封装数据、选择视图，而 Spring MVC 通过 @RequestMapping 直接映射请求，简化开发。

• Spring MVC 通过 DispatcherServlet 处理所有请求，而 Servlet 需要开发者自己编写大量逻辑代码。

✅ Spring MVC vs Spring Boot

• Spring Boot 内置 Spring MVC，并且提供了自动配置，减少了繁琐的 XML 配置。

• Spring Boot 更适合快速开发 REST API，而 Spring MVC 更适合传统 Web 应用。

---

📌 Spring MVC 的核心组成部分

✅1. DispatcherServlet（请求分发器）

Spring MVC 的 核心控制器，所有请求都会先经过 DispatcherServlet，它负责将请求分发给合适的组件进行处理。

✅2. HandlerMapping（处理器映射）

负责将 URL 请求 映射到对应的 Controller 方法。
🔹 例如：

@RequestMapping("/hello")
public String hello() { return "Hello, Spring MVC!"; }

✅3. Controller（控制器）

负责处理请求、调用业务逻辑，并返回数据或视图。
🔹 例如：

@Controller
public class MyController {
    @RequestMapping("/hello")
    public String hello() {
        return "hello"; // 返回视图名称
    }
}

✅4. ViewResolver（视图解析器）

负责解析视图名称并渲染页面，支持 JSP、Thymeleaf、Freemarker 等。

✅5. ModelAndView（模型和视图）

用于封装数据（Model）和页面（View），最终返回给用户。

---

📌 经典 Spring MVC 处理流程

1️⃣ 用户发送 HTTP 请求（例如：/hello）
2️⃣ DispatcherServlet 拦截请求，查找对应的 Controller
3️⃣ 调用 Controller 方法，执行业务逻辑
4️⃣ 返回 ModelAndView（数据 + 视图）
5️⃣ ViewResolver 解析视图，渲染页面
6️⃣ 返回 HTML 页面给用户

---

总结

• Spring MVC 是 Spring 框架的 Web 层解决方案，基于 MVC 设计模式。

• 它通过 DispatcherServlet 统一管理请求，简化 Web 开发。

• Spring MVC 依赖 Servlet，但比直接使用 Servlet 更加灵活和高效。

• Spring Boot 集成了 Spring MVC，简化了配置，更适合快速开发。

---

2 搭建 Spring MVC 开发环境

在开始使用 Spring MVC 进行开发之前，我们需要搭建一个基本的 Spring MVC 项目，并进行必要的配置。本章节将介绍如何使用 Maven/Gradle 管理依赖，了解 Spring MVC 基本项目结构，并使用 XML/JavaConfig 进行配置，最后编写一个 简单的控制器 处理 HTTP 请求。

---

2.1  使用 Maven/Gradle 管理 Spring MVC 项目

🔹 创建 Spring MVC 项目（Maven）

如果使用 Maven，可以手动创建 pom.xml 并添加 Spring MVC 相关依赖：

<dependencies>
    <!-- Spring Web MVC -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.30</version>  <!-- 具体版本可以根据需求调整 -->
    </dependency>

    <!-- Servlet API（仅编译时依赖，运行时由服务器提供） -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <scope>provided</scope>
    </dependency>

    <!-- JSP 解析（如果使用 JSP 作为视图层） -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>

    <!-- 依赖 Spring Boot 时，可以使用 spring-boot-starter-web -->
</dependencies>

🔹 创建 Spring MVC 项目（Gradle）

如果使用 Gradle，则在 build.gradle 中添加以下依赖：

dependencies {
    implementation 'org.springframework:spring-webmvc:5.3.30'
    providedCompile 'javax.servlet:javax.servlet-api:4.0.1'
    implementation 'javax.servlet:jstl:1.2'
}

---

2. Spring MVC 的基本项目结构

典型的 Spring MVC 项目结构 如下：

SpringMVCProject/
│── src/main/java/com/example/controller/   # Controller 层（控制器）
│── src/main/java/com/example/service/      # Service 层（业务逻辑）
│── src/main/java/com/example/repository/   # 数据访问层（DAO）
│── src/main/java/com/example/config/       # 配置类（JavaConfig）
│── src/main/webapp/WEB-INF/views/          # 视图层（JSP / Thymeleaf）
│── src/main/webapp/WEB-INF/web.xml         # Web.xml（Servlet 配置）
│── pom.xml / build.gradle                   # 依赖管理文件

其中：

• Controller 层 负责处理 HTTP 请求

• Service 层 处理业务逻辑

• Repository 层（DAO） 负责数据访问

• Config 目录 存放 Spring MVC 的配置类（如果使用 Java 配置）

• WEB-INF/views/ 目录存放 JSP 页面（如果使用 JSP 作为视图层）

• web.xml 或 JavaConfig 负责配置 DispatcherServlet

---

3. 配置 Spring MVC（XML 配置 vs JavaConfig）

🔹 方法 1：使用 XML 配置（web.xml + spring-mvc.xml）

(1) 配置 web.xml

web.xml 主要用于 注册 DispatcherServlet，它是 Spring MVC 处理请求的核心：

<web-app xmlns="http://java.sun.com/xml/ns/javaee"
         version="3.1">
    <servlet>
        <servlet-name>springDispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/spring-mvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>springDispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

(2) 配置 spring-mvc.xml

spring-mvc.xml 主要用于 开启 Spring MVC 功能，并配置视图解析器：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/mvc
           http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 启用 Spring MVC 注解 -->
    <mvc:annotation-driven />

    <!-- 配置视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/" />
        <property name="suffix" value=".jsp" />
    </bean>

</beans>

---

🔹 方法 2：使用 JavaConfig 配置（无 XML）

(1) 配置 AppConfig.java

使用 @Configuration 代替 XML 配置：

@Configuration
@EnableWebMvc
@ComponentScan(basePackages = "com.example")
public class AppConfig {
    
    @Bean
    public InternalResourceViewResolver viewResolver() {
        InternalResourceViewResolver resolver = new InternalResourceViewResolver();
        resolver.setPrefix("/WEB-INF/views/");
        resolver.setSuffix(".jsp");
        return resolver;
    }
}

(2) 配置 WebInitializer.java（替代 web.xml）

使用 WebApplicationInitializer 进行初始化：

public class WebInitializer implements WebApplicationInitializer {
    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
        context.register(AppConfig.class);
        
        DispatcherServlet dispatcherServlet = new DispatcherServlet(context);
        ServletRegistration.Dynamic registration = servletContext.addServlet("dispatcher", dispatcherServlet);
        registration.setLoadOnStartup(1);
        registration.addMapping("/");
    }
}

---

4. 编写一个简单的 Spring MVC 控制器

在 com.example.controller 包下创建 HelloController.java：

@Controller
public class HelloController {

    @RequestMapping("/hello")
    public String sayHello(Model model) {
        model.addAttribute("message", "Hello, Spring MVC!");
        return "hello"; // 视图名称，对应 /WEB-INF/views/hello.jsp
    }
}

对应的 JSP 视图 hello.jsp（存放于 WEB-INF/views/ 目录）：

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<html>
<head>
    <title>Hello Spring MVC</title>
</head>
<body>
    <h2>${message}</h2>
</body>
</html>

---

总结

✅ 使用 Maven/Gradle 管理 Spring MVC 依赖
✅ Spring MVC 项目结构：Controller、Service、Repository、Config
✅ 配置 Spring MVC（XML 配置 vs JavaConfig）
✅ 编写一个简单的 Spring MVC 控制器，返回一个 JSP 视图

---

3. DispatcherServlet：MVC的核心

在 Spring MVC 中，DispatcherServlet 是整个框架的 核心，负责拦截所有 HTTP 请求，并将它们分发给适当的处理器（Controller）。它本质上是一个 前端控制器（Front Controller），类似于 Java EE 中的 Servlet，但提供了更高级的请求处理机制。

---

📌 DispatcherServlet 的作用

Spring MVC 采用 前端控制器模式（Front Controller Pattern），DispatcherServlet 充当 中央请求分发器，其主要作用如下：

✅ 拦截所有请求，统一入口处理
✅ 查找合适的控制器（Controller） 处理请求
✅ 调用业务逻辑（Service 层）
✅ 解析视图（ViewResolver） 并返回响应
✅ 支持拦截器（Interceptor）、异常处理（ExceptionHandler）等高级功能

---

📌 DispatcherServlet 的生命周期

DispatcherServlet 继承自 HttpServlet，因此其生命周期与普通 Servlet 类似，主要分为 初始化（init）、处理请求（service）和 销毁（destroy）。

🔹 DispatcherServlet 生命周期：

1️⃣ 服务器启动，加载 DispatcherServlet（调用 init() 方法）
2️⃣ 读取 Spring MVC 配置文件或 Java 配置（初始化 WebApplicationContext）
3️⃣ 请求到达，DispatcherServlet 处理请求（调用 service() 方法）
4️⃣ 解析请求，调用 Controller 处理请求，返回视图
5️⃣ 应用关闭，DispatcherServlet 被销毁（调用 destroy() 方法）

---

📌 DispatcherServlet 的初始化过程

1️⃣ DispatcherServlet 的注册方式

在 Spring MVC 中，我们通常使用两种方式注册 DispatcherServlet：

🔹 方法 1：在 web.xml 配置（基于 XML）

<servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/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>

load-on-startup=1 表示 服务器启动时就初始化 DispatcherServlet，而不是等到请求时才初始化。

---

🔹 方法 2：使用 WebApplicationInitializer 配置（基于 Java）

public class WebAppInitializer implements WebApplicationInitializer {
    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
        context.register(AppConfig.class);

        DispatcherServlet dispatcherServlet = new DispatcherServlet(context);
        ServletRegistration.Dynamic registration = servletContext.addServlet("dispatcher", dispatcherServlet);
        registration.setLoadOnStartup(1);
        registration.addMapping("/");
    }
}

这种方式无需 web.xml，符合 Spring Boot 规范，推荐使用。

---

2️⃣ DispatcherServlet 的初始化流程

当 DispatcherServlet 被初始化时，会执行以下 初始化流程：

1️⃣ 创建 WebApplicationContext（Spring 容器）

• 如果 contextConfigLocation 参数指定了 Spring 配置文件，则加载该文件

• 如果没有指定，则默认加载 /WEB-INF/[servlet-name]-servlet.xml

2️⃣ 注册 Spring MVC 组件（HandlerMapping、HandlerAdapter 等）

• HandlerMapping：查找合适的 Controller 处理请求

• HandlerAdapter：调用 Controller 方法

• ViewResolver：解析返回的视图

3️⃣ 初始化拦截器、异常处理器等组件

• Interceptor（拦截器）：在请求处理前/后执行特定逻辑

• ExceptionResolver（异常处理器）：全局异常管理

4️⃣ 完成初始化，等待处理 HTTP 请求

---

📌 DispatcherServlet 处理请求的流程

当用户请求到达 DispatcherServlet 时，它会按照 Spring MVC 处理流程 依次执行：

1️⃣ 拦截请求（DispatcherServlet）

• 解析 URL，判断是否匹配 Controller

2️⃣ 查找合适的 Controller（HandlerMapping）

• 通过 @RequestMapping 解析请求路径

3️⃣ 调用 Controller 方法（HandlerAdapter）

• 将请求参数转换为 Controller 方法的参数

4️⃣ 处理业务逻辑（Service 层）

• 调用 Service 层处理数据（如数据库操作）

5️⃣ 返回数据或视图（ViewResolver）

• 如果返回的是 视图名称，则交给 ViewResolver 解析

• 如果返回的是 JSON 数据，则通过 @ResponseBody 直接返回

6️⃣ 渲染视图，返回响应

---

📌 DispatcherServlet 处理请求示例

假设用户访问 http://localhost:8080/hello，处理流程如下：

(1) 定义 Controller

@Controller
public class HelloController {
    @RequestMapping("/hello")
    public String hello(Model model) {
        model.addAttribute("message", "Hello, Spring MVC!");
        return "hello"; // 返回视图名 "hello.jsp"
    }
}

(2) 视图解析（ViewResolver）

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/views/" />
    <property name="suffix" value=".jsp" />
</bean>

(3) hello.jsp

<h2>${message}</h2>

(4) 请求处理流程

1️⃣ 用户访问 /hello
2️⃣ DispatcherServlet 拦截请求，并查找 HandlerMapping
3️⃣ HandlerAdapter 调用 HelloController.hello() 方法
4️⃣ 方法返回 "hello"，ViewResolver 解析视图 /WEB-INF/views/hello.jsp
5️⃣ 渲染 hello.jsp，最终页面显示 "Hello, Spring MVC!"

---

📌 总结

✅ DispatcherServlet 是 Spring MVC 的核心，负责拦截请求并分发到 Controller
✅ DispatcherServlet 继承自 HttpServlet，其 生命周期 包括 初始化（init）、处理请求（service）和销毁（destroy）
✅ DispatcherServlet 在 初始化时会加载 Spring MVC 组件（HandlerMapping、HandlerAdapter、ViewResolver）
✅ DispatcherServlet 处理请求时，会 查找 Controller → 调用业务逻辑 → 解析视图 → 返回响应
✅ 可以使用 web.xml 或 WebApplicationInitializer 注册 DispatcherServlet，推荐 使用 JavaConfig

---

4. Spring MVC 的基本流程

Spring MVC 采用 前端控制器模式（Front Controller Pattern），DispatcherServlet 作为核心组件，负责 拦截请求 并 协调多个 Spring MVC 组件 共同完成请求处理和响应生成。

本节将详细讲解 Spring MVC 的基本流程，并剖析其中 HandlerMapping、HandlerAdapter、ViewResolver 等核心组件的作用。

---

📌 Spring MVC 请求处理流程（核心组件解析）

当一个请求到达 Spring MVC 时，它会经过 多个组件 的协同处理，整体流程如下：

🔷 步骤 1：客户端发送 HTTP 请求
🔷 步骤 2：DispatcherServlet 拦截请求（前端控制器）
🔷 步骤 3：HandlerMapping 查找合适的 Controller
🔷 步骤 4：HandlerAdapter 适配并执行 Controller 方法
🔷 步骤 5：Controller 处理业务逻辑，返回 ModelAndView
🔷 步骤 6：ViewResolver 解析视图
🔷 步骤 7：渲染视图，返回响应

---

📌 详细解析 Spring MVC 处理流程

下图展示了 Spring MVC 处理请求的完整流程：

    客户端请求（HTTP Request）
            │
            ▼
    DispatcherServlet（前端控制器）
            │
            ▼
    HandlerMapping（查找控制器）
            │
            ▼
    HandlerAdapter（调用 Controller 方法）
            │
            ▼
    Controller（处理业务逻辑）
            │
            ▼
    返回 ModelAndView（数据 + 视图名）
            │
            ▼
    ViewResolver（解析视图）
            │
            ▼
    视图（JSP、Thymeleaf、JSON等）
            │
            ▼
    返回 HTTP 响应（Response）

---

📌 1. DispatcherServlet（前端控制器）

🔹 作用：

• 作为 Spring MVC 的核心组件，拦截所有 HTTP 请求

• 将请求分发给 合适的处理器（Controller）

• 负责 调用视图解析器 渲染最终的视图

🔹 示例：注册 DispatcherServlet（基于 Java 配置）：

public class WebAppInitializer implements WebApplicationInitializer {
    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
        context.register(AppConfig.class);

        DispatcherServlet dispatcherServlet = new DispatcherServlet(context);
        ServletRegistration.Dynamic registration = servletContext.addServlet("dispatcher", dispatcherServlet);
        registration.setLoadOnStartup(1);
        registration.addMapping("/");
    }
}

---

📌 2. HandlerMapping（查找 Controller）

🔹 作用：

• DispatcherServlet 通过 HandlerMapping 找到 哪个 Controller 方法 负责处理当前请求

• Spring MVC 提供了多种 HandlerMapping 实现，常见的是：

  • RequestMappingHandlerMapping（基于 @RequestMapping 注解）

  • SimpleUrlHandlerMapping（基于 properties 配置）

🔹 示例：使用 @RequestMapping 定义 Controller 方法

@Controller
public class HelloController {
    @RequestMapping("/hello")
    public String sayHello(Model model) {
        model.addAttribute("message", "Hello, Spring MVC!");
        return "hello"; // 视图名，对应 /WEB-INF/views/hello.jsp
    }
}

🔹 执行流程： 1️⃣ DispatcherServlet 拦截请求 /hello
2️⃣ HandlerMapping 查找 匹配的 Controller 方法（HelloController.sayHello()）

---

📌 3. HandlerAdapter（调用 Controller 方法）

🔹 作用：

• HandlerMapping 只负责找到 Controller，但不同类型的 Controller 可能有不同的调用方式

• HandlerAdapter 负责 调用 Controller 方法，并返回 ModelAndView

• Spring 提供了不同类型的 HandlerAdapter：

  • RequestMappingHandlerAdapter（处理 @RequestMapping 方法）

  • SimpleControllerHandlerAdapter（处理 Controller 接口）

🔹 示例：返回 ModelAndView

@Controller
public class HelloController {
    @RequestMapping("/hello")
    public ModelAndView hello() {
        ModelAndView mav = new ModelAndView();
        mav.setViewName("hello"); // 视图名
        mav.addObject("message", "Hello, Spring MVC!");
        return mav;
    }
}

🔹 执行流程： 1️⃣ HandlerAdapter 调用 hello() 方法
2️⃣ 方法返回 ModelAndView("hello", message="Hello, Spring MVC!")

---

📌 4. Controller（处理业务逻辑）

🔹 作用：

• 处理 具体的业务逻辑，通常会调用 Service 层

• 处理完后，返回数据（Model）或视图（View）

🔹 示例：Controller 调用 Service 层

@Controller
public class UserController {
    @Autowired
    private UserService userService;

    @RequestMapping("/user/{id}")
    public String getUser(@PathVariable int id, Model model) {
        User user = userService.getUserById(id);
        model.addAttribute("user", user);
        return "user"; // 视图名
    }
}

🔹 执行流程： 1️⃣ Controller 通过 @Autowired 注入 UserService
2️⃣ getUser() 方法调用 userService.getUserById(id)
3️⃣ 将 user 对象存入 Model 并返回视图 "user"

---

📌 5. ViewResolver（解析视图）

🔹 作用：

• ViewResolver 负责 将视图名解析为具体的视图文件

• Spring 提供了不同的 视图解析器：

  • InternalResourceViewResolver（解析 JSP 视图）

  • ThymeleafViewResolver（解析 Thymeleaf 视图）

  • MappingJackson2JsonView（返回 JSON 数据）

🔹 示例：配置 InternalResourceViewResolver

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/views/" />
    <property name="suffix" value=".jsp" />
</bean>

🔹 执行流程： 1️⃣ ViewResolver 解析 "hello" → /WEB-INF/views/hello.jsp
2️⃣ DispatcherServlet 渲染视图，并返回响应给客户端

---

📌 6. 渲染视图，返回响应

🔹 如果是 JSP 页面：

• DispatcherServlet 解析 hello.jsp

• JSP 渲染 Model 数据，并返回 HTML

🔹 如果是 JSON 数据：

@RestController
public class UserController {
    @RequestMapping("/user/{id}")
    public User getUser(@PathVariable int id) {
        return new User(id, "张三");
    }
}

• 返回 JSON 响应：{"id":1,"name":"张三"}

---

📌 总结

✅ DispatcherServlet：前端控制器，负责拦截请求并分发
✅ HandlerMapping：查找匹配的 Controller 方法
✅ HandlerAdapter：适配并调用 Controller 方法
✅ Controller：执行业务逻辑，返回 ModelAndView 或 JSON
✅ ViewResolver：解析视图名，渲染最终视图

---

5. 编写第一个 Spring MVC 应用

在本节中，我们将 从零开始 编写一个简单的 Spring MVC 应用，学习 如何创建控制器、处理 GET/POST 请求，并配置 ViewResolver 解析视图。

---

📌 1. Spring MVC 应用结构

Spring MVC 项目的基本目录结构如下：

spring-mvc-demo/
├── src/main/java/com/example/controller/HelloController.java  # 控制器
├── src/main/webapp/WEB-INF/views/hello.jsp  # 视图
├── src/main/webapp/WEB-INF/web.xml  # 配置 DispatcherServlet
├── src/main/webapp/WEB-INF/spring-mvc.xml  # Spring MVC 配置文件
├── pom.xml  # Maven 依赖管理

---

📌 2. 创建 Spring MVC 项目

🔹 2.1 添加 Maven 依赖

如果你使用 Maven 作为构建工具，在 pom.xml 中添加以下依赖：

<dependencies>
    <!-- Spring MVC -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.30</version>
    </dependency>

    <!-- 视图解析需要 JSTL 支持 -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>

    <!-- Servlet API -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>4.0.1</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

---

🔹 2.2 配置 DispatcherServlet

在 web.xml 中注册 Spring MVC 的前端控制器（DispatcherServlet）：

<web-app xmlns="http://java.sun.com/xml/ns/javaee"
         version="3.0">

    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/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>

load-on-startup=1：服务器启动时加载 DispatcherServlet。

---

📌 3. 配置 Spring MVC

在 WEB-INF/spring-mvc.xml 中配置 Spring MVC：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 开启 Spring MVC 注解支持 -->
    <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"/>

    <!-- 配置视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

InternalResourceViewResolver 用于解析 hello 视图为 /WEB-INF/views/hello.jsp。

---

📌 4. 创建控制器（Controller）

🔹 4.1 处理 GET 请求

创建 HelloController.java，使用 @Controller 处理 HTTP 请求：

package com.example.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/hello")
public class HelloController {

    @GetMapping
    public String sayHello(Model model) {
        model.addAttribute("message", "Hello, Spring MVC!");
        return "hello";  // 返回视图名
    }
}

访问 http://localhost:8080/hello 时，控制器返回 "hello" 视图，并传递 message 数据。

---

🔹 4.2 处理 POST 请求

创建一个简单的表单处理：

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
@RequestMapping("/greet")
public class GreetController {

    @GetMapping
    public String showForm() {
        return "greet-form";  // 显示表单
    }

    @PostMapping
    public String processForm(@RequestParam("name") String name, Model model) {
        model.addAttribute("message", "Hello, " + name + "!");
        return "greet-result";
    }
}

@PostMapping 处理表单提交，@RequestParam 读取表单数据。

---

📌 5. 创建 JSP 视图

🔹 5.1 创建 hello.jsp

在 WEB-INF/views/hello.jsp：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head><title>Hello Page</title></head>
<body>
    <h2>${message}</h2>
</body>
</html>

---

🔹 5.2 创建表单页面 greet-form.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head><title>Greeting Form</title></head>
<body>
    <form action="greet" method="post">
        Name: <input type="text" name="name"/>
        <input type="submit" value="Submit"/>
    </form>
</body>
</html>

---

🔹 5.3 创建 greet-result.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head><title>Greeting Result</title></head>
<body>
    <h2>${message}</h2>
</body>
</html>

---

📌 6. 运行 Spring MVC 应用

🔹 6.1 启动 Tomcat

将项目部署到 Tomcat 或 Spring Boot 内嵌服务器，启动后访问：

• 访问 GET 请求：http://localhost:8080/hello

• 访问表单（GET 请求）：http://localhost:8080/greet

• 提交表单（POST 请求），输入 name 并点击提交

---

📌 7. 总结

✅ 使用 @Controller 创建控制器 处理 GET/POST 请求
✅ 配置 DispatcherServlet 作为 Spring MVC 前端控制器
✅ 使用 ViewResolver 解析视图，返回 JSP 页面
✅ 处理用户输入（POST 请求） 并动态返回数据

---

结语 🎯

至此，我们已经完成了 Spring MVC 的基础入门，从 环境搭建 到 请求处理流程，再到 编写第一个 Spring MVC 应用，掌握了 Spring MVC 的核心概念和开发方法。

---

📌 你已经学会了什么？

✅ Spring MVC 的基本架构（DispatcherServlet、HandlerMapping、HandlerAdapter、ViewResolver）
✅ 如何创建 Spring MVC 项目（Maven/Gradle 依赖、项目结构）
✅ 如何编写 Controller，处理 GET/POST 请求
✅ 如何配置 ViewResolver，解析 JSP 视图并返回响应
✅ 如何处理表单提交，接收用户输入并动态返回数据

---

📌 接下来的学习方向 🚀

现在，你已经掌握了 Spring MVC 的基础，可以进一步深入学习以下高级功能：

🔹 1. Spring MVC 进阶

• 拦截器（Interceptor）：在请求处理前后执行额外逻辑

• 异常处理（ExceptionHandler）：统一管理错误响应

• 文件上传与下载

🔹 2. Spring MVC + 数据库

• 整合 Spring JDBC / MyBatis / JPA，操作数据库

• 编写 RESTful API，使用 @RestController 返回 JSON 数据

🔹 3. Spring Boot 与 Spring MVC

• Spring Boot 简化 MVC 开发（自动配置 + 内嵌服务器）

• Spring Boot + Thymeleaf，构建现代 Web 应用

---

💡 学习编程就像建造房子，Spring MVC 就是地基。打好基础，你就能在此之上 构建更复杂的 Web 应用。希望你在接下来的学习中不断进步，早日成为 Spring 全栈开发高手！💪🚀

如果你有任何问题，欢迎随时交流！Happy Coding! 🎉