SpringMVC：Struts2区别、搭建应用、流程处理、核心控制器

已于 2023-05-07 07:40:35 修改
阅读量341 收藏 3
点赞数
分类专栏： Spring/SpringMVC/MyBatis 文章标签： struts spring java
于 2021-05-26 21:04:27 首次发布
版权所有——燕双嘤
本文链接：https://blog.csdn.net/qq_42192693/article/details/117247051
版权

作为Spring框架的一部分，SpringMVC可以与Spring框架无缝整合。实际上，SpringMVC本身就是基于Spring核心容器的，SpringMVC的控制器天然就处于Spring容器的管理之下，因此Spring可以轻易地将Service组件注入控制器。

SpringMVC已逐渐取代Struts2的地位，成为Java领域最流行的MVC框架，这不仅仅由于它是Spring家族的产品，更由于SpringMVC本身更加简单、易用，而且功能非常强大。SpringMVC的控制器、处理方法都非常简单，通常只需要使用简单的注解修饰它们即可，它们无须实现特定的接口，也无须使用固定的方法签名，使用起来格外方便。

1，MVC概述

1.1，MVC模式极其优势

MVC将应用中的各组件按照功能进行分类，不同的组件使用不同的技术充当，甚至推荐了严格分层，不同的组件被严格限制在其所在的层内，各层之间以松耦合的方式组织在一起，从而提供了良好的封装。

MVC思想和优势：https://shao12138.blog.csdn.net/article/details/113877213#t2

1.2，SpringMVC概述

Spring MVC 是一款优秀的 Java Web 开发框架，具有以下几个好处：

  • 基于MVC的设计模式，将请求、处理和响应分离，让代码更加易于维护和扩展；
  • 支持多种视图技术，如JSP、Freemarker、Velocity等，可以灵活地选择适合自己的视图技术；
  • 易于进行测试和集成，能够轻松地进行针对控制器、业务逻辑和视图的单元测试；
  • 提供了强大的数据绑定、类型转换和校验功能，能够简化数据处理的编写；
  • 整合了Spring的IoC和AOP功能，提供了更加简洁和优雅的开发方式，也能够方便地与其他Spring组件进行整合。

总之，Spring MVC 能够帮助我们更快、更高效地开发 Web 应用程序，提高开发效率和代码质量。

SpringBoot和SpringMVC的区别：

  • 目的不同：Spring MVC是一个Web框架，用于开发Web应用程序；而Spring Boot是一个快速开发框架，用于快速创建和部署Spring应用程序。

  • 配置方式不同：Spring MVC需要手动配置各种组件，如数据源、事务管理、Web安全等；而Spring Boot提供了大量的自动配置，可以根据应用程序的classpath和配置信息，自动配置Spring应用程序所需的各种组件。

  • 依赖管理不同：Spring MVC需要手动管理各种依赖，如Servlet API、JSP API、JSTL等；而Spring Boot自动管理这些依赖，并提供了内嵌的Web服务器，可以快速启动Web应用程序。

  • 构建工具不同：Spring MVC可以使用任何构建工具，如Maven、Gradle等；而Spring Boot推荐使用Maven或Gradle来构建应用程序，并提供了一些特定的插件和依赖，如spring-boot-maven-plugin、spring-boot-starter-parent等。

  • 开发方式不同：Spring MVC需要手动编写大量的配置和代码，如XML配置、Controller、DAO等；而Spring Boot使用约定大于配置的开发方式，可以通过简单的注解和默认配置来快速开发Spring应用程序。

1.3，SpringMVC与Struts2的区别

