Spring MVC页面输出技术全解析从ModelAndView到ViewResolver详解数据渲染与页面展示的完整流程及实战技巧

威震华夏关云长

引言

Spring MVC作为Spring框架中用于Web开发的重要模块，提供了一套强大而灵活的页面输出技术。在Web应用开发中，如何将控制器处理后的数据有效地渲染并展示给用户，是每个开发者必须掌握的核心技能。本文将全面解析Spring MVC中的页面输出技术，从ModelAndView到ViewResolver，详细剖析数据渲染与页面展示的完整流程，并结合实际案例分享实战技巧，帮助开发者深入理解并灵活运用这些技术。

Spring MVC页面输出技术概述

Spring MVC的页面输出技术主要涉及以下几个核心组件：

1. Controller：处理用户请求，准备需要展示的数据
2. Model：存储需要传递给视图的数据
3. View：负责渲染数据并生成HTML响应
4. ModelAndView：一个同时包含Model和View的对象
5. ViewResolver：根据视图名称解析具体的View对象

这些组件协同工作，形成了一个完整的数据渲染与页面展示流程。当控制器处理完请求后，会将数据放入Model中，并指定一个视图名称，然后ViewResolver会根据这个视图名称找到具体的视图实现，最后视图将Model中的数据渲染成最终的HTML响应返回给客户端。

ModelAndView详解

ModelAndView的基本概念

ModelAndView是Spring MVC中一个非常重要的类，它同时封装了Model和View两个对象。Model用于存储数据，View用于指定视图。通过ModelAndView，我们可以在控制器方法中方便地将数据和视图信息返回给DispatcherServlet。

ModelAndView的使用方式

ModelAndView提供了多种构造方式：

2. // 1. 只指定视图名
3. ModelAndView mav = new ModelAndView("viewName");
5. // 2. 同时指定视图名和Model
6. Map<String, Object> model = new HashMap<>();
7. model.put("key1", "value1");
8. model.put("key2", "value2");
9. ModelAndView mav = new ModelAndView("viewName", model);
11. // 3. 指定视图名并添加单个模型数据
12. ModelAndView mav = new ModelAndView("viewName", "modelName", modelObject);
14. // 4. 创建空的ModelAndView，后续再设置
15. ModelAndView mav = new ModelAndView();
16. mav.setViewName("viewName");
17. mav.addObject("key1", "value1");
18. mav.addObject("key2", "value2");

复制代码

下面是一个完整的Controller示例，展示如何使用ModelAndView：

2. @Controller
3. @RequestMapping("/user")
4. public class UserController {
5.    
6.     @Autowired
7.     private UserService userService;
8.    
9.     @RequestMapping("/detail/{id}")
10.     public ModelAndView getUserDetail(@PathVariable("id") Long id) {
11.         // 创建ModelAndView对象
12.         ModelAndView mav = new ModelAndView();
13.         
14.         // 获取用户数据
15.         User user = userService.getUserById(id);
16.         
17.         // 添加模型数据
18.         mav.addObject("user", user);
19.         
20.         // 获取用户的订单列表
21.         List<Order> orders = orderService.getOrdersByUserId(id);
22.         mav.addObject("orders", orders);
23.         
24.         // 设置视图名称
25.         mav.setViewName("user/detail");
26.         
27.         return mav;
28.     }
29.    
30.     @RequestMapping("/list")
31.     public ModelAndView getUserList(
32.             @RequestParam(defaultValue = "1") int page,
33.             @RequestParam(defaultValue = "10") int size) {
34.         
35.         // 分页获取用户列表
36.         Page<User> userPage = userService.getUserList(page, size);
37.         
38.         // 使用另一种方式创建ModelAndView
39.         return new ModelAndView("user/list", "page", userPage);
40.     }
41. }

复制代码

ModelAndView提供了一些常用方法来操作模型数据和视图：

2. // 添加模型数据
3. mav.addObject("key", value);  // 添加单个数据
4. mav.addAllObjects(map);       // 批量添加数据
6. // 获取模型数据
7. Map<String, Object> model = mav.getModel();  // 获取整个模型
8. Object value = mav.getModel().get("key");    // 获取特定数据
10. // 设置和获取视图
11. mav.setViewName("viewName");  // 设置视图名称
12. String viewName = mav.getViewName();  // 获取视图名称
13. View view = mav.getView();  // 获取View对象
15. // 设置视图状态
16. mav.setStatus(HttpStatus.OK);  // 设置HTTP状态码
17. mav.clear();  // 清除ModelAndView中的所有数据

复制代码

ModelAndView的工作原理

当控制器方法返回一个ModelAndView对象后，DispatcherServlet会进行以下处理：

1. 获取ModelAndView中的Model数据，并将其合并到临时的ModelMap中
2. 获取ModelAndView中的View信息（可以是视图名称或View对象）
3. 如果是视图名称，则使用ViewResolver解析为具体的View对象
4. 将Model数据传递给View对象，进行渲染
5. 返回渲染后的响应结果

下面是一个简化版的处理流程示意图：

2. // DispatcherServlet处理ModelAndView的简化流程
3. protected void render(ModelAndView mav, HttpServletRequest request, HttpServletResponse response) throws Exception {
4.     // 1. 获取视图
5.     View view = resolveViewName(mav.getViewName(), mav.getModelInternal(), request, response);
6.    
7.     // 2. 渲染视图
8.     if (view != null) {
9.         view.render(mav.getModelInternal(), request, response);
10.     }
11. }

复制代码

