Spring MVC 全面详解：Java Web 开发框架

记忆：前端控制器是核心，所有组件都由它调度，开发者只需要写 Controller 和业务逻辑，其余组件 Spring MVC 都已内置实现。

四、Spring MVC 核心组件（各司其职，缺一不可）

上面流程中提到的组件，是 Spring MVC 的核心，全部由 Spring 容器管理，大部分组件开发者无需自定义，Spring 提供默认实现，这里讲清楚每个组件的核心作用：

1. 前端控制器：DispatcherServlet（核心核心核心）

地位：整个 Spring MVC 的核心，无它不成立；

作用：统一接收请求、统一响应结果，负责调度其他所有组件，相当于「交通指挥中心」；

特点：全局唯一，由开发者在 web.xml 或配置类中配置，生命周期由 Tomcat 管理。

2. 处理器映射器：HandlerMapping

作用：根据请求 URL 匹配对应的 Controller 方法；

原理：Spring 启动时，会扫描所有 Controller 中的请求映射注解（如 @RequestMapping），将「URL-Controller 方法」的映射关系存入内存，请求来时直接匹配。

常用实现：RequestMappingHandlerMapping（Spring MVC 默认，支持 @RequestMapping 系列注解）。

3. 处理器适配器：HandlerAdapter

作用：适配并执行 Handler（Controller）；

核心价值：屏蔽不同 Handler 的执行差异，让 DispatcherServlet 无需关心具体的 Controller 是如何执行的，只需要调用适配器即可，符合「开闭原则」。

常用实现：RequestMappingHandlerAdapter（Spring MVC 默认，适配 @RequestMapping 注解的 Controller）。

4. 处理器：Handler（开发者核心编写）

本质：就是我们编写的 Controller 类；

作用：业务请求的具体处理者，负责接收参数、调用业务逻辑、返回处理结果；

特点：开发者自定义，是 Spring MVC 中唯一需要开发者编写核心逻辑的组件。

5. 视图解析器：ViewResolver

作用：解析视图地址，生成视图对象；

核心能力：拼接视图路径，比如开发者返回视图名index，视图解析器可以自动拼接前缀/WEB-INF/views/和后缀.jsp，最终得到完整路径/WEB-INF/views/index.jsp。

常用实现：InternalResourceViewResolver（默认，支持 JSP 解析）。

6. 视图：View

作用：渲染数据，生成响应页面；

类型：JSP、HTML、Thymeleaf 模板、PDF 等，只负责展示数据，不处理业务。

五、Spring MVC 核心注解（高频必用，必须掌握）

Spring MVC 基于注解驱动开发，完全摒弃了早期的 XML 配置方式，所有核心功能都通过注解实现，以下是开发中常用到的核心注解，按使用频率排序：

类级注解：@Controller

作用：标记一个 Java 类为 Spring MVC 的控制（Controller/Handler）；

核心特性：

被该注解标记的类，会被 Spring 容器扫描并实例化（纳入 IoC 容器）； 该类中的方法可以通过「请求映射注解」绑定 URL，接收前端请求； 配合@ResponseBody注解，可让 Controller 直接返回 JSON 数据（前后端分离项目必用）。

补：该注解标记的类，默认返回视图名称（跳转页面，比如 JSP/HTML），而非数据，通常用于传统前后端一体项目（需要跳转页面、渲染视图）

类级 + 方法级注解：@RequestMapping

作用：建立「URL 请求地址」和「Controller 方法」的映射关系；

核心用法： 加在类上：设置当前 Controller 的「请求前缀」，所有方法的 URL 都基于该前缀拼接； 加在方法上：设置当前方法的「请求路径」，结合类上的前缀，形成完整的请求 URL；

核心属性： value/path：指定请求 URL（必填）； method：指定请求方式（GET/POST/PUT/DELETE），如method = RequestMethod.GET； params：限制请求必须携带指定参数才会匹配；

示例：

@RestController
@RequestMapping("/user")
// 类上：所有方法的 URL 前缀都是 /user
public class UserController {
    // 方法上：完整请求 URL = /user/query，仅处理 GET 请求
    @RequestMapping(value = "/query", method = RequestMethod.GET)
    public String query() {
        return "查询用户";
    }
}

简化版请求注解（Spring4.3 + 新增，推荐优先使用）

是@RequestMapping的专用简化版，语义更清晰，开发中常用这些代替 @RequestMapping：

@GetMapping("url") → 等价于 @RequestMapping(value="url",method=RequestMethod.GET) → 处理 GET 请求（查询）；

@PostMapping("url") → 等价于 @RequestMapping(value="url",method=RequestMethod.POST) → 处理 POST 请求（新增）；