目前Java领域两大主流的MVC框架就是SpringMVC和Struts 2，一般旧项目用Struts2比较多，但新项目往往用SpringMVC比较多，这说明SpringMVC正在蚕食Struts2的占有率，这也是SpringMVC的有点所致。总体来说，SpringMVC与Struts2存在以下几个区别：

  • 核心控制器区别：SpringMVC的核心控制器是Servlet（DispatcherServlet），而Struts2的核心控制器是Filter（StrutsPrepareAndExecuteFilter）。两者只是实现不同，并无优略之分。
  • 业务控制器区别：SpringMVC的业务控制器在容器中以单例模式应用，所有HTTP请求公用一个业务控制器（Controller）实例——不同的请求对应不同的方法；Struts2的业务控制器则不然，Struts2会针对每个HTTP请求都创建新的业务控制器（Action）实例。这一点，SpringMVC的性能优于Struts2。
  • 处理请求参数的区别：借助IoC容器的强大功能，SpringMVC直接通过方法形参来获取请求参数（只要让方法形参与HTTP请求参数同名即可）；而Struts2则需要定义与请求参数同名的属性（实例变量+getter、setter方法）才能获取请求参数。这一点，SpringMVC完胜Struts2。从开发角度来看，SpringMVC代码简洁，Struts2代码臃肿；从性能角度来看，由于Struts2使用Action的实例变量来封装请求参数，这意味着Struts2必须为每个参数都创建不同的Action实例——否则就会存在线程安全问题；但SpringMVC的控制器可被设计成单例模式。
  • 请求参数支持上的区别：Struts2主要支持的依然是传统的POST、GET请求参数；但SpringMVC可以非常方便地支持各种请求参数，也支持URL路径中的请求参数、矩阵参数等，SpringMVC天生就对RESTful提供了良好支持。在这一点上，SpringMVC完胜Struts2。
  • 设计架构的区别：Struts2采用的是拦截器机制的设计，Struts2既提供了细粒度的拦截器，也允许将细粒度的拦截器组合成粗粒度拦截器栈；SpringMVC则采用了AOP机制设计。从本质上看，拦截器机制与AOP机制基本上殊途同归，二者并没有优略之分。
  • 文本响应区别：SpringMVC只需创建一个@ResponseBody注解，它就会自动处理方法返回的文本对象转换成JSON或XML文档响应，非常简洁；Struts2要么使用Stream二进制流来生成文本响应（非常烦琐），要么使用JSON插件将整个Action实力转换成JSON字符串来作为响应（相对比较简洁）——无论那种方式，SpringMVC都略胜一筹。
  • 配置文件区别：除非Struts2使用了Convention插件，否则Struts2应用必须为每个Action、每个视图映射都提供单独的配置；而SpringMVC除要在***-servlet.xml文件中做一些简单的配置之外，基本上是零配置，因此SpinrgmVC开发更加简洁。

2，SpringMVC入门（IDEA）

2.1，在Web应用中启动Spring容器

由于SpringMVC是一个针对Java Web的MVC框架，因此，首先需要建立一个动态的Java Web应用。步骤如下：

  • 创建Maven项目

  •  填写项目名称，其余默认或者自定义修改

  •  然后得到如下目录，创建一些其他目录

  • 在maven中引入jar包
<!--spring相关-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.9.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>5.2.9.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>5.2.9.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>5.2.9.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.9.RELEASE</version>
</dependency>
  • 在web.xml中配置创建Spring容器
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.1" 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_3_1.xsd">
    <!-- 配置Spring IoC配置文件路径 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/applicationContext.xml</param-value>
    </context-param>
    <!-- 配置ContextLoaderListener用以初始化Spring IoC容器 -->
    <listener>
      <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
</web-app>
  • 创建applicationContext.xml
<?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-4.0.xsd">
</beans>

2.2，配置核心控制器

经过上面的配置，当Web应用启动时，在web.xml文件中配置的ContextLoaderListener会自动创建并初始化Spring容器。但是仅有Spring容器还不够，还必须在web.xml文件中配置Spring提供的核心控制器——该核心控制器负责拦截所有的HTTP请求。SpringMVC的核心控制器是DsipatcherServelt，它就是一个标准的Servlet，因此只要使用标准的Servlet配置语法配置它即可。

  • 在web.xml文件中增加如下配置片段配置DispatcherServlet
<servlet>
    <!-- 注意：Spring MVC框架会根据servlet-name配置，找到/WEB-INF/dispatcher-servlet.xml作为配置文件载入Web工程中 -->
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 使得Dispatcher在服务器启动的时候就初始化 -->
    <load-on-startup>1</load-on-startup>
</servlet>
<!-- Servlet拦截配置 -->
<servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

<!--防止中文乱码-->
<filter>
    <filter-name>characterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
    <init-param>
        <param-name>forceEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

上面配置片段在Web应用中配置了DispatcherServlet，它主要完成两个功能：

  • 负责拦截HTTP请求，此处将它拦截的URL配置成“/”，这意味着它会拦截所有的请求。
  • 负责初始化另一个Spring容器。

当使用Spring与SpringMVC开发Web应用时，默认会存在两个Spring容器，其中ContextLoaderListener初始化的Spring容器是“根容器”，DispatcherServlet初始化的是“Servlet容器”。主要区别是：

  • ROOT容器主要负责配置、管理应用中的Service组件、DAO组件等后端组件。
  • Servlet容器主要负责配置、管理应用中的Controller组件、视图解析器、HandlerMapping组件等——主要管理MVC相关的组件，当程序在Servlet容器中找不到某个Bean时，Spring会自动到Root容器中继续查找。