ViewResolver详解

ViewResolver的基本概念

ViewResolver是Spring MVC中负责将视图名称解析为具体View对象的组件。当控制器返回一个视图名称时，ViewResolver会根据这个名称找到对应的View实现，如JSP、Thymeleaf、FreeMarker等。

ViewResolver的接口定义

ViewResolver接口非常简单，只定义了一个方法：

2. public interface ViewResolver {
3.     View resolveViewName(String viewName, Locale locale) throws Exception;
4. }

复制代码

其中，viewName是控制器返回的视图名称，locale是本地化信息，返回值是解析后的View对象。

Spring MVC提供的ViewResolver实现

Spring MVC提供了多种ViewResolver的实现，以适应不同的视图技术：

InternalResourceViewResolver是最常用的ViewResolver之一，主要用于解析JSP和HTML等内部资源视图：

2. @Configuration
3. @EnableWebMvc
4. @ComponentScan("com.example.controller")
5. public class WebConfig implements WebMvcConfigurer {
6.    
7.     @Bean
8.     public InternalResourceViewResolver viewResolver() {
9.         InternalResourceViewResolver resolver = new InternalResourceViewResolver();
10.         resolver.setPrefix("/WEB-INF/views/");  // 设置视图前缀
11.         resolver.setSuffix(".jsp");             // 设置视图后缀
12.         resolver.setViewClass(JstlView.class);  // 设置视图类，支持JSTL
13.         return resolver;
14.     }
15. }

复制代码

配置完成后，当控制器返回”user/detail”时，InternalResourceViewResolver会将其解析为”/WEB-INF/views/user/detail.jsp”。

UrlBasedViewResolver是InternalResourceViewResolver的父类，提供了一种更简单的方式来解析视图：

2. @Bean
3. public UrlBasedViewResolver urlBasedViewResolver() {
4.     UrlBasedViewResolver resolver = new UrlBasedViewResolver();
5.     resolver.setPrefix("/WEB-INF/views/");
6.     resolver.setSuffix(".jsp");
7.     resolver.setViewClass(JstlView.class);
8.     return resolver;
9. }

复制代码

ResourceBundleViewResolver允许我们在属性文件中定义视图名称和对应的View类：

2. @Bean
3. public ResourceBundleViewResolver resourceBundleViewResolver() {
4.     ResourceBundleViewResolver resolver = new ResourceBundleViewResolver();
5.     resolver.setBasename("views");  // 指定属性文件的基础名称
6.     return resolver;
7. }

复制代码

然后在classpath根目录下的views.properties文件中定义视图映射：

2. user.detail.(class)=org.springframework.web.servlet.view.JstlView
3. user.detail.url=/WEB-INF/views/user/detail.jsp
5. user.list.(class)=org.springframework.web.servlet.view.JstlView
6. user.list.url=/WEB-INF/views/user/list.jsp

复制代码

XmlViewResolver允许我们在XML配置文件中定义视图：

2. @Bean
3. public XmlViewResolver xmlViewResolver() {
4.     XmlViewResolver resolver = new XmlViewResolver();
5.     resolver.setLocation(new ClassPathResource("views.xml"));  // 指定XML配置文件
6.     return resolver;
7. }

复制代码

然后在views.xml文件中定义视图：

2. <beans xmlns="http://www.springframework.org/schema/beans"
3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.        xsi:schemaLocation="http://www.springframework.org/schema/beans
5.        http://www.springframework.org/schema/beans/spring-beans.xsd">
6.    
7.     <bean id="userDetail" class="org.springframework.web.servlet.view.JstlView">
8.         <property name="url" value="/WEB-INF/views/user/detail.jsp"/>
9.     </bean>
10.    
11.     <bean id="userList" class="org.springframework.web.servlet.view.JstlView">
12.         <property name="url" value="/WEB-INF/views/user/list.jsp"/>
13.     </bean>
14. </beans>

复制代码

FreeMarkerViewResolver用于解析FreeMarker模板：

2. @Bean
3. public FreeMarkerViewResolver freeMarkerViewResolver() {
4.     FreeMarkerViewResolver resolver = new FreeMarkerViewResolver();
5.     resolver.setPrefix("");  // FreeMarker通常不需要前缀
6.     resolver.setSuffix(".ftl");  // FreeMarker模板文件后缀
7.     resolver.setContentType("text/html;charset=UTF-8");
8.     return resolver;
9. }
11. @Bean
12. public FreeMarkerConfigurer freeMarkerConfigurer() {
13.     FreeMarkerConfigurer configurer = new FreeMarkerConfigurer();
14.     configurer.setTemplateLoaderPath("/WEB-INF/views/");  // 模板文件路径
15.     return configurer;
16. }

复制代码

ThymeleafViewResolver用于解析Thymeleaf模板：

2. @Bean
3. public ThymeleafViewResolver thymeleafViewResolver(SpringTemplateEngine templateEngine) {
4.     ThymeleafViewResolver resolver = new ThymeleafViewResolver();
5.     resolver.setTemplateEngine(templateEngine);
6.     resolver.setCharacterEncoding("UTF-8");
7.     return resolver;
8. }
10. @Bean
11. public SpringTemplateEngine templateEngine(ITemplateResolver templateResolver) {
12.     SpringTemplateEngine engine = new SpringTemplateEngine();
13.     engine.setTemplateResolver(templateResolver);
14.     return engine;
15. }
17. @Bean
18. public ITemplateResolver templateResolver() {
19.     SpringResourceTemplateResolver resolver = new SpringResourceTemplateResolver();
20.     resolver.setPrefix("/WEB-INF/views/");
21.     resolver.setSuffix(".html");
22.     resolver.setTemplateMode(TemplateMode.HTML);
23.     resolver.setCharacterEncoding("UTF-8");
24.     return resolver;
25. }

