让你五分钟彻底理解Spring MVC

概述

Sping MVC 正式的名字为 Spring Web MVC，是 Spring Framework 框架中的其中一个模块，基于 Servlet API 构建，同时使用 MVC 的架构模式，主要用以简化传统的 Servlet + JSP 进行 web 开发的工作。

 

MVC 架构模式

Spring MVC 基于 MVC 模式，因此理解 Spring MVC 需要先对 MVC 模式有所了解。

传统 MVC 架构模式

MVC 即 Model-View-Controller 是软件开发中一种常用的架构模式，将软件系统分为三层：模型(Model)、视图(View)、控制器(Controller)，各部分根据职责进行分离，使程序的结构更为直观，增加了程序的可扩展性、可维护性、可复用性。可以用如下的图形来表示三者之间的关系。

• 模型(Model)：模型封装了数据及对数据的操作，可以直接对数据库进行访问，不依赖视图和控制器，也就是说模型并不关注数据如何展示，只负责提供数据。GUI 程序模型中数据的变化一般会通过观察者模式通知视图，而在 web 中则不会这样。
• 视图(View)：视图从模型中拉取数据，只负责展示，没有具体的程序逻辑。
• 控制器(Controller)：控制器用于控制程序的流程，将模型中的数据展示到视图中。

Java Web MVC 架构模式

上世纪 90 年代，随着互联网的发展，基于浏览器的 B/S 模式随之流行，最初浏览器向服务器请求的都是一些静态的资源，如 HTML，CSS 等，为了支持根据用户的请求动态的获取资源，Java 提出了 Servlet 规范。

此时 Servlet 可以说是一个大杂烩，浏览器接收的 HTML 都是通过 Servelt 一行一行的输出，比较繁琐，并且写后端代码的程序员还要熟悉前端技术，为了解决这个问题，sun 公司又借鉴 ASP 提出了 JSP。

JSP 和 HTML 相似，只是在 JSP 文件中可以嵌入 Java 代码，减少了直接使用 Servlet 产生的大量冗余代码。此时 JSP 同时充当模型、视图、控制器的角色，为了解决前后端代码仍然揉在一起的问题，Java Web MVC 模式后来被提出，JavaBean 充当模型、JSP 充当视图，Servlet 充当控制器，流程如下图所示。

浏览器的请求先经过 Servlet，Servlet 控制整个流程，使用 JavaBean 查询并存储数据，然后携带 JavaBean 中的数据到 JSP 页面中，这个就是 Java 中早期的 Web MVC 架构模式了。

Spring MVC 架构模式

Spring MVC 架构模式对 Java Web 中的 MVC 架构模式加以扩展，将控制器拆分为前端控制器 DispatcherServlet 和后端控制器 Controller，将 Model 拆分成业务层(Service) 和数据访问层(Respository)，并且支持不同的视图，如 JSP、FreeMarker 等，设计更为灵活，请求处理流程如下。

浏览器的请求先经过 DispatcherServlet，DispatcherServlet 负责分发请求，因此 DispatcherServlet 又被称为前端控制器。DispatcherServlet 其后的 Controller 又被称为后端控制器，Controller 可以选择性的调用 Service、Repository 实现业务逻辑，DispatcherServlet 拿到 Controller 提供的模型和视图后，进行渲染并返回给浏览器。当然了，这里只是为了方便理解 Spring MVC 描述的大概流程，具体流程会在后文介绍。

 

Hello，Spring MVC

虽然现在 SpringBoot 已经成为主流，但是我仍然想从单纯的 Spring MVC 讲起，因为 SpringBoot 也只是在 Spring Framework 其上添加了一些自动化的配置，这些自动化的配置会让我们忽略背后的技术原理。

几年的 Spring 的教程中都会提出使用 Spring MVC 首先需要去 Spring 官网下载一大堆的依赖，而现在有了 maven 之后再也不必关系这些乱七八糟的依赖及其依赖关系。如果你不了解 maven，建议先去了解 maven 后再回头看下面的内容。

Spring MVC 依赖引入