DispatcherServlet初始化的Spring容器会自动部署默认的视图解析器、HandlerMapping等组件，ContextLoaderListenrer初始化的Spring容器则不会。如果只想初始化一个Spring容器，这是允许的，程序可去掉ContextLoadeListener的配置，这样Web应用启动时就不会初始化ROOT容器了。此外，也可让DispatcherServlet直接使用ContextLoaderListener加载Root容器，但不推荐只初始化一个Spring容器的方式，因为这种方式意味着控制器与后端容器混合成一个容器，不利于项目维护。

DispatcherServlet也要初始化Spring容器，其对应的配置文件在默认情况下，会以<servletname>-servlet.xml作为Spring容器的配置文件，其中<servletname>代表配置DispatcherServlet时指定的名字。比如上面配置片段中配置DispatcherServlet时指定的servlet-name为springmvc，这意味着它会以springmvc-servlet.xml作为Spring容器的配置文件。

  • 为了让该项目正常启动，在WEB-INF目录下增加一个springmvc-servlet.xml配置文件，该文件的代码如下：
<?xml version='1.0' encoding='UTF-8' ?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
       http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">
    <!-- 使用注解驱动 -->
    <mvc:annotation-driven />
    <!-- 定义扫描装载的包 -->
    <context:component-scan base-package="com.ysy.springmvc.Controller" />
</beans>

如果不想使用默认的<servletname>-servlet.xml作为Spring配置文件，也可以为DispatcherServlet配置一个contextConfigLocation参数，该参数用于为SpringMVC的Servlet容器指定配置文件。

<servlet>
    <!-- 注意：Spring MVC框架会根据servlet-name配置，找到/WEB-INF/dispatcher-servlet.xml作为配置文件载入Web工程中 -->
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 使得Dispatcher在服务器启动的时候就初始化 -->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>WEB-INF/actionContext.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>

至此，SpringMVC应用所需的两个Spring容器（Root容器和Servlet容器）都已配置完成，接下来即可为该引用开发控制器、Service组件了。

2.3，开发控制器

开发SpringMVC的控制器非常简单，只要留意以下三点：

  • 控制器类使用@Controller注解修饰。
  • 处理方法使用@RequestMapping注解修饰。@RequestMapping注解有@GetMapping、@PostMapping、@PutMapping、@DeleteMapping和@PatchMapping几个变体，它们的功能几乎相同，只不过后面几个变体注解专门处理GET、POST、PUT、DELETE、PATCH请求。
  • 处理方法为每个请求参数定义同名的形参。
@Controller
public class UserController {
    @Resource(name = "userService")
    private UserService userService;

    @PostMapping("/login")
    public String login(String username, String pass, Model model) {
        if (userService.userLogin(username,pass)>0){
            model.addAttribute("tip","欢迎您，登录成功!");
            return "/WEB-INF/content/success.jsp";
        }
        model.addAttribute("tip","对不起，您输入的用户名、密码不正确！");
        return "/WEB-INF/content/error.jsp";
    }
}

上面程序中定义了一个login()方法——该方法名是什么无关紧要，关键在于两点：

  • 该方法使用了@PostMapping("/login")修饰，因此，该方法会负责处理提交给/login的POST请求。
  • 该方法定义了username和pass两个形参，程序可以在该方法中通过这两个形参访问username、pass请求参数。

SpringMVC的控制器Bean是无状态的，它没有使用实例变量来封装请求参数，而是通过方法形参来获取请求参数的，这样的控制器就可以被设计成单例模式。

login()方法还定义了一个Model类型的参数，Model其实就是一个类似于Map的接口（addAttribute()方法就类似于Map的put()方法），程序只要向该Model添加属性，这些属性自动传递给下一个处理结点（可能是视图页面也可能是处理方法）。

由于上面的控制器类已经使用了@Controller修饰，因此Spring会自动识别并在容器中配置该Bean——对于Spring容器来说，一切都是Bean，控制器也自然是Bean。另外还使用了@Resource修饰了userService成员变量，这表明Spring会将容器中id为userService的Bean赋值给该成员变量，userService是业务逻辑组件。

public class UserService {
    public Integer userLogin(String username, String pass) {
        if (username.equals("ysy")&&pass.equals("123456")){
            return 1;
        }
        return 0;
    }
}

由于上面的UserService并为使用@Service注解修饰，因此需要在applicationContext.xml文件中注入

<bean id="userService" class="com.ysy.springmvc.Service.UserService"/>

2.4，提供视图资源

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<html>
<body>
<h2>Hello World!</h2>
<form action="/login.do" method="post">
    <input type="text" name="username"/><br>
    <input type="password" name="pass"/><br>
    <input type="submit" value="登录"/>