复制代码

ViewResolver的链式处理

Spring MVC支持配置多个ViewResolver，并可以指定它们的优先级。当需要解析视图时，Spring MVC会按照优先级顺序依次调用每个ViewResolver，直到有一个能够解析出View对象为止。

2. @Configuration
3. @EnableWebMvc
4. @ComponentScan("com.example.controller")
5. public class WebConfig implements WebMvcConfigurer {
6.    
7.     @Bean
8.     public ThymeleafViewResolver thymeleafViewResolver(SpringTemplateEngine templateEngine) {
9.         ThymeleafViewResolver resolver = new ThymeleafViewResolver();
10.         resolver.setTemplateEngine(templateEngine);
11.         resolver.setCharacterEncoding("UTF-8");
12.         resolver.setOrder(1);  // 设置优先级，数字越小优先级越高
13.         return resolver;
14.     }
15.    
16.     @Bean
17.     public InternalResourceViewResolver internalResourceViewResolver() {
18.         InternalResourceViewResolver resolver = new InternalResourceViewResolver();
19.         resolver.setPrefix("/WEB-INF/views/");
20.         resolver.setSuffix(".jsp");
21.         resolver.setOrder(2);  // 优先级低于ThymeleafViewResolver
22.         return resolver;
23.     }
24.    
25.     // 其他Bean定义...
26. }

复制代码

在上述配置中，当控制器返回一个视图名称时，Spring MVC会首先尝试使用ThymeleafViewResolver进行解析，如果失败，则尝试使用InternalResourceViewResolver。

自定义ViewResolver

如果Spring MVC提供的ViewResolver无法满足需求，我们还可以自定义ViewResolver：

2. public class CustomViewResolver implements ViewResolver {
3.    
4.     private String prefix;
5.     private String suffix;
6.    
7.     public void setPrefix(String prefix) {
8.         this.prefix = prefix;
9.     }
10.    
11.     public void setSuffix(String suffix) {
12.         this.suffix = suffix;
13.     }
14.    
15.     @Override
16.     public View resolveViewName(String viewName, Locale locale) throws Exception {
17.         // 根据视图名称和本地化信息构建实际视图路径
18.         String viewPath = prefix + viewName + suffix;
19.         
20.         // 这里可以根据实际需求创建不同的View对象
21.         // 例如，根据文件扩展名决定使用哪种视图技术
22.         if (viewPath.endsWith(".jsp")) {
23.             JstlView view = new JstlView();
24.             view.setUrl(viewPath);
25.             return view;
26.         } else if (viewPath.endsWith(".html")) {
27.             InternalResourceView view = new InternalResourceView();
28.             view.setUrl(viewPath);
29.             return view;
30.         }
31.         
32.         // 如果无法解析，返回null，让下一个ViewResolver尝试
33.         return null;
34.     }
35. }

复制代码

然后在配置类中注册自定义的ViewResolver：

2. @Bean
3. public CustomViewResolver customViewResolver() {
4.     CustomViewResolver resolver = new CustomViewResolver();
5.     resolver.setPrefix("/WEB-INF/views/");
6.     resolver.setSuffix(".html");
7.     resolver.setOrder(0);  // 设置最高优先级
8.     return resolver;
9. }

复制代码

数据渲染与页面展示流程

完整的请求处理流程

Spring MVC处理请求并渲染页面的完整流程如下：

1. 用户发送请求到DispatcherServlet
2. DispatcherServlet根据请求URL找到对应的HandlerMapping
3. HandlerMapping返回对应的HandlerExecutionChain
4. DispatcherServlet通过HandlerAdapter调用对应的Controller方法
5. Controller方法处理业务逻辑，并返回ModelAndView
6. DispatcherServlet接收ModelAndView，并调用ViewResolver解析视图
7. ViewResolver根据视图名称返回对应的View对象
8. DispatcherServlet将Model数据传递给View对象
9. View对象使用Model数据进行渲染，生成最终的HTML响应
10. DispatcherServlet将HTML响应返回给用户

下面是一个详细流程的示意图：

2. // DispatcherServlet的简化处理流程
3. protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
4.     // 1. 根据请求获取Handler
5.     HandlerExecutionChain mappedHandler = getHandler(request);
6.    
7.     // 2. 获取HandlerAdapter
8.     HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
9.    
10.     // 3. 调用前置拦截器
11.     if (!mappedHandler.applyPreHandle(request, response)) {
12.         return;
13.     }
14.    
15.     // 4. 调用Controller方法
16.     ModelAndView mav = ha.handle(request, response, mappedHandler.getHandler());
17.    
18.     // 5. 调用后置拦截器
19.     mappedHandler.applyPostHandle(request, response, mav);
20.    
21.     // 6. 处理分发结果
22.     processDispatchResult(request, response, mappedHandler, mav);
23. }
25. // 处理分发结果
26. private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
27.         HandlerExecutionChain mappedHandler, ModelAndView mav) throws Exception {
28.     // 渲染视图
29.     render(mav, request, response);
30.    
31.     // 触发完成回调
32.     mappedHandler.triggerAfterCompletion(request, response, null);
33. }
35. // 渲染视图
36. protected void render(ModelAndView mav, HttpServletRequest request, HttpServletResponse response) throws Exception {
37.     // 1. 解析视图
38.     View view = resolveViewName(mav.getViewName(), mav.getModelInternal(), request, response);
39.    
40.     // 2. 渲染视图
41.     if (view != null) {
42.         view.render(mav.getModelInternal(), request, response);
43.     }
44. }

