Spring MVC文档：从入门到精通

wx1bff85f55b403198

于 2024-08-27 12:49:08 发布

阅读量496

点赞数 9

本文链接：https://blog.csdn.net/weixin_36001279/article/details/141637114

版权

本文还有配套的精品资源，点击获取

简介：Spring MVC是Spring框架的核心模块，用于构建MVC架构的Web应用程序。本文档全面介绍了Spring MVC的功能、工作原理和实际应用。涵盖了DispatcherServlet、Controller、Model、View、ViewResolver等组件，以及模型绑定、数据验证、RESTful Web服务、异常处理和视图技术等关键概念。通过深入学习和实践，开发者可以掌握Spring MVC的精髓，构建高性能、可测试且维护性强的Web应用。

1. Spring MVC 简介

Spring MVC 是一个基于 Model-View-Controller (MVC) 设计模式的 Web 框架，用于构建健壮且可维护的 Web 应用程序。它提供了一个清晰的分层架构，将应用程序的业务逻辑、数据模型和表示层分离。

Spring MVC 的核心组件包括 DispatcherServlet、控制器、模型、视图和视图解析器。DispatcherServlet 是应用程序的入口点，负责将请求路由到相应的控制器。控制器处理请求，并根据业务逻辑返回一个模型对象。模型对象包含要显示给用户的应用程序数据。视图解析器将模型对象转换为最终的表示形式，例如 HTML 或 JSON。

2. Spring MVC 组件

Spring MVC 是一个基于 Java 的 Web 框架，它遵循模型-视图-控制器 (MVC) 设计模式。MVC 模式将应用程序的业务逻辑（模型）、表示层（视图）和用户交互（控制器）分离，从而提高了应用程序的可维护性和可扩展性。

Spring MVC 框架由几个关键组件组成，这些组件共同协作以处理 HTTP 请求并生成响应。

2.1 DispatcherServlet

DispatcherServlet 是 Spring MVC 的核心组件，它负责处理所有传入的 HTTP 请求。它充当控制器和视图之间的中介，根据请求的 URL 将请求路由到适当的控制器。

代码块：

public class DispatcherServlet extends HttpServlet {

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 获取请求的 URL
        String requestURI = request.getRequestURI();

        // 根据 URL 查找对应的控制器
        Controller controller = controllerMapper.getController(requestURI);

        // 调用控制器的 handleRequest 方法处理请求
        ModelAndView modelAndView = controller.handleRequest(request, response);

        // 根据 ModelAndView 选择合适的视图解析器解析视图
        View view = viewResolver.resolveViewName(modelAndView.getViewName());

        // 将模型数据渲染到视图中
        view.render(modelAndView.getModel(), request, response);
    }
}

逻辑分析：

DispatcherServlet 的 service 方法是处理 HTTP 请求的入口。它获取请求的 URL，并使用 controllerMapper 查找与该 URL 对应的控制器。然后，它调用控制器的 handleRequest 方法处理请求，并返回一个 ModelAndView 对象。 ModelAndView 对象包含视图的名称和要渲染到该视图的模型数据。最后， DispatcherServlet 使用 viewResolver 解析视图名称，并使用 view 对象渲染模型数据。

2.2 Controller

控制器是处理用户请求的组件。它负责从请求中提取数据、调用业务逻辑并生成 ModelAndView 对象。 ModelAndView 对象包含视图的名称和要渲染到该视图的模型数据。

代码块：

public class MyController implements Controller {

    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        // 从请求中提取数据
        String name = request.getParameter("name");

        // 调用业务逻辑处理数据
        String message = businessLogic.process(name);

        // 创建 ModelAndView 对象
        ModelAndView modelAndView = new ModelAndView();

        // 设置视图名称
        modelAndView.setViewName("myView");

        // 添加模型数据
        modelAndView.addObject("message", message);

        // 返回 ModelAndView 对象
        return modelAndView;
    }
}

逻辑分析：