</form>
</body>
</html>
--------------------------------------
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    ${tip}
</body>
</html>

3，SpringMVC的流程

3.1，SpringMVC应用的开发步骤

【步骤一】在web.xml文件中配置核心控制器DispatcherServlet处理所有的HTTP请求。由于Web应用是基于请求/响应架构的，所以不管使用哪种MVC Web框架，都需要在web.xml文件中配置该框架的核心Servlet或Filter。

<servlet>
    <!-- 注意：Spring MVC框架会根据servlet-name配置，找到/WEB-INF/dispatcher-servlet.xml作为配置文件载入Web工程中 -->
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 使得Dispatcher在服务器启动的时候就初始化 -->
    <load-on-startup>1</load-on-startup>
</servlet>
<!-- Servlet拦截配置 -->
<servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>*.do</url-pattern>
</servlet-mapping>

【步骤二】如果需要以POST方式提交请求，则定义包含表单数据的视图页面，将该表单的action属性指定为请求提交的地址。

（1）如果是以GET方式发送请求，则无须经过这一步只需定义一个超链接，将该链接的href属性指定为请求提交的地址即可。

（2）如果以异步方式提交请求（比如jQuery、Vue等），则需要使用JS编写提交请求脚本。

【步骤三】定义处理请求的控制类，该类通常需要使用@Controller注解修饰。这一步是所有MVC框架中必不可少的，因为这个控制器类就是MVC中的C，它负责调用后端Service组件的方法来处理HTTP请求。

【问题】Controller并不能直接接收HTTP请求，为什么能处理请求HTTP请求呢？

MVC框架的底层机制是当核心控制器（DispatcherServlet）接收到HTTP请求后，通常会对该请求进行简单的预处理，例如解析、封装参数等，然后通过反射来创建Controller实例，并调用Controller的指定方法（由@RequestMapping注解或其变体修饰的方法）来处理请求。

【问题】当DispatcherServlet拦截HTTP请求后，它如何知道创建哪个控制器的实例呢？

（1）利用XML配置文件。比如Struts2或Spring2.5之前的SpringMVC框架，都要求在XML文件中配置/abc请求对应与调用哪个类的那个方法，这样就可以让MVC框架知道要创建那个控制器的实例了。

（2）利用注解。现在的SpringMVC只要使用@Controller修饰控制器类，并使用@RequestMapping或其变体修饰处理方法，即可让MVC框架知道创建哪个控制器的实例，并调用哪个方法来处理用户请求。

在SpringMVC框架中，控制器实际上由两部分组成，即：拦截所有HTTP请求和处理请求的通用代码都由核心控制器DispatcherServlet完成，而实际的业务控制（诸如调用Service组件的方法、返回处理结果等）则由自定义的Controller处理——因此，Comtroller也被称为业务控制器。

【步骤四】配置控制器类。也就是配置某个请求由哪个类的哪个方法负责处理。

现在的SpringMVC只要使用@Controller修饰控制器类，并使用@RequestMapping注解或其变体修饰处理方法即可。

@Controller
public class UserController {
    @Resource(name = "userService")
    private UserService userService;

    @PostMapping("/login")
    public String login(String username, String pass, Model model) {
        if (userService.userLogin(username,pass)>0){
            model.addAttribute("tip","欢迎您，登录成功!");
            return "/WEB-INF/content/success.jsp";
        }
        model.addAttribute("tip","对不起，您输入的用户名、密码不正确！");
        return "/WEB-INF/content/error.jsp";
    }
}

【步骤五】定义视图解析器。

SpringMVC控制器的出来方法总是返回一个String对象，该String对象通常并不是具体的视图资源，因此还需要视图解析器负责解析String对象与视图资源之间的对应关系。

SpringMVC还允许使用ModelAndView作为控制器处理方法的返回值（这也是早期SpringMVC遗留的问题），ModelAndView其实就是Model和View，其中Model用于封装传递给下一个处理结点的数据，而View（其实就是一个String对象）就相当于处理方法所返回的字符串。

【问题】为什么前面的示例中没有配置视图解析器呢？

这样是SpringMVC框架的优秀所在，当开发者没有配置任何视图解析器时，SpringMVC会提供默认的、最基础的视图解析机制。

一般来说程序没必要为每个控制器都配置单独的视图解析器，一个视图解析器通常可以为一批控制器提供视图功能。

【步骤六】提供视图资源。

当控制器处理用户请求结束后，通常返回一个String对象（或ModelAndView对象）作为逻辑视图名，视图解析器会根据该String对象解析到具体的物理视图资源，因此还需要提供对应的物理视图资源。