复制代码

数据传递与渲染机制

在Spring MVC中，Model数据可以通过多种方式创建和传递：

方式一：使用ModelAndView

2. @RequestMapping("/user/{id}")
3. public ModelAndView getUser(@PathVariable Long id) {
4.     User user = userService.getUserById(id);
5.     ModelAndView mav = new ModelAndView();
6.     mav.addObject("user", user);  // 添加数据到Model
7.     mav.setViewName("user/detail");
8.     return mav;
9. }

复制代码

方式二：使用Model参数

2. @RequestMapping("/user/{id}")
3. public String getUser(@PathVariable Long id, Model model) {
4.     User user = userService.getUserById(id);
5.     model.addAttribute("user", user);  // 添加数据到Model
6.     return "user/detail";
7. }

复制代码

方式三：使用ModelMap参数

2. @RequestMapping("/user/{id}")
3. public String getUser(@PathVariable Long id, ModelMap model) {
4.     User user = userService.getUserById(id);
5.     model.addAttribute("user", user);  // 添加数据到Model
6.     return "user/detail";
7. }

复制代码

方式四：使用Map参数

2. @RequestMapping("/user/{id}")
3. public String getUser(@PathVariable Long id, Map<String, Object> model) {
4.     User user = userService.getUserById(id);
5.     model.put("user", user);  // 添加数据到Model
6.     return "user/detail";
7. }

复制代码

方式五：使用@ModelAttribute注解

2. @ModelAttribute("user")
3. public User getUser(@PathVariable Long id) {
4.     return userService.getUserById(id);
5. }
7. @RequestMapping("/user/{id}")
8. public String getUser() {
9.     return "user/detail";
10. }

复制代码

不同的视图技术有不同的渲染机制，下面以JSP和Thymeleaf为例进行说明：

JSP渲染机制

JSP（JavaServer Pages）是一种基于Java的模板技术，它允许在HTML中嵌入Java代码。在Spring MVC中，JSP的渲染过程如下：

1. ViewResolver将视图名称解析为JSP文件路径
2. DispatcherServlet将请求转发到JSP文件
3. JSP引擎解析JSP文件，将其转换为Servlet
4. Servlet执行，将Model数据渲染到HTML中
5. 最终的HTML响应返回给客户端

下面是一个使用JSTL的JSP示例：

2. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
3. <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
4. <%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
5. <!DOCTYPE html>
6. <html>
7. <head>
8.     <title>User Detail</title>
9. </head>
10. <body>
11.     <h1>User Detail</h1>
12.    
13.     <table border="1">
14.         <tr>
15.             <th>ID</th>
16.             <th>Name</th>
17.             <th>Email</th>
18.             <th>Registration Date</th>
19.         </tr>
20.         <tr>
21.             <td>${user.id}</td>
22.             <td>${user.name}</td>
23.             <td>${user.email}</td>
24.             <td><fmt:formatDate value="${user.registrationDate}" pattern="yyyy-MM-dd"/></td>
25.         </tr>
26.     </table>
27.    
28.     <h2>Orders</h2>
29.     <table border="1">
30.         <tr>
31.             <th>ID</th>
32.             <th>Product</th>
33.             <th>Amount</th>
34.             <th>Date</th>
35.         </tr>
36.         <c:forEach items="${orders}" var="order">
37.             <tr>
38.                 <td>${order.id}</td>
39.                 <td>${order.product}</td>
40.                 <td><fmt:formatNumber value="${order.amount}" type="currency"/></td>
41.                 <td><fmt:formatDate value="${order.date}" pattern="yyyy-MM-dd"/></td>
42.             </tr>
43.         </c:forEach>
44.     </table>
45. </body>
46. </html>

复制代码

Thymeleaf渲染机制

Thymeleaf是一种现代的服务器端Java模板引擎，它强调自然模板的概念，允许模板作为静态原型工作。在Spring MVC中，Thymeleaf的渲染过程如下：

1. ViewResolver将视图名称解析为Thymeleaf模板文件
2. Thymeleaf引擎解析模板文件，构建DOM树
3. Thymeleaf引擎将Model数据与DOM树结合，进行数据绑定和逻辑处理
4. 最终的HTML响应返回给客户端

下面是一个使用Thymeleaf的HTML模板示例：

2. <!DOCTYPE html>
3. <html xmlns:th="http://www.thymeleaf.org">
4. <head>
5.     <title>User Detail</title>
6.     <meta charset="UTF-8"/>
7. </head>
8. <body>
9.     <h1>User Detail</h1>
10.    
11.     <table border="1">
12.         <tr>
13.             <th>ID</th>
14.             <th>Name</th>
15.             <th>Email</th>
16.             <th>Registration Date</th>
17.         </tr>
18.         <tr>
19.             <td th:text="${user.id}">1</td>
20.             <td th:text="${user.name}">John Doe</td>
21.             <td th:text="${user.email}">john@example.com</td>
22.             <td th:text="${#dates.format(user.registrationDate, 'yyyy-MM-dd')}">2023-01-01</td>
23.         </tr>
24.     </table>
25.    
26.     <h2>Orders</h2>
27.     <table border="1">
28.         <tr>
29.             <th>ID</th>
30.             <th>Product</th>
31.             <th>Amount</th>
32.             <th>Date</th>
33.         </tr>
34.         <tr th:each="order : ${orders}">
35.             <td th:text="${order.id}">1</td>
36.             <td th:text="${order.product}">Product A</td>
37.             <td th:text="${#numbers.formatCurrency(order.amount)}">$100.00</td>
38.             <td th:text="${#dates.format(order.date, 'yyyy-MM-dd')}">2023-01-01</td>
39.         </tr>
40.     </table>
41. </body>
42. </html>