@PutMapping("url") → 处理 PUT 请求（修改）；

@DeleteMapping("url") → 处理 DELETE 请求（删除）；

核心响应注解：@ResponseBody

作用：将方法的返回值，直接转换为 JSON 格式的响应体，返回给前端；

核心特性： 加在方法上：当前方法返回 JSON，不跳转页面； 加在类上：当前 Controller 的所有方法都返回 JSON，无需逐个添加；

✨ 组合注解：@RestController = @Controller + @ResponseBody → 前后端分离项目的标配，标记的 Controller 所有方法都返回 JSON，不会跳转视图。

补：不加该注解时，方法返回值会被解析为「视图名称」（比如返回"index"会跳转 index.jsp 页面）； 加了该注解后，返回值就是纯数据，不再跳转页面； 搭配@Controller使用，适合「部分方法返回 JSON、部分方法跳转页面」的混合场景。

请求参数接收注解

用于在 Controller 方法中接收前端传递的参数，开发中高频使用：

1. @RequestParam

@RequestParam("参数名")：接收 URL 拼接参数（GET）或表单提交参数（POST），如@RequestParam("name") String username；

属性： value/name：必填，指定前端传递的参数名，必须和前端一致； required：可选，默认true，表示该参数必须传递，不传则报错；设为false则参数可选； defaultValue：可选，给参数设置默认值，当参数未传递 / 传递空值时生效。

示例：

// 请求 URL：http://localhost:8080/user/query?name=张三&age=20
@GetMapping("/query")
// 接收 name 和 age 参数，age 可选，默认值 18
public String query(
    @RequestParam("name") String username,
    @RequestParam(value = "age", required = false, defaultValue = "18") Integer age
) {
    return "姓名：" + username + ",年龄：" + age;
}

若：后端参数名 = 前端参数名，可以省略注解，直接写参数即可，底层自动映射：

// 等价于上面的写法，name 和前端参数名一致，可省略 @RequestParam
public String query(String name, Integer age) {
    ...
}

2. @PathVariable

@PathVariable("占位符")：接收 RESTful 风格的 URL 路径参数，如@GetMapping("/user/{id}")中，用@PathVariable("id") Integer id接收；

注意： URL 中需要用 {参数名} 定义占位符； 注解的value值必须和占位符的参数名一致； 该参数默认是必传的，不传则请求 404。

// 请求 URL：http://localhost:8080/user/1001/info
@GetMapping("/{userId}/info")
// {userId}是路径占位符
public String getUserInfo(@PathVariable("userId") String id) {
    return "用户 ID：" + id;
}

3. @RequestBody

@RequestBody：接收前端传递的 JSON 格式请求体（POST/PUT 必用），直接封装到实体类中，如@RequestBody User user；

特点： 只能标注在方法参数上，且一个方法只能有一个 @RequestBody 参数； 前端必须将参数放在 请求体 (Request Body) 中，且请求头Content-Type = application/json； Spring MVC 会通过 Jackson 框架自动完成「JSON 字符串 → Java 对象」的反序列化，无需手动解析； 适用于传递复杂参数（比如新增用户时传递姓名、年龄、手机号、地址等多个字段）。

示例：

// 前端 POST 请求，请求体是 JSON：{"name":"张三","age":20,"phone":"13800138000"}
@PostMapping("/add")
// 自动将 JSON 请求体封装为 User 实体类对象
public String addUser(@RequestBody User user) {
    return "新增用户：" + user.getName();
}

4. @RequestHeader

作用：接收前端在 HTTP 请求头 中传递的参数，比如token、Content-Type、User-Agent等。

示例：

// 接收请求头中的 token 参数，用于接口鉴权
@GetMapping("/auth")
public String auth(@RequestHeader("token") String token) {
    return "请求头中的令牌：" + token;
}

5. @CookieValue

作用：接收前端浏览器在请求中携带的 Cookie 数据，比如登录后的 Cookie 令牌。

@GetMapping("/cookie")
public String getCookie(@CookieValue("JSESSIONID") String sessionId) {
    return "Cookie 中的会话 ID：" + sessionId;
}

补：

@ModelAttribute

作用：将前端传递的表单参数，自动封装为 Java 实体类对象，适用于传统表单提交的场景；

场景：替代多个@RequestParam，简化表单参数的封装，比如提交用户信息时，直接封装为User对象。

@CrossOrigin

作用：解决前端跨域请求问题，前后端分离项目必用！

使用：标注在 Controller 类上（所有方法允许跨域）或方法上（仅当前方法允许跨域），无需额外配置跨域过滤器，开箱即用。