如果控制器需要将数据传递给视图资源，则通常建议在处理方法中增加一个Model类型的参数，并将这些数据添加成Model对象的属性；如果采用SpringMVC早期的风格，让处理方法返回ModelAndView对象，则也可以将这些数据添加成ModelAndView对象的属性。

3.2，SpringMVC的运行流程

SpringMVC的开发步骤实际上是按“请求——响应”的流程进行。

  • 用户通过浏览器向Web应用发送请求，该请求由部署在web.xml文件中的DispatcherServlet负责处理。 
  • 当DispatcherServlet接收到请求时，它会通过容器的一个或多个HandlerMapping对象来处理该URL。HandlerMapping对象也是部署在Spring容器中的Bean，它实现了HandlerMapping接口来获取对应的Handler。
  • HandlerMapping（HandlerMapping负责将请求的URL映射到对应的Handler）对象会根据URL返回对应的Handler对象。（Handler是对控制器中特定方法的包装，由于SpringMVC的Controller可以包含很多个处理方法，因此它的每个处理方法都能被包装成Handler）
  • HandlerAdapter在准备调用Handler（控制器的特定方法）之前，会先对请求参数进行一定处理（通过HttpMessageConverter），主要包括：消息转换（JSON、XML等数据转换成对象，将对象转换成指定格式的响应数据等）、数据转换（将String转换成Integer、Double等）、数据校验（校验数据的有效性，将校验的结果存储到BindingResult或Error中）。
  • 当控制器处理完请求后，会将逻辑视图名和Model返回给DispatcherServlet。Model也包含了控制器要传递给视图进行显示的数据。
  • 当DispatcherServlet接收到视图名后，它会通过容器中的一个或多个ViewResolver（视图解析器）来处理该视图名。
  • 视图解析器会根据视图名返回视图对象。（视图解析器负责根据视图名确定对应视图）
  • 当DispatcherServlet确定了实际要呈现的视图之后，它就会将Model数据也传递给对应的视图。
  • 视图则负责呈现数据，并生成最终的响应。
  • 最后由DispatcherServlet将最终的响应呈现给用户。

SpringMVC的运行流程中涉及的核心组件：

  • DispatcherServlet：核心控制器，由Spring框架提供，开发者需要在web.xml文件中配置它。
  • HandlerMapping：负责将请求URL映射到对应的Handler。开发者可能可能需要选择、配置合适的HandlerMapping类。
  • Controller：控制器，开发者需要定义Controller类，并使用合适的注解修饰该类及其处理方法。
  • HandlerAdapter：它负责在调用Controller之前对请求参数进行一些前置处理，通常不需要开发者关心。
  • ViewResolver：视图解析器，它负责根据视图名确定对应的视图资源。开发者可能需要选择、配置合适的视图解析器。
  • View：视图资源。开发者需要编写视图页面。

3.3、核心控制器（DispatcherServlet）

DispatcherServlet源代码包括如下片段：

protected void initStrategies(ApplicationContext context) {
    //初始化文件上传解析器
    this.initMultipartResolver(context);
    //初始化国际化解析器
    this.initLocaleResolver(context);
    //初始化主题解析器
    this.initThemeResolver(context);
    //初始化HandlerMapping对象
    this.initHandlerMappings(context);
    //初始化HandlerAdapters对象
    this.initHandlerAdapters(context);
    //初始化处理器异常解析器
    this.initHandlerExceptionResolvers(context);
    //初始化视图名解析器
    this.initRequestToViewNameTranslator(context);
    //初始化视图解析器
    this.initViewResolvers(context);
    //初始化FlaashMap管理器
    this.initFlashMapManager(context);
}

initStragies()方法会在WebApplicationContext初始化后自动执行，它会自动扫描Spring容器中所有的Bean，根据它们的名称或类型来查找上面这些特殊的Bean，如果没找到，DispatcherServlet会为这些特殊的Bean装配到一起。

特殊的Bean解释
HandlerMapping将请求URL映射到对应的Handler，目前的主流实现是基于注解的映射实现。
HandlerAdapter主要用于帮助DispatcherServlet调用控制器（Adapter），其主要作用就是对DispatcherServlet屏蔽控制器的各种细节。
HandlerExceptionResolver主要作用就是将异常映射到视图。
ViewResolver将逻辑视图名（String对象）解析到实际视图（View对象）。

LocaleResovler

LocaleContextResolver

用于解析客户端正在使用的语言、区域设置及所在的时区，以便应用呈现国际化界面。
ThemeResolver解析Web应用程序可以使用的主体，例如，提供个性化布局。
MultipartResolver解析multi-part请求，主要用于支持对HTML表单的文件上传。
FlashMapManager负责存储和检索从一个请求传递到另一个请求的“input”和“output”属性。