新建 maven 项目，并引入 Spring MVC 的依赖，注意这里引入的版本号是 5.2.6，Spring Framework 5 开始对 JDK 版本的要求是 1.8 及以上。完整的 pom 内容如下。

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.zzuhkp</groupId>
  <artifactId>mvc-demo</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <maven.compiler.source>1.8</maven.compiler.source>
      <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>

      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-webmvc</artifactId>
          <version>5.2.6.RELEASE</version>
      </dependency>

      <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>javax.servlet-api</artifactId>
          <version>4.0.1</version>
          <scope>provided</scope>
      </dependency>

  </dependencies>

  <build>
      <finalName>mvc-demo</finalName>
  </build>
</project>

DispatcherServlet 声明

传统的 Java Web 项目使用 Servlet 处理请求，Spring MVC 遵循了 Servlet 规范，提供了一个名称为 DispatcherServlet 的 Servlet 类，使用 Spring MVC 需要先声明这个 Servlet。

DispatcherServlet 整合了 IOC 容器，所有处理 Web 请求的组件都存至 IOC 容器中，然后使用这些 bean 处理控制整个请求过程。

有两种声明 DispatcherServlet 的方式，第一种方式是直接在类路径下的/WEB-INF/web.xml文件中配置。

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
        http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
  version="4.0">

  <servlet>
      <servlet-name>dispatcher</servlet-name>
      <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
      <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
      <servlet-name>dispatcher</servlet-name>
      <url-pattern>/</url-pattern>
  </servlet-mapping>

</web-app>

第二种方式基于 Servlet 3.0 提出的 ServletContainerInitializer 接口，Servlet 容器会从类路径中查找实现了这个接口的类，并在启动时回调这个接口中的方法，Spring MVC 已经将这个接口实现为 SpringServletContainerInitializer，在其内部调用了 WebApplicationInitializer 接口完成初始化，因此实现 WebApplicationInitializer 接口再添加 DispatcherServlet 也可以，和上述 xml 等效的 java 代码如下。

public class MvcXmlInitializer implements WebApplicationInitializer {

  @Override
  public void onStartup(ServletContext servletContext) throws ServletException {
      XmlWebApplicationContext context = new XmlWebApplicationContext();
      DispatcherServlet dispatcher = new DispatcherServlet(context);
      Dynamic dynamic = servletContext.addServlet("dispatcher", dispatcher);
      dynamic.addMapping("/");
      dynamic.setLoadOnStartup(1);
  }
}

除了上述用户自定义的 WebApplicationInitializer，Spring 还自定义了一个支持注解配置的抽象实现类 AbstractAnnotationConfigDispatcherServletInitializer，这个类会自动向 Servlet 上下文中注册 DispatcherServlet，实现这个类然后指定配置类即可。

public class MvcAnnotationInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
  @Override
  protected Class<?>[] getRootConfigClasses() {
      return null;
  }

  @Override
  protected Class<?>[] getServletConfigClasses() {
      return new Class[]{MvcConfig.class};
  }

  @Override
  protected String[] getServletMappings() {
      return new String[]{"/"};
  }
}

这里我们使用 web.xml 配置进行演示，我们配置的 DispatcherServlet 声明的映射路径是/，因此，所有的请求都会到达 DispatcherServlet，然后再分派给不同的处理器处理。

Spring 上下文配置

Spring MVC 使用 IOC 容器存储处理请求的组件，包括处理器在内的所有自定义的与 Web 请求有关的组件都需要添加到 Spring 的配置中。

Spring 上下文配置文件指定

DispatcherServlet 初始化时默认使用的容器是 XmlWebApplicationContext，虽然 Spring 预留了扩展点用于修改容器类型，非必要情况下还是建议不要修改，这个容器默认情况下会使用类路径下/WEB-INF/{servlet-name}-servlet.xml文件作为容器的配置文件，我们声明的 DispatcherServlet 名为 dispatcher，因此我们创建/WEB-INF/dispatcher-servlet.xml文件作为容器的配置。另外还可以使用 Servlet 的初始化参数 configLocation 指定 Spring 容器配置文件路径。

  <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/dispatcher-servlet.xml</param-value>
      </init-param>
      <load-on-startup>1</load-on-startup>
  </servlet>