复制代码

视图解析与渲染的细节

视图名称解析是ViewResolver的核心功能，下面是一个简化的视图名称解析过程：

2. // InternalResourceViewResolver的简化解析过程
3. public View resolveViewName(String viewName, Locale locale) throws Exception {
4.     // 构建实际视图路径
5.     String path = getPrefix() + viewName + getSuffix();
6.    
7.     // 创建View对象
8.     AbstractUrlBasedView view = buildView(path);
9.    
10.     // 应用其他配置
11.     view.setApplicationContext(getApplicationContext());
12.    
13.     return view;
14. }
16. protected AbstractUrlBasedView buildView(String viewUrl) throws Exception {
17.     // 实例化View类
18.     AbstractUrlBasedView view = (AbstractUrlBasedView) BeanUtils.instantiateClass(getViewClass());
19.    
20.     // 设置URL
21.     view.setUrl(viewUrl);
22.    
23.     // 设置其他属性
24.     if (getContentType() != null) {
25.         view.setContentType(getContentType());
26.     }
27.    
28.     return view;
29. }

复制代码

视图渲染是View的核心功能，下面是一个简化的视图渲染过程：

2. // InternalResourceView的简化渲染过程
3. public void render(Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {
4.     // 暴露Model数据到请求属性中
5.     exposeModelAsRequestAttributes(model, request);
6.    
7.     // 准备请求
8.     prepareRequest(request);
9.    
10.     // 获取请求分发器
11.     RequestDispatcher rd = getRequestDispatcher(request, getUrl());
12.    
13.     // 如果是包含请求，则包含资源
14.     if (useInclude(request, response)) {
15.         response.setContentType(getContentType());
16.         rd.include(request, response);
17.     }
18.     // 否则转发请求
19.     else {
20.         rd.forward(request, response);
21.     }
22. }
24. protected void exposeModelAsRequestAttributes(Map<String, Object> model, HttpServletRequest request) throws Exception {
25.     // 将Model中的数据暴露为请求属性
26.     for (Map.Entry<String, Object> entry : model.entrySet()) {
27.         String modelName = entry.getKey();
28.         Object modelValue = entry.getValue();
29.         if (modelValue != null) {
30.             request.setAttribute(modelName, modelValue);
31.         }
32.     }
33. }

复制代码

在Spring MVC中，我们可以通过返回特定的视图名称来实现重定向和转发：

重定向

2. @RequestMapping("/save")
3. public String saveUser(User user) {
4.     userService.saveUser(user);
5.     // 使用"redirect:"前缀实现重定向
6.     return "redirect:/user/list";
7. }

复制代码

转发

2. @RequestMapping("/process")
3. public String processForm() {
4.     // 使用"forward:"前缀实现转发
5.     return "forward:/user/list";
6. }

复制代码

重定向和转发的区别：

1. 重定向是客户端行为，浏览器地址栏会改变；转发是服务器端行为，浏览器地址栏不会改变
2. 重定向会丢失请求属性；转发会保留请求属性
3. 重定向可以重定向到任意URL；转发只能在同一应用内进行

实战技巧

1. 使用多个ViewResolver处理不同类型的视图

在实际项目中，我们可能需要同时使用多种视图技术，例如使用Thymeleaf处理HTML页面，使用JSP处理报表，使用JSON处理API响应等。这时，我们可以配置多个ViewResolver，并设置它们的优先级：

2. @Configuration
3. @EnableWebMvc
4. public class WebConfig implements WebMvcConfigurer {
5.    
6.     @Bean
7.     public ContentNegotiatingViewResolver contentViewResolver() {
8.         ContentNegotiatingViewResolver resolver = new ContentNegotiatingViewResolver();
9.         
10.         // 设置内容协商策略
11.         ContentNegotiationManager manager = new ContentNegotiationManager(
12.             new HeaderContentNegotiationStrategy(),
13.             new FixedContentNegotiationStrategy(MediaType.TEXT_HTML)
14.         );
15.         resolver.setContentNegotiationManager(manager);
16.         
17.         // 设置默认视图
18.         resolver.setDefaultViews(Arrays.asList(new MappingJackson2JsonView()));
19.         
20.         // 设置ViewResolver列表
21.         List<ViewResolver> resolvers = new ArrayList<>();
22.         resolvers.add(thymeleafViewResolver());
23.         resolvers.add(jspViewResolver());
24.         resolver.setViewResolvers(resolvers);
25.         
26.         return resolver;
27.     }
28.    
29.     @Bean
30.     public ThymeleafViewResolver thymeleafViewResolver(SpringTemplateEngine templateEngine) {
31.         ThymeleafViewResolver resolver = new ThymeleafViewResolver();
32.         resolver.setTemplateEngine(templateEngine);
33.         resolver.setCharacterEncoding("UTF-8");
34.         resolver.setOrder(1);
35.         return resolver;
36.     }
37.    
38.     @Bean
39.     public InternalResourceViewResolver jspViewResolver() {
40.         InternalResourceViewResolver resolver = new InternalResourceViewResolver();
41.         resolver.setPrefix("/WEB-INF/jsp/");
42.         resolver.setSuffix(".jsp");
43.         resolver.setViewClass(JstlView.class);
44.         resolver.setOrder(2);
45.         return resolver;
46.     }
47.    
48.     // 其他Bean定义...
49. }

复制代码

2. 使用ContentNegotiatingViewResolver实现内容协商

ContentNegotiatingViewResolver是Spring MVC提供的一个特殊ViewResolver，它可以根据请求的Accept头、文件扩展名或请求参数来决定使用哪种视图技术：

2. @Configuration
3. @EnableWebMvc
4. public class WebConfig implements WebMvcConfigurer {
5.    
6.     @Bean
7.     public ContentNegotiatingViewResolver contentViewResolver() {
8.         ContentNegotiatingViewResolver resolver = new ContentNegotiatingViewResolver();
9.         
10.         // 设置内容协商策略
11.         ContentNegotiationManager manager = new ContentNegotiationManager(
12.             new HeaderContentNegotiationStrategy(),
13.             new ParameterContentNegotiationStrategy(),
14.             new PathExtensionContentNegotiationStrategy()
15.         );
16.         resolver.setContentNegotiationManager(manager);
17.         
18.         // 设置默认内容类型
19.         resolver.setDefaultContentType(MediaType.APPLICATION_JSON);
20.         
21.         // 设置媒体类型映射
22.         Map<String, MediaType> mediaTypes = new HashMap<>();
23.         mediaTypes.put("html", MediaType.TEXT_HTML);
24.         mediaTypes.put("json", MediaType.APPLICATION_JSON);
25.         mediaTypes.put("xml", MediaType.APPLICATION_XML);
26.         manager.addMediaTypeMappings(mediaTypes);
27.         
28.         // 设置ViewResolver列表
29.         List<ViewResolver> resolvers = new ArrayList<>();
30.         resolvers.add(thymeleafViewResolver());
31.         resolvers.add(jsonViewResolver());
32.         resolvers.add(xmlViewResolver());
33.         resolver.setViewResolvers(resolvers);
34.         
35.         return resolver;
36.     }
37.    
38.     @Bean
39.     public ThymeleafViewResolver thymeleafViewResolver(SpringTemplateEngine templateEngine) {
40.         ThymeleafViewResolver resolver = new ThymeleafViewResolver();
41.         resolver.setTemplateEngine(templateEngine);
42.         resolver.setCharacterEncoding("UTF-8");
43.         resolver.setContentType(MediaType.TEXT_HTML_VALUE);
44.         return resolver;
45.     }
46.    
47.     @Bean
48.     public ViewResolver jsonViewResolver() {
49.         return new ViewResolver() {
50.             @Override
51.             public View resolveViewName(String viewName, Locale locale) throws Exception {
52.                 MappingJackson2JsonView view = new MappingJackson2JsonView();
53.                 view.setPrettyPrint(true);
54.                 return view;
55.             }
56.         };
57.     }
58.    
59.     @Bean
60.     public ViewResolver xmlViewResolver() {
61.         return new ViewResolver() {
62.             @Override
63.             public View resolveViewName(String viewName, Locale locale) throws Exception {
64.                 MarshallingView view = new MarshallingView(jaxb2Marshaller());
65.                 return view;
66.             }
67.         };
68.     }
69.    
70.     @Bean
71.     public Jaxb2Marshaller jaxb2Marshaller() {
72.         Jaxb2Marshaller marshaller = new Jaxb2Marshaller();
73.         marshaller.setPackagesToScan("com.example.model");
74.         return marshaller;
75.     }
76. }

复制代码

3. 使用异常处理器自定义错误页面

在Spring MVC中，我们可以通过@ExceptionHandler和@ControllerAdvice来处理异常并返回自定义的错误页面：

2. @ControllerAdvice
3. public class GlobalExceptionHandler {
4.    
5.     // 处理特定异常
6.     @ExceptionHandler(UserNotFoundException.class)
7.     public ModelAndView handleUserNotFoundException(UserNotFoundException ex) {
8.         ModelAndView mav = new ModelAndView();
9.         mav.addObject("errorMessage", ex.getMessage());
10.         mav.addObject("errorCode", "404");
11.         mav.setViewName("error/404");
12.         return mav;
13.     }
14.    
15.     // 处理所有异常
16.     @ExceptionHandler(Exception.class)
17.     public ModelAndView handleAllExceptions(Exception ex) {
18.         ModelAndView mav = new ModelAndView();
19.         mav.addObject("errorMessage", ex.getMessage());
20.         mav.addObject("errorCode", "500");
21.         mav.setViewName("error/500");
22.         return mav;
23.     }
24. }

复制代码

4. 使用拦截器预处理和后处理Model数据

Spring MVC的拦截器不仅可以用于权限验证、日志记录等，还可以用于预处理和后处理Model数据：

2. public class ModelDataInterceptor implements HandlerInterceptor {
3.    
4.     @Override
5.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
6.         // 在控制器方法执行前执行
7.         return true;
8.     }
9.    
10.     @Override
11.     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView mav) throws Exception {
12.         // 在控制器方法执行后，视图渲染前执行
13.         
14.         if (mav != null) {
15.             // 添加全局数据
16.             mav.addObject("currentTime", new Date());
17.             mav.addObject("applicationName", "Spring MVC Demo");
18.             
19.             // 处理Model数据
20.             Map<String, Object> model = mav.getModel();
21.             for (Map.Entry<String, Object> entry : model.entrySet()) {
22.                 // 对特定数据进行处理
23.                 if (entry.getValue() instanceof String) {
24.                     String value = (String) entry.getValue();
25.                     if (value != null && value.length() > 100) {
26.                         // 截断过长的字符串
27.                         model.put(entry.getKey(), value.substring(0, 100) + "...");
28.                     }
29.                 }
30.             }
31.         }
32.     }
33.    
34.     @Override
35.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
36.         // 在视图渲染后执行
37.     }
38. }