MyController 的 handleRequest 方法从请求中提取数据，并调用业务逻辑处理数据。然后，它创建一个 ModelAndView 对象，设置视图名称和要渲染到该视图的模型数据。最后，它返回 ModelAndView 对象。

2.3 Model

模型是包含应用程序数据的对象。它存储由控制器处理的业务逻辑产生的数据。模型数据可以通过 ModelAndView 对象传递给视图。

代码块：

public class MyModel {

    private String message;

    public MyModel(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }
}

逻辑分析：

MyModel 类是一个简单的模型类，它包含一个 message 属性。它有一个构造函数，用于设置 message 属性，以及一个 getMessage 方法，用于获取 message 属性。

2.4 View

视图是负责将模型数据呈现给用户的组件。它可以是 JSP 页面、Thymeleaf 模板或其他类型的视图技术。

代码块：

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %>
<!DOCTYPE html>
<html>
<head>
    <title>My View</title>
</head>
<body>
    <h1>${message}</h1>
</body>
</html>

逻辑分析：

这是一个 JSP 视图，它包含一个 h1 元素，用于显示从模型中获取的 message 属性。

2.5 ViewResolver

视图解析器是负责将视图名称解析为实际视图的组件。它根据视图名称查找相应的视图技术，并创建相应的视图对象。

代码块：

public class MyViewResolver implements ViewResolver {

    @Override
    public View resolveViewName(String viewName) throws Exception {
        // 根据视图名称查找视图技术
        ViewTechnology viewTechnology = viewTechnologyMapper.getViewTechnology(viewName);

        // 创建相应的视图对象
        View view = viewTechnology.createView(viewName);

        // 返回视图对象
        return view;
    }
}

逻辑分析：

MyViewResolver 的 resolveViewName 方法根据视图名称查找视图技术，并创建相应的视图对象。它使用 viewTechnologyMapper 查找视图技术，并使用 viewTechnology 创建视图对象。

3. 模型绑定和数据验证

3.1 模型绑定

模型绑定的概念

模型绑定是将请求参数或表单数据绑定到控制器方法的参数或模型属性的过程。它允许控制器方法访问客户端提交的数据，并将其用于业务逻辑或视图渲染。

模型绑定机制

Spring MVC 提供了两种模型绑定机制：

自动模型绑定： Spring MVC 根据请求参数或表单数据的名称和类型，自动将它们绑定到控制器方法的参数或模型属性。
自定义模型绑定： 使用 @InitBinder 注解或 WebDataBinder 类，可以自定义模型绑定规则，例如指定日期格式、类型转换器等。

自动模型绑定

自动模型绑定支持以下数据类型：

基本数据类型（int、long、double 等）
String
Date
List
Map
实体类

自动模型绑定的示例

@Controller
public class UserController {

    @RequestMapping("/user/create")
    public String createUser(@ModelAttribute User user) {
        // user 对象已自动绑定了请求参数或表单数据
        // ...
        return "user/create";
    }
}

3.2 数据验证

数据验证的概念

数据验证是确保客户端提交的数据符合特定规则和约束的过程。它可以防止无效或恶意数据进入系统，从而提高应用程序的健壮性和安全性。

数据验证机制

Spring MVC 提供了两种数据验证机制：

JSR-303 Bean Validation： 使用 @Valid 注解和 javax.validation 包提供的验证注解，对控制器方法的参数或模型属性进行验证。
自定义数据验证： 使用 @Validated 注解和 Validator 接口，自定义数据验证规则。

JSR-303 Bean Validation

JSR-303 Bean Validation 提供了以下常见的验证注解：

@NotNull ：不能为空
@NotEmpty ：不能为空字符串或集合
@Size ：字符串长度或集合大小范围
@Pattern ：正则表达式匹配
@Email ：电子邮件地址格式
@Min ：最小值
@Max ：最大值

JSR-303 Bean Validation 的示例

@Controller
public class UserController {

    @RequestMapping("/user/create")
    public String createUser(@Valid @ModelAttribute User user) {
        // user 对象已自动绑定并验证了请求参数或表单数据
        // ...
        return "user/create";
    }
}