Spring 上下文配置文件内容

Spring 配置文件内容如下。

<?xml version="1.0" encoding="UTF-8"?>
<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">

  <bean id="/hellohandler" class="com.zzuhkp.mvc.handler.HelloSpringMVCHttpRequestHandler"/>
      
</beans>

这里声明了一个类型为 HelloSpringMVCHttpRequestHandler 的 bean，其 id 为请求路径/hellohandler，这个类的定义如下。

public class HelloSpringMVCHttpRequestHandler implements HttpRequestHandler {


  @Override
  public void handleRequest(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      response.getWriter().write("Hello,HelloSpringMVCHttpRequestHandler");
  }

}

这样配置的目的是希望当/hellohandler请求到达时，能够使用我们提供的 HelloSpringMVCHttpRequestHandler 处理请求。

到了这里，将项目发布到 Tomcat，我这里使用的 Tomcat 版本号是 9.0.54，可以看到效果如下。

HandlerMapping 配置

那为什么将处理器的 bean id 配置为请求路径就可以使用这个处理器进行处理呢？Spring MVC 为了灵活的查找处理器内部使用了 HandlerMapping 将请求映射到处理器，Spring 默认情况下会使用BeanNameUrlHandlerMapping映射请求，这个映射器将请求路径作为 id 查找处理器。除了默认情况下使用的这个映射器，我们还可以配置 SimpleUrlHandlerMapping 映射器，和上述等效的 Spring 配置如下。

<?xml version="1.0" encoding="UTF-8"?>
<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">

  <bean id="hellohandler" class="com.zzuhkp.mvc.handler.HelloSpringMVCHttpRequestHandler"/>

  <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
      <property name="urlMap">
          <map>
              <entry key="/hellohandler" value-ref="hellohandler"/>
          </map>
      </property>
  </bean>
  
</beans>

处理器配置

看到这里，细心的小伙伴可能会有疑问，说好的 DispatcherServlet 将请求分派给 Controller 呢？这里暂时不用着急，Controller 其实是 Spring MVC 的处理器类型之一，这里的 HttpRequestHandler 同样是 Spring MVC 的处理器。

Spring 对多种处理器进行了支持，具体则是使用 HandlerAdapter 对处理器进行适配，Spring MVC 内部已经默认了一些适配器，HttpRequestHandler 的适配器是 HttpRequestHandlerAdapter，Controller 的适配器 SimpleControllerHandlerAdapter 也是 Spring MVC 默认支持的。

默认的 HandlerAdapter 已经足够支持日常所需，一般不会自定义 HandlerAdapter。

下面尝试使用 Controller 作为处理器处理请求，定义实现 Controller 接口的 HelloSpringMVCController 类如下。

public class HelloSpringMVCController implements Controller {

  @Override
  public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
      ModelAndView modelAndView = new ModelAndView();
      modelAndView.setViewName("/WEB-INF/view/welcome.jsp");
      modelAndView.addObject("hello", "HelloSpringMVCController");
      return modelAndView;
  }
}

然后在 Spring 配置文件中添加这个类作为 bean。

<bean id="/hellocontroller" class="com.zzuhkp.mvc.handler.HelloSpringMVCController"/>

到了这里，终于可以看到 Controller 了，Controller 处理请求，返回了一个类型为 ModelAndView 的对象。

ModelAndView 包含模型和视图，这里向模型中添加了属性 hello，并且指定了/WEB-INF/view/welcome.jsp 文件作为视图名，这个文件内容如下。

<html>
<body>
<h2>Hello,${requestScope.hello}</h2>
</body>
</html>

启动 Tomcat 访问 /hellocontroller 效果如下。

成功将模型中的数据展示到视图。

ViewResolver 配置

为了支持不同的视图，如 JSP、FreeMarker 等，ModelAndView 中的视图名称被设计成虚拟的，具体的视图由视图解析器 ViewResolver 进行解析，默认情况下使用的视图解析器是 InternalResourceViewResolver ，这个视图解析器基于 URL 解析视图。同时也可以向应用上下文中配置自己的视图解析器。添加自定义的 InternalResourceViewResolver 到 Spring 配置文件。

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