复制代码

然后在配置类中注册拦截器：

2. @Configuration
3. @EnableWebMvc
4. public class WebConfig implements WebMvcConfigurer {
5.    
6.     @Override
7.     public void addInterceptors(InterceptorRegistry registry) {
8.         registry.addInterceptor(new ModelDataInterceptor())
9.                 .addPathPatterns("/**")
10.                 .excludePathPatterns("/static/**");
11.     }
12.    
13.     // 其他配置...
14. }

复制代码

5. 使用Flash属性传递重定向数据

在Spring MVC中，重定向会导致请求属性丢失，但我们可以使用Flash属性在重定向之间传递数据：

2. @Controller
3. @RequestMapping("/user")
4. public class UserController {
5.    
6.     @PostMapping("/save")
7.     public String saveUser(User user, RedirectAttributes redirectAttributes) {
8.         // 保存用户
9.         userService.saveUser(user);
10.         
11.         // 添加Flash属性
12.         redirectAttributes.addFlashAttribute("message", "User saved successfully!");
13.         redirectAttributes.addFlashAttribute("user", user);
14.         
15.         // 重定向到列表页面
16.         return "redirect:/user/list";
17.     }
18.    
19.     @GetMapping("/list")
20.     public String listUsers(Model model) {
21.         // Flash属性会自动添加到Model中
22.         // 不需要额外处理
23.         
24.         // 获取用户列表
25.         List<User> users = userService.getAllUsers();
26.         model.addAttribute("users", users);
27.         
28.         return "user/list";
29.     }
30. }