自定义数据验证

自定义数据验证允许定义更复杂的验证规则。

自定义数据验证的示例

public class EmailValidator implements Validator {

    @Override
    public boolean supports(Class<?> clazz) {
        return String.class.equals(clazz);
    }

    @Override
    public void validate(Object target, Errors errors) {
        String email = (String) target;
        if (!email.matches("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$")) {
            errors.rejectValue("email", "invalid.email", "Invalid email format");
        }
    }
}

@Controller
public class UserController {

    @InitBinder
    public void initBinder(WebDataBinder binder) {
        binder.addValidators(new EmailValidator());
    }

    @RequestMapping("/user/create")
    public String createUser(@Valid @ModelAttribute User user) {
        // user 对象已自动绑定并验证了请求参数或表单数据
        // ...
        return "user/create";
    }
}

4. RESTful Web 服务

4.1 RESTful Web 服务的概念

RESTful Web 服务是一种基于 REST（表述性状态转移）架构风格的 Web 服务。它遵循一组原则，旨在创建可扩展、可维护且易于使用的 Web API。

RESTful Web 服务的特点包括：

无状态性： 服务器不存储有关客户端状态的信息。每个请求都是独立的，并且不依赖于之前的请求。
统一接口： 所有资源都通过一个统一的接口进行访问，该接口使用一组标准方法（如 GET、POST、PUT、DELETE）。
资源表示： 资源以标准化格式表示，例如 JSON 或 XML。
超媒体控制： 服务器提供有关如何访问和操作资源的信息。

4.2 使用 Spring MVC 实现 RESTful Web 服务

Spring MVC 提供了一系列注解和功能，用于简化 RESTful Web 服务的开发。

4.2.1 @RestController 注解

@RestController 注解将一个类标记为 RESTful Web 服务控制器。它相当于 @Controller 和 @ResponseBody 注解的组合，这意味着控制器方法返回的对象将直接写入响应体，而不是渲染为视图。

@RestController
public class UserController {

    @GetMapping("/users")
    public List<User> getAllUsers() {
        // ...
    }
}

4.2.2 请求映射

Spring MVC 使用 @RequestMapping 注解将请求映射到控制器方法。该注解指定请求方法（如 GET、POST）、路径和可选的请求参数。

@RequestMapping(value = "/users", method = RequestMethod.GET)
public List<User> getAllUsers() {
    // ...
}

4.2.3 数据绑定

Spring MVC 使用数据绑定机制将请求参数和正文绑定到控制器方法的参数。它支持各种数据类型，包括 POJO、Map 和 List。

@PostMapping("/users")
public User createUser(@RequestBody User user) {
    // ...
}

4.2.4 响应状态码

Spring MVC 提供了 @ResponseStatus 注解，用于设置 HTTP 响应状态码。它可以用于处理错误或指示成功操作。

@PostMapping("/users")
@ResponseStatus(HttpStatus.CREATED)
public User createUser(@RequestBody User user) {
    // ...
}

4.2.5 异常处理

Spring MVC 提供了 @ExceptionHandler 注解，用于处理控制器方法中抛出的异常。它可以映射到特定的异常类型并返回自定义响应。

@ExceptionHandler(Exception.class)
public ResponseEntity<Error> handleException(Exception e) {
    // ...
}

4.2.6 例子

以下是一个使用 Spring MVC 实现 RESTful Web 服务的示例：

@RestController
@RequestMapping("/users")
public class UserController {

    @GetMapping
    public List<User> getAllUsers() {
        // ...
    }

    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public User createUser(@RequestBody User user) {
        // ...
    }

    @GetMapping("/{id}")
    public User getUserById(@PathVariable("id") Long id) {
        // ...
    }

    @PutMapping("/{id}")
    public User updateUser(@PathVariable("id") Long id, @RequestBody User user) {
        // ...
    }

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable("id") Long id) {
        // ...
    }
}

5. 异常处理

5.1 异常处理机制