在spring-webmvc-<版本号>.RELEASE.jar文件的org\springframework\web\servlet路径下有一个DispatcherServlet.properties配置文件，该文件指定了这些特殊的Bean的默认实现：

# Default implementation classes for DispatcherServlet's strategy interfaces.
# Used as fallback when no matching beans are found in the DispatcherServlet context.
# Not meant to be customized by application developers.
# 定义默认的国际化解析器实现类
org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver
# 定义默认的主题解析器实现类
org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver
# 定义默认的HandlerMapping解析器实现类(2个)
org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping,\
	org.springframework.web.servlet.function.support.RouterFunctionMapping
# 定义默认的HandlerAdapter解析器实现类(3个)
org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
	org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter,\
	org.springframework.web.servlet.function.support.HandlerFunctionAdapter
# 定义默认的处理器异常解析器实现类(2个)
org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver,\
	org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\
	org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver
# 定义默认的视图名解析器实现类
org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator
# 定义默认的视图解析器实现类
org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver
# 定义默认的FlashMap管理器实现类
org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager

这些特殊的Bean有些只允许有一个实例，比如文件上传解析器MultipartResolver、国际化解析器LocaleResovler等；有些允许有多个实例，如HandlerMapping、处理器适配器HandlerAdapter等。

如果存在多个同一类型的组件，那么如果确定它们的优先级呢？由于这些组件都实现了org.springframework.core.Ordered接口，因此可以通过它们重写getOrder()方法的返回值来确定优先级，getOrder()方法的返回值越小优先级越高。

如果将DispatcherServlet的配置文件设置为null，DispatcherServlet将不会使用单独的容器，而是直接使用Root容器作为Servlet，此时整个应用只有一个Spring容器。

下面web.xml配置文件示范了这种配置：

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.1" 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_3_1.xsd">
  <!-- 配置Spring IoC配置文件路径 -->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/WEB-INF/applicationContext.xml</param-value>
  </context-param>
  <!-- 配置ContextLoaderListener用以初始化Spring IoC容器 -->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!-- 配置DispatcherServlet -->
  <servlet>
    <!-- 注意：Spring MVC框架会根据servlet-name配置，找到/WEB-INF/dispatcher-servlet.xml作为配置文件载入Web工程中 -->
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 使得Dispatcher在服务器启动的时候就初始化 -->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value></param-value>
    </init-param>
  </servlet>
  <!-- Servlet拦截配置 -->
  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>
</web-app>

上面将contextConfigLocation参数设置为null，这样SpringMVC将直接使用Root容器作为Servlet容器，因此需要在Root容器对应的配置文件中进行SpringMVC相关配置。

<?xml version='1.0' encoding='UTF-8' ?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
       http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">
    <!-- 使用注解驱动 -->
    <mvc:annotation-driven />
    <!-- 定义扫描装载的包 -->
    <context:component-scan base-package="com.ysy.springmvc.Controller" />
    <bean id="userService" class="com.ysy.springmvc.Service.UserService"/>
</beans>

3.4，<mvc:annotation-driven />

<mvc:annotation-driven />（注解驱动）元素是为容器开启SpringMVC功能的快捷配置，如果为DispatcherServlet提供了单独的配置文件，则在该文件中添加该元素；如果DispatcherServlet没有单独的配置文件，则直接在Root容器的配置文件中添加该元素。

<mvc:annotation-driven />在容器中配置了如下三个特殊的Bean：

  • andlerMapping：使用RequestMappingHandlerMapping作为该特殊的Bean的实现类。
  • HandlerAdapter：使用RequestMappingHandlerAdapter作为该特殊的Bean的实现类。
  • HandlerExceptionResolver：使用ExceptionHandlerExceptionResolver作为该特殊的实现类。

此外，它除支持用于数据绑定的PropertyEditor之外，还通过ConversionService实例提供了Spring 3风格的类型转换功能：

  • 借助ConversionService的支持，可以使用@NumberFormat注解对Number类型的字段进行格式化。
  • 借助ConversionService的支持，可以使用@DateTimeFormat注解对Date、Calendar、Long和Joda Time类型的字段进行格式化。
  • 如果应用本身支持JSR 303校验机制，则可对控制器通过@Valid执行输入校验。
  • 注册一些列HttpMessaageConverter，支持对@RequestBody注解修饰的方法参数和@ResponseBody注解修饰的方法返回值进行转换。

HttpMessageConverter组件的主要有如下两个作用：

  • 将HTTP请求数据（如JSON或XML数据）转换成符合控制器的处理方法要求的参数。
  • 当控制器的处理方法处理结束后，该方法的返回值转换成JSON或XML数据。