示例：

@RestController
@RequestMapping("/user")
@CrossOrigin
// 所有方法允许跨域请求
public class UserController {
    ...
}

六、Spring MVC 最简入门示例（完整可运行，核心代码）

下面给出基于注解的最简 Spring MVC 入门案例，包含核心配置 + 核心代码，能直观看到 Spring MVC 的开发方式，分「传统前后端一体」和「前后端分离（主流）」两种最常用场景。

环境前提

JDK 8+ Spring MVC 5.x+ 依赖：核心依赖spring-webmvc

✅ 场景 1：前后端分离（主流）→ 返回 JSON 数据（推荐）

1. 编写核心控制器（@RestController 版）

// 组合注解：@Controller + @ResponseBody，所有方法返回 JSON
@RestController
// 类级请求前缀：所有方法的 URL 都以 /user 开头
@RequestMapping("/user")
public class UserController {
    // 处理 GET 请求，完整 URL：http://localhost:8080/user/info/1
    @GetMapping("/info/{id}")
    public User getUserInfo(@PathVariable("id") Integer id) {
        // 模拟业务逻辑：根据 ID 查询用户
        User user = new User();
        user.setId(id);
        user.setName("张三");
        user.setAge(20);
        // 直接返回实体类，Spring MVC 自动转为 JSON 响应给前端
        return user;
    }

    // 处理 POST 请求，接收前端 JSON 参数，完整 URL：http://localhost:8080/user/add
    @PostMapping("/add")
    public Result addUser(@RequestBody User user) {
        // 模拟新增用户业务
        System.out.println("新增用户：" + user);
        // 返回统一响应结果
        return Result.success("新增用户成功");
    }
}

// 实体类：User
class User {
    private Integer id;
    private String name;
    private Integer age;
    // getter/setter 省略
}

// 统一响应结果类：Result
class Result {
    private Integer code;
    private String msg;
    private Object data;
    // 静态工具方法：success/error 省略
}

✅ 场景 2：传统前后端一体 → 跳转页面（返回视图）

// 只加@Controller，方法返回视图名称，不是 JSON
@Controller
@RequestMapping("/page")
public class PageController {
    // 处理 GET 请求，URL：http://localhost:8080/page/index
    @GetMapping("/index")
    public ModelAndView index() {
        // 创建 ModelAndView 对象，封装数据 + 视图地址
        ModelAndView mv = new ModelAndView();
        // 1. 往 Model 中存数据（前端页面可以获取）
        mv.addObject("msg", "欢迎使用 Spring MVC");
        // 2. 设置视图名称，视图解析器会拼接前缀 + 后缀
        mv.setViewName("index");
        // 最终视图路径：/WEB-INF/views/index.jsp
        return mv;
    }
}

七、Spring MVC 的核心优势（为什么是 Java Web 的首选）

1. 无缝集成 Spring 生态：Spring MVC 是 Spring 的核心模块，天然兼容 Spring 的 IoC 容器、AOP、事务管理、注解驱动等特性，无需额外整合，开发无缝衔接；
2. 极致解耦：基于 MVC 设计模式，三层职责分离，代码可读性、可维护性、扩展性极强；
3. 轻量级无侵入：核心依赖少，项目启动快，注解驱动开发，对业务代码几乎无侵入；
4. 功能强大且灵活：支持 RESTful 风格、文件上传下载、拦截器、异常统一处理、数据校验、跨域请求等所有 Web 开发必备功能；
5. 高性能：底层设计简洁，没有多余的封装，请求处理效率高，能支撑高并发场景；
6. 社区成熟：Spring 生态是 Java 后端的事实标准，文档齐全、问题解决方案多，几乎所有 Java 后端岗位都要求掌握。

总结

1. Spring MVC 是 Spring 的核心模块，基于 MVC 设计模式的轻量级 Java Web 框架，Java Web 开发的主流技术；
2. MVC 三层：Model（数据 + 业务）、View（展示）、Controller（调度），核心是解耦；
3. Spring MVC 的核心是 DispatcherServlet（前端控制器），所有请求统一入口，调度其他组件；
4. 核心执行流程：请求→DispatcherServlet→HandlerMapping→HandlerAdapter→Controller→ModelAndView→ViewResolver→View→响应；
5. 核心注解：@Controller/@RestController、@RequestMapping及简化版@GetMapping/@PostMapping、@ResponseBody、@RequestParam/@PathVariable/@RequestBody；
6. 主流开发方式：前后端分离，用@RestController返回 JSON，是目前企业开发的标配；
7. 核心优势：无缝集成 Spring、极致解耦、轻量灵活、功能强大、社区成熟。