Spring MVC 提供了完善的异常处理机制，允许开发人员对应用程序中抛出的异常进行细粒度的控制。异常处理机制主要包括以下几个方面：

异常处理器（ExceptionHandler）： 异常处理器负责处理特定类型的异常。它可以映射到特定的异常类或异常层次结构。
异常解析器（ExceptionResolver）： 异常解析器负责将异常映射到适当的视图。它可以根据异常类型或其他因素选择合适的视图。
异常映射（ExceptionMapping）： 异常映射定义了异常与异常处理器的对应关系。它允许开发人员指定特定异常应由哪个异常处理器处理。

5.2 常见异常类型

Spring MVC 中处理的常见异常类型包括：

ServletException： 由 Servlet 引发的异常，例如 ServletException 和 IOException 。
HttpMediaTypeNotSupportedException： 当请求的媒体类型不被服务器支持时引发。
HttpMessageNotReadableException： 当请求体无法被服务器读取时引发。
HttpMessageNotWritableException： 当服务器无法将响应体写入到响应中时引发。
MethodNotAllowedException： 当请求的 HTTP 方法不被服务器支持时引发。
MissingServletRequestParameterException： 当请求中缺少必需的参数时引发。
NoSuchRequestHandlingMethodException： 当服务器无法找到处理请求的方法时引发。

5.3 自定义异常处理

除了处理常见的异常类型外，开发人员还可以创建自己的自定义异常并定义相应的异常处理器。自定义异常处理允许开发人员对应用程序中的特定错误场景进行细粒度的控制。

以下代码示例演示了如何创建自定义异常和异常处理器：

// 自定义异常
public class MyCustomException extends RuntimeException {

    public MyCustomException(String message) {
        super(message);
    }
}

// 异常处理器
@ControllerAdvice
public class MyExceptionHandler {

    @ExceptionHandler(MyCustomException.class)
    public ResponseEntity<Object> handleMyCustomException(MyCustomException ex) {
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(ex.getMessage());
    }
}

在上面的示例中， MyCustomException 是一个自定义异常， MyExceptionHandler 是一个异常处理器，它负责处理 MyCustomException 。当 MyCustomException 被抛出时， MyExceptionHandler 将被触发，并返回一个带有错误消息的 400 Bad Request 响应。

通过自定义异常处理，开发人员可以创建健壮且可维护的应用程序，这些应用程序可以优雅地处理错误情况并提供有意义的错误消息。

6. 视图技术

视图技术是 Spring MVC 中用于呈现模型数据的组件。Spring MVC 提供了多种视图技术，包括 JSP、Thymeleaf 和 Velocity。这些技术允许开发人员使用不同的模板语言和语法来创建动态 Web 页面。

6.1 JSP 视图

JSP（JavaServer Pages）是一种基于 Java 的视图技术，它允许开发人员在 HTML 页面中嵌入 Java 代码。JSP 页面使用 .jsp 文件扩展名，并由 JSP 容器编译为 Java Servlet。

6.1.1 JSP 语法

JSP 语法基于 XML，并使用以下标签：

<jsp:useBean> ：用于创建和使用 JavaBean 对象
<jsp:setProperty> ：用于设置 JavaBean 属性
<jsp:getProperty> ：用于获取 JavaBean 属性
<jsp:forward> ：用于将请求转发到另一个 JSP 页面
<jsp:include> ：用于在当前 JSP 页面中包含另一个 JSP 页面

6.1.2 JSP 控制器

JSP 控制器是用于处理请求并生成 JSP 视图的 Java 类。控制器使用 @Controller 注解进行注释，并使用 @RequestMapping 注解映射请求路径。

6.1.3 示例

以下是一个使用 JSP 视图的简单控制器：

@Controller
@RequestMapping("/jsp")
public class JspController {

    @GetMapping
    public String index() {
        return "index.jsp";
    }

}

6.2 Thymeleaf 视图

Thymeleaf 是一种现代化的视图技术，它使用模板语言来生成动态 Web 页面。Thymeleaf 模板使用 .html 文件扩展名，并由 Thymeleaf 引擎编译为 HTML。