HttpMessageConverter只是一个接口，Spring为之提供了大量的实现类，<mvc:annotation-driven />设置了如下HttpMessageConverter实现类的实例：

  • ByteArrayHttpMessageConverter：用于处理字节数组数据的转换。
  • StringHttpMessageConverter：用于处理字符串数据的转换。
  • ResourceHttpMessageConverter：完成目标类型与javax.xml.transform.Source类型之间的转换。
  • FormHttpMessageConverter：完成表单数据与MultiValueMap<String,String>对象之间的转换。
  • Jaxb2RootElementHttpMessageConverter：完成Java对象与XML消息之间的转换。

MappingJackson2XMLHttpMessageConverter：完成Java对象与XML消息之间的转换。当类路径下存在Jackson XML2时才注册该转换器。

  • MappingJackson2HttpMessageConverter：完成Java对象与JSON数据之间的转换。当类加载路径下存在Jackson2时才注册该转换器。
  • AtomFeedHttpMessageConverter：完成Atom feed与Java对象之间的转换。当类加载路径下存在Rome时才注册该转换器。
  • RssChannelHttpMessageConverter：完成RSS feed与Java对象之间的转换。当类加载路径下存在Rome时才注册该转换器。
燕双嘤
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
springmvc和struts2比较
John的博客
03-19 401
springmvc流程图；struts2访问调用流程图：依照上图，我们可以看出一个请求在struts的处理大概有如下步骤：客户端初始化一个指向Servlet容器（例如Tomcat）的请求；这个请求经过一系列的过滤器（Filter）（这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器，这个过滤器对于Struts2和其他框架的集成很有帮助，例如：SiteMesh Plugin）...
Struts2和SpringMvc的区别
Cash Blog
04-16 751
1、拦截级别 Struts2是类级别的拦截， 一个类对应一个request上下文，SpringMVC是方法级别的拦截，一个方法对应一个request上下文，而方法同时又跟一个url对应,所以说从架构本身上SpringMVC就容易实现restful url,而struts2的架构实现起来要费劲，因为Struts2中Action的一个方法可以对应一个url，而其类属性却被所有方法共享，这也就无法用...
Spring mvc与Struts 2的区别
回首一辈子
02-20 121
Spring mvc与Struts 2的区别：     Struts 2的核心是个过滤器（StrutsPreparedAndExcuteFilter ）,而Spring mvc的核心是个servlet(DispatcherServlet);     Struts2是基于类开发的，传递的参数是通过类的属性传递(属性驱动和模型驱动),所以只能设计成多例, SpringMvc是基于类中的方法开发的，也...
Struts2与springMVC区别总结
u013051301的博客
07-01 258
项目框架由Struts2转SpringMVC，总结了下两者区别 1、Struts2 核心是一个Filter StrutsPreparedAndExcuteFilter SpringMVC是Servlet DispatcherServlet 控制请求分发 2、 Struts是基于类开发，参数传递通过类属性， 每次请求实例化一次action，set注入req数据...
Spring MVC原理及流程 springMVC与struts2
weixin_45491031的博客
03-06 209
SpringMVC执行流程: 1.用户发送请求至前端控制器DispatcherServlet 2.DispatcherServlet收到请求调用处理器映射器HandlerMapping。 3.处理器映射器根据请求url找到具体的处理器，生成处理器执行链HandlerExecutionChain(包括处理器对象和处理器拦截器)一并返回给DispatcherServlet。 4.Dispatcher...
maven+(springmvc,mybatis,struts2,hibernate)两两整合
04-19
5. Struts2： Struts2是基于MVC设计模式的Action驱动的Web框架，它简化了企业级Java Web应用的开发。整合Struts2与MyBatis或Hibernate时，Struts2的动作类（Action）接收请求并调用Service层，Service层再通过...
Struts2,JSF,SpringMVC快速入门Demo
02-13
SpringMVC以其简单、灵活、可扩展性著称，它将请求映射到控制器，控制器处理请求后，通过模型对象返回数据，最后由视图负责展示。SpringMVC的核心组件包括DispatcherServlet、Controller、Model、View和ViewResolver...
ssm配置及struts文件，拦截器.zip
06-07
拦截器是Struts2的核心特性之一，它们是围绕Action执行的一系列拦截动作，可以在请求到达Action之前或之后进行预处理和后处理。自定义拦截器可以实现如日志记录、权限验证、性能统计等多种功能。通过在struts.xml中...
八、SpringMVC
08-04
SpringMVC和Struts2都是基于MVC架构的Web应用程序框架，但它们的运行流程有所不同。SpringMVC的运行流程主要包括以下几个步骤： 1. 客户端请求：客户端发送请求到服务器。 2. DispatcherServlet：DispatcherServlet...
SpringMVC是Spring家族的一款专注于解决控制器层问题的框架技术，学习资料第一天
最新发布
10-29
在项目中，SpringMVC可以替代Struts2框架的功能，并且开发效率更高。SpringMVC天生提倡注解式开发。 二、控制器层解决的问题分析 控制器层解决的问题主要包括： * 接收客户端请求参数 * 进行数据类型的转换 * ...
springmvc与struts2使用总结
内心宁静，心如止水
07-25 527
对比的写下struts2与springmvc，这两个web框架 1.在web项目中的web.xml中配置与简单开发struts2中<!-- 引入struts核心过滤器 --> <filter> <filter-name>struts2</filter-name> <filter-class>org.apache.struts2.dispatcher.ng.f
SpringMVC 之六（运行流程、与 Spring 整合及与 Struts2 对比）
CoderJay
01-11 162
18、SpringMVC 运行流程 存在对应的映射的情况： 由 HandlerMapping 获取 HandlerExecutionChain 对象，即由 RequestMappingHandlerMapping 获取 HandlerExcutionChain 对象 获取 HandlerAdapter（RequestMappingHandlerAdapter）对象 调用拦截器的 PreHandler 方法 调用目标 Handler 的目标方法得到 ModelAndView 对象 调用拦截器的
Spring整合Struts2方式一：让Spring容器管理控制器
confirmAname的专栏
08-08 935
web.xml : <web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java
java之路—— 带你了解Struts与其基本的应用
m0_68987535的博客
06-29 1257
创作不易，各位亲给个免费的呗 文章目录前言一、什么是Struts，可以用来干嘛二、Struts 与 springmvc三、Struts的开发的基本步骤四、Struts的处理流程 前言 Struts是在2000年由Apache软件基金会首次发布的，自那时以来，它在Java Web开发中扮演着重要的角色，并经历了许多值得注意的发展阶段。 Struts 1.x：Struts的最初版本是Struts 1.x系列，它引入了MVC架构模式，提供了基本的控制器（Action）和视图（JSP）的分离。Struts
MVC框架及Struts2介绍
Winston_D的博客
11-21 1020
MVC框架及Struts2介绍 Struts2核心 Struts2拦截器 Struts2值栈和OGNL表达式 Struts2标签库1 框架1.1 框架  框架(Framework)：指为解决一个特定问题而设计的具有一定约束性的结构。框架强调的是软件的设计重用性和系统的可扩充性，以缩短大型应用软件系统的开发周期，提高开发质量。一个好的框架必定是某个领域的最佳实践。   最佳实践(Bes
SpringMVC 、Struts2之间的区别
03-01 5362
一、Spring与SpringMVC的区别： spring是一个开源框架，是为了解决企业应用程序开发，功能如下： 功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能 范围：任何Java应用 Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。 1、轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是...
SpringMVC与Struts2的对比
热门推荐
许立峰的专栏
11-29 21万+
下面这些东西基本都是我从网上粘贴过来的，没有那么多耐心和时间一个字一个字的敲了，但是基本能表明我选择SpringMVC的思路和原因。 把这张图放在这里，我是想说SpringMVC和Struts2真的是不一样的，虽然在都有着核心分发器等相同的功能组件（这些由MVC模式本身决定的）。   为什么SpringMVC会赢得最后的胜利呢？谈几点我自己的看法：   第一、MVC框架的出现是为
Java Struts2 框架入门详解（一）MVC架构详解以及Struts基本概述
FENG_LIN的博客
12-18 2782
Apache Struts 2 是一个简洁的，可扩展的框架，它用来创建企业级的 Java web 应用程序。框架的目的是随着时间的积累从构建，部署，维护应用程序上简化整个开发周期。Apache Struts 2 最初被称为 WebWork 2。
Struts2实现MVC（概念解析）
a_good_programer的博客
09-07 3962
框架简述 什么是框架:框架就是能完成一定基础功能的半成品软件。在没有框架时，所有的工作都要从最底层做起；但是有了框架后，它可以为我们提供一定的基础功能，我们就可以在框架的基础上进行开发，而无需自己去实现那些底层的基础功能，大大提高了开发的效率和质量
SpringMVC教程：快速入门与环境搭建
"SpringMVC案例，包括快速入门的丰富示例和环境搭建指南，注释详细解释" 在本文中，我们将深入探讨Spring MVC，这是一个由Spring框架提供的用于构建Web应用程序的Model-View-Controller（MVC）架构。Spring MVC允许...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值