然后设置视图名时就可以忽略路径前缀/WEB-INF/view和后缀.jsp，配置前缀后缀后上述示例中 HelloSpringMVCController 就可以将视图名从 /WEB-INF/view/welcome.jsp 简化为 welcome。

 

DispatcherServlet 组件默认配置

上述示例中使用了不少 DispatcherServlet 使用的组件，Spring MVC 默认情况下已经提供了一些，如果需要自定义，则将自定义的组件添加到上下文配置中接口，十分方便，那么 Spring 默认情况下使用了哪些组件处理请求呢？

spring-webmvc 模块类路径下 org/springframework/web/servlet/DispatcherServlet.properties 文件定义了这些默认的配置，具体如下。

 

基于注解的 Spring WebMVC

基于配置文件的 Spring Web MVC 项目在前些年确实比较流行，然而现在注解已经成为 Spring 开发的主流。下面通过纯注解的方式对上面的示例进行改造。

pom 文件不需要进行变化，首先要提供 Spring 配置类。

@ComponentScan("com.zzuhkp.mvc")
public class MvcConfig {

}

这里只添加了组件扫描能力，Spring 会将给定包下标注了 @Component 的类作为 bean 进行处理。然后将将这个类设置为配置类即可，这里可以参见使用上述提供的 DispatcherServlet 第二种声明方式。

然后提供基于注解的控制器。

@Controller
public class HelloSpringMVCAnnotationController {

  @GetMapping("/helloAnnotationController")
  public String helloMVC(@RequestParam("hello") String hello, Model model) {
      model.addAttribute("hello", hello);
      return "/WEB-INF/view/welcome.jsp";
  }

}

基于注解的控制器不需要实现特定的接口，直接在类上添加 @Controller 注解即可，这里定义了一个处理 /helloAnnotationController 路径 GET 请求方式的方法，并且接收 hello 参数，存放至 model 中，然后返回了视图名。这里直接复用了上面示例中的视图。最终效果如下。

基于注解的控制器是 Spring MVC 中设计最为灵活的地方，这里可以先考虑下，Spring 是怎么适配用户自定义的控制器的？控制器方法中的参数如何赋值呢？如何将控制器方法的返回值解析为视图？Spring 如何支持 RESTFUL 风格的接口的？后面会写几篇文章继续分析。

 

DispatcherServlet 请求处理流程

DispatcherServlet 请求处理流程已经穿插在前面的示例中介绍，直接看前面的描述可能不是很直观，这里总结了一张图来梳理整个流程。

整个流程串联起来如下。

1. DispatcherServlet 处理浏览器发起的请求。
2. DispatcherServlet 根据用户或默认的配置使用 HandlerMapping 查找可处理请求的处理器。
3. DispatcherServlet 拿到 HandlerMapping 返回的处理器链 HandlerExecutionChain。整个处理器链包含拦截器和处理。
4. DispatcherServlet 将处理器适配为 HandlerAdapter。
5. DispatcherServlet 使用拦截器进行请求前置处理。
6. DispatcherServlet 使用处理器进行请求处理。
7. DispatcherServlet 使用拦截器进行请求后置处理。
8. DispatcherServlet 从拦截器或处理器中提取到模型及视图 ModelAndView。
9. DispatcherServlet 使用视图解析器 ViewResolver 解析视图出视图 View。
10. DispatcherServlet 渲染视图，响应请求。

 

结束语

本文先介绍 MVC 架构模式，然后通过示例的方式对 Spring MVC 的使用方式及执行流程进行介绍，最后还使用一个流程图总结。

Spring MVC 中所有的扩展都基于 DispatcherServlet 处理请求的这个流程，可以说理解了这个流程图就理解了 Spring MVC 的原理，后面将会对这个流程进行细化，继续介绍 Spring MVC 的其他内容。

到此这篇关于理解Spring MVC的文章就介绍到这了,更多相关理解Spring MVC内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://blog.csdn.net/zzuhkp/article/details/120685952