6.2.1 Thymeleaf 语法

Thymeleaf 语法基于 HTML，并使用以下表达式：

${} ：用于获取模型属性
*{ } ：用于执行表达式
# ：用于访问 Thymeleaf 对象
@{} ：用于访问 Spring MVC 注解

6.2.2 Thymeleaf 控制器

Thymeleaf 控制器与 JSP 控制器类似，但使用 @ThymeleafController 注解进行注释。

6.2.3 示例

以下是一个使用 Thymeleaf 视图的简单控制器：

@ThymeleafController
@RequestMapping("/thymeleaf")
public class ThymeleafController {

    @GetMapping
    public String index() {
        return "index.html";
    }

}

6.3 Velocity 视图

Velocity 是一种模板引擎，它允许开发人员使用 Velocity 模板语言来生成动态 Web 页面。Velocity 模板使用 .vm 文件扩展名，并由 Velocity 引擎编译为 HTML。

6.3.1 Velocity 语法

Velocity 语法基于 OGNL（Object-Graph Navigation Language），并使用以下指令：

#set ：用于设置变量
#if ：用于执行条件语句
#foreach ：用于执行循环
#macro ：用于定义宏
#include ：用于包含另一个 Velocity 模板

6.3.2 Velocity 控制器

Velocity 控制器与 JSP 和 Thymeleaf 控制器类似，但使用 @VelocityController 注解进行注释。

6.3.3 示例

以下是一个使用 Velocity 视图的简单控制器：

@VelocityController
@RequestMapping("/velocity")
public class VelocityController {

    @GetMapping
    public String index() {
        return "index.vm";
    }

}

6.4 视图解析器

视图解析器是 Spring MVC 中用于将视图名称解析为实际视图对象的组件。Spring MVC 提供了多种视图解析器，包括：

InternalResourceViewResolver ：用于解析 JSP 视图
ThymeleafViewResolver ：用于解析 Thymeleaf 视图
VelocityViewResolver ：用于解析 Velocity 视图

6.5 选择视图技术

选择合适的视图技术取决于应用程序的特定要求。以下是一些考虑因素：

性能： Thymeleaf 通常比 JSP 和 Velocity 更快。
可维护性： Thymeleaf 和 Velocity 的模板语言比 JSP 更易于维护。
功能： Thymeleaf 和 Velocity 提供了比 JSP 更强大的功能，例如模板继承和局部。
社区支持： JSP 拥有庞大的社区支持，而 Thymeleaf 和 Velocity 的社区相对较小。

7. 测试支持

7.1 单元测试

单元测试是针对单个方法或类的测试，它可以验证方法或类的行为是否符合预期。Spring MVC 提供了对单元测试的支持，可以使用 @RunWith 和 @ContextConfiguration 注解来配置测试环境。

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { MyController.class })
public class MyControllerTest {

    @Autowired
    private MyController myController;

    @Test
    public void testIndex() {
        ModelAndView modelAndView = myController.index();
        assertEquals("index", modelAndView.getViewName());
    }

}

7.2 集成测试

集成测试是针对多个组件或模块的测试，它可以验证组件或模块之间的交互是否符合预期。Spring MVC 提供了对集成测试的支持，可以使用 @WebMvcTest 注解来配置测试环境。

@WebMvcTest(MyController.class)
public class MyControllerIntegrationTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void testIndex() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.get("/"))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andExpect(MockMvcResultMatchers.view().name("index"));
    }

}

本文还有配套的精品资源，点击获取

wx1bff85f55b403198

关注

9
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
Spring MVC文档：从入门到精通

本文还有配套的精品资源，点击获取简介：Spring MVC是Spring框架的核心模块，用于构建MVC架构的Web应用程序。本文档全面介绍了Spring MVC的功能、工作原理和实际应用。涵盖了DispatcherServlet、Controller、Model、View、ViewResolver等组件，以及模型绑定、数据验证、RESTful Web服务、异常处理和视图技...
复制链接

扫一扫