复制代码

6. 使用自定义视图处理特殊需求

有时，标准的视图技术无法满足特殊需求，这时我们可以自定义视图：

2. public class PdfView extends AbstractView {
3.    
4.     public PdfView() {
5.         setContentType("application/pdf");
6.     }
7.    
8.     @Override
9.     protected void renderMergedOutputModel(Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {
10.         // 设置响应头
11.         response.setContentType(getContentType());
12.         response.setHeader("Content-Disposition", "attachment; filename="report.pdf"");
13.         
14.         // 获取数据
15.         List<User> users = (List<User>) model.get("users");
16.         
17.         // 创建PDF文档
18.         Document document = new Document();
19.         PdfWriter writer = PdfWriter.getInstance(document, response.getOutputStream());
20.         
21.         document.open();
22.         
23.         // 添加标题
24.         Font titleFont = new Font(Font.FontFamily.HELVETICA, 18, Font.BOLD);
25.         Paragraph title = new Paragraph("User Report", titleFont);
26.         title.setAlignment(Element.ALIGN_CENTER);
27.         document.add(title);
28.         
29.         // 添加表格
30.         PdfPTable table = new PdfPTable(3);
31.         table.setWidthPercentage(100);
32.         
33.         // 添加表头
34.         table.addCell(createCell("ID", true));
35.         table.addCell(createCell("Name", true));
36.         table.addCell(createCell("Email", true));
37.         
38.         // 添加数据行
39.         for (User user : users) {
40.             table.addCell(createCell(String.valueOf(user.getId()), false));
41.             table.addCell(createCell(user.getName(), false));
42.             table.addCell(createCell(user.getEmail(), false));
43.         }
44.         
45.         document.add(table);
46.         document.close();
47.         writer.close();
48.     }
49.    
50.     private PdfPCell createCell(String content, boolean isHeader) {
51.         Font font = isHeader ?
52.             new Font(Font.FontFamily.HELVETICA, 12, Font.BOLD) :
53.             new Font(Font.FontFamily.HELVETICA, 10, Font.NORMAL);
54.         
55.         PdfPCell cell = new PdfPCell(new Phrase(content, font));
56.         cell.setHorizontalAlignment(Element.ALIGN_CENTER);
57.         cell.setVerticalAlignment(Element.ALIGN_MIDDLE);
58.         cell.setPadding(5);
59.         
60.         if (isHeader) {
61.             cell.setBackgroundColor(BaseColor.LIGHT_GRAY);
62.         }
63.         
64.         return cell;
65.     }
66. }

复制代码

然后在控制器中使用自定义视图：

2. @Controller
3. @RequestMapping("/report")
4. public class ReportController {
5.    
6.     @Autowired
7.     private UserService userService;
8.    
9.     @GetMapping("/users.pdf")
10.     public View generateUserReport() {
11.         // 创建自定义视图
12.         PdfView view = new PdfView();
13.         
14.         // 准备数据
15.         List<User> users = userService.getAllUsers();
16.         
17.         // 添加静态属性
18.         Map<String, Object> model = new HashMap<>();
19.         model.put("users", users);
20.         view.setAttributesMap(model);
21.         
22.         return view;
23.     }
24. }

复制代码

7. 使用Tiles框架构建复合视图

Apache Tiles是一个模板框架，允许构建可重用的页面组件。在Spring MVC中集成Tiles：

首先，添加Tiles依赖：

2. <dependency>
3.     <groupId>org.apache.tiles</groupId>
4.     <artifactId>tiles-jsp</artifactId>
5.     <version>3.0.8</version>
6. </dependency>

复制代码

然后，配置Tiles：

2. @Configuration
3. @EnableWebMvc
4. @ComponentScan("com.example.controller")
5. public class WebConfig implements WebMvcConfigurer {
6.    
7.     @Bean
8.     public TilesConfigurer tilesConfigurer() {
9.         TilesConfigurer configurer = new TilesConfigurer();
10.         configurer.setDefinitions("/WEB-INF/tiles/tiles-defs.xml");
11.         configurer.setCheckRefresh(true);
12.         return configurer;
13.     }
14.    
15.     @Bean
16.     public TilesViewResolver tilesViewResolver() {
17.         TilesViewResolver resolver = new TilesViewResolver();
18.         resolver.setViewClass(TilesView.class);
19.         return resolver;
20.     }
21.    
22.     // 其他配置...
23. }

复制代码

定义Tiles配置文件（tiles-defs.xml）：

2. <?xml version="1.0" encoding="UTF-8"?>
3. <!DOCTYPE tiles-definitions PUBLIC
4.        "-//Apache Software Foundation//DTD Tiles Configuration 3.0//EN"
5.        "http://tiles.apache.org/dtds/tiles-config_3_0.dtd">
6. <tiles-definitions>
7.    
8.     <!-- 基础模板 -->
9.     <definition name="base" template="/WEB-INF/tiles/layout.jsp">
10.         <put-attribute name="header" value="/WEB-INF/tiles/header.jsp" />
11.         <put-attribute name="menu" value="/WEB-INF/tiles/menu.jsp" />
12.         <put-attribute name="body" value="" />
13.         <put-attribute name="footer" value="/WEB-INF/tiles/footer.jsp" />
14.     </definition>
15.    
16.     <!-- 首页 -->
17.     <definition name="home" extends="base">
18.         <put-attribute name="body" value="/WEB-INF/views/home.jsp" />
19.         <put-attribute name="title" value="Home Page" />
20.     </definition>
21.    
22.     <!-- 用户列表 -->
23.     <definition name="user.list" extends="base">
24.         <put-attribute name="body" value="/WEB-INF/views/user/list.jsp" />
25.         <put-attribute name="title" value="User List" />
26.     </definition>
27.    
28.     <!-- 用户详情 -->
29.     <definition name="user.detail" extends="base">
30.         <put-attribute name="body" value="/WEB-INF/views/user/detail.jsp" />
31.         <put-attribute name="title" value="User Detail" />
32.     </definition>
33.    
34. </tiles-definitions>

复制代码

创建基础模板（layout.jsp）：

2. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
3. <%@ taglib prefix="tiles" uri="http://tiles.apache.org/tags-tiles" %>
4. <!DOCTYPE html>
5. <html>
6. <head>
7.     <title><tiles:getAsString name="title"/></title>
8.     <meta charset="UTF-8"/>
9. </head>
10. <body>
11.     <div id="header">
12.         <tiles:insertAttribute name="header"/>
13.     </div>
14.    
15.     <div id="menu">
16.         <tiles:insertAttribute name="menu"/>
17.     </div>
18.    
19.     <div id="body">
20.         <tiles:insertAttribute name="body"/>
21.     </div>
22.    
23.     <div id="footer">
24.         <tiles:insertAttribute name="footer"/>
25.     </div>
26. </body>
27. </html>

复制代码

最后，在控制器中返回Tiles视图名称：

2. @Controller
3. @RequestMapping("/user")
4. public class UserController {
5.    
6.     @Autowired
7.     private UserService userService;
8.    
9.     @RequestMapping("/list")
10.     public String listUsers(Model model) {
11.         List<User> users = userService.getAllUsers();
12.         model.addAttribute("users", users);
13.         return "user.list";  // 返回Tiles视图名称
14.     }
15.    
16.     @RequestMapping("/detail/{id}")
17.     public String getUserDetail(@PathVariable Long id, Model model) {
18.         User user = userService.getUserById(id);
19.         model.addAttribute("user", user);
20.         return "user.detail";  // 返回Tiles视图名称
21.     }
22. }

复制代码

总结

本文全面解析了Spring MVC中的页面输出技术，从ModelAndView到ViewResolver，详细介绍了数据渲染与页面展示的完整流程及实战技巧。

我们首先了解了ModelAndView的基本概念和使用方式，掌握了如何在控制器中准备数据和指定视图。然后，我们深入探讨了ViewResolver的工作机制，学习了Spring MVC提供的多种ViewResolver实现，以及如何配置和使用它们。

接着，我们详细分析了Spring MVC中的数据渲染与页面展示流程，包括完整的请求处理流程、数据传递与渲染机制，以及视图解析与渲染的细节。最后，我们分享了一些实用的实战技巧，如使用多个ViewResolver处理不同类型的视图、使用ContentNegotiatingViewResolver实现内容协商、使用异常处理器自定义错误页面、使用拦截器预处理和后处理Model数据、使用Flash属性传递重定向数据、使用自定义视图处理特殊需求，以及使用Tiles框架构建复合视图。

通过本文的学习，读者应该能够深入理解Spring MVC的页面输出技术，并能够灵活运用这些技术解决实际开发中的问题。希望本文能够帮助读者在Spring MVC开发中更加得心应手，构建出更加优秀的Web应用。