Spring学习笔记(3)一SpringMVC快速入门和基本流程

末蓝、 2022-09-20 15:02 171阅读 0赞

学习技术方面由浅入深的层次步骤：

了解：入门,如何去使用这门技术  
掌握：具体,它的原理是什么  
熟悉：规则实践,在理解原理的基础上，如何去模仿，  
精通：解决问题  
专家：觉悟,扩展创新,如何去进一步演化

# 一、[SpringMVC ][SpringMVC]框架 #

--------------------

[spring][]是一个轻型容器(light-weight [Container][])，其核心是Bean工厂(Bean Factory)，用以构造我们所需要的M(Model)。在此基础之上，Spring提供了AOP（Aspect-Oriented Programming, 面向层面的编程）的实现，用它来提供非管理环境下申明方式的事务、安全等服务；对Bean工厂的扩展ApplicationContext更加方便我们实现J2EE的应用；DAO/ORM的实现方便我们进行[数据库][Link 1]的开发；Web MVC和Spring Web提供了[Java][] Web应用的框架或与其他流行的Web框架进行集成。

1)开源框架  
2)IoC（控制反转）,将类的创建和依赖关系写在配置文件里，由配置文件注入，实现了松耦合  
3)AOP 将安全，事务等于程序逻辑相对独立的功能抽取出来，利用spring的配置文件将这些功能插进去，实现了按照方面编程，提高了复用性

springmvc是spring框架的一个模块，springmvc和spring无需通过中间整合层进行整合。  
springmvc是一个基于mvc的web框架。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hndWlzdQ_size_16_color_FFFFFF_t_70][]

Spring MVC框架根据不同的角色定义了很多接口,但是它最大的问题也是依赖于Servlet API

**Spring MVC Framework有这样一些特点:**  
1、它是基于组件技术的.全部的应用对象,无论控制器和视图,还是业务对象之类的都是java组件.并且和Spring提供的其他基础结构紧密集成.  
2、不依赖于Servlet API(目标虽是如此,但是在实现的时候确实是依赖于Servlet的)  
3、可以任意使用各种视图技术,而不仅仅局限于JSP  
4、支持各种请求资源的映射策略  
5、它应是易于扩展的

SpringMVC属于Spring Framework的后续产品，已经融合到Spring Web Flow中。SpringMVC基于Model2而实现，利用处理器分离了模型对象、视图、控制，达到了松散耦合的效果，提高了系统的可重用性、可维护性以及可扩展性。其功能与Struts类似，只是实现原理和方式上有所不同。

优点：

*  使用简单，学习成本低
 *  功能强大，很容易写出性能优秀的程序
 *  十分灵活，并且可与Spring无缝衔接

# 二、SpringMVC入门1:Controller使用注解 #

--------------------

使用maven创建SpringMCV工程就很简单，可以使用IDE插件来创建。

项目整体结构：

## 1、.SpringMvc POM依赖： ##

在项目的pom.xml导入Spring MVC的Maven依赖

<?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/maven-v4_0_0.xsd ">
    
    	<modelVersion>4.0.0</modelVersion>
    
    	<groupId>demo.springmvc.test</groupId>
    	<artifactId>demo-springmvc-test</artifactId>
    	<packaging>war</packaging>
    	<version>1.0-SNAPSHOT</version>
    	<name>demo-springmvc-test</name>
    	
    	<dependencies>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>4.2.4.RELEASE</version>
        </dependency>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-webmvc</artifactId>
          <version>4.2.4.RELEASE</version>
        </dependency>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-web</artifactId>
          <version>4.2.4.RELEASE</version>
        </dependency>
      </dependencies>
    	
    </project>

## 3 配置web.xml ##

在web.xml中主要配置的是前端控制器，前端控制器的作用是：通过用户的url请求路径查找到匹配该请求的handler，在将用户的请求交由相应的handler处理。

<?xml version="1.0" encoding="UTF-8"?>
    <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
    		 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    		 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
    	http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
    
    	
    	<context-param>
    		<param-name>contextConfigLocation</param-name>
    		<param-value>classpath:applicationContext.xml</param-value>
    	</context-param>
    	
    	
    	<servlet>
    		<servlet-name>apiserver</servlet-name>
    		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    		
    		
    		<load-on-startup>1</load-on-startup>
    	</servlet>
    
    
    	<servlet-mapping>
    		<servlet-name>apiserver</servlet-name>
    		<url-pattern>/apiserver/*</url-pattern>
    	</servlet-mapping>
    
    </web-app>

根据<servlet-name>servlet.xml的配置，查找HandlerMapping

init-param面对应的参数名和值，是给servlet在初始化执行init()方法的时候(servlet有doGet doPost 在这之前还有init()方法 )。  
可以dao在init()方法里调用这个参数的值，如：System.out.println(this.getInitParameter("param1")); 就会输出这个servlet里 打印init-name 名为"param1"的值。

配置说明

*  DispathcerServlet是Spring MVC提供的核心控制器，这是一个Servlet程序，该Servlet会接收所有请求。
 *  核心控制器会读取一个springmvc.xml配置，加载Spring MVC的核心配置。
 *  <url-pattern>配置/apiserver/\*，代表只拦截/apiserver/\*的请求，可以进行更改。
 *  <load-on-startup>代表在项目启动时实例化DispathcerServlet，如果没有配置，则在第一次访问Servlet时进行实例化。

## 4、apiserver-serlet.xml的配置 ##

即在默认路径下，springmvc的配置文件的名字格式是 <servlet-name>-servlet.xml.  因为是在默认路径下，所以web.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:p="http://www.springframework.org/schema/p"
           xmlns:mvc="http://www.springframework.org/schema/mvc"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:util="http://www.springframework.org/schema/util"
           xmlns:aop="http://www.springframework.org/schema/aop"
           xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd
    		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
    		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
    		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
    		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.2.xsd">
    
        
        <context:component-scan base-package="com.demo" />
        
        <bean
                class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/WEB-INF/"></property>
            <property name="suffix" value=".jsp"></property>
        </bean>
    
    </beans>

## 5. 控制代码 ##

在SpringMVC 中提供了一个非常简便的定义Controller 的方法，你无需继承特定的类或实现特定的接口，只需使用@Controller 标记一个类是Controller ，然后使用@RequestMapping 和@RequestParam 等一些注解用以定义URL 请求和Controller 方法之间的映射，这样的Controller 就能被外界访问到。

@Controller 是标记在类UserController上面的，所以类UserController就是一个SpringMVC Controller 对象了。@RequestMapping(“/user”) 标记在UserController类上，表示当请求\*/user/\* 的时候访问的是UserController的相关方法。  
@RequestMapping(“/abc”) 标记在UserController类方法test上，该方法返回了一个String对象。

package com.demo.springmvc.controller;
    
    import org.springframework.web.bind.annotation.*;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    
    @Controller
    @RequestMapping("/user")
    public class UserController {
        @RequestMapping("/")
        @ResponseBody
        public String index() {
            return "Hello world";
        }
        @RequestMapping("/abc")
        @ResponseBody
        public String test() {
            System.out.println("------------TestController-----------");
            return "Hello test";
        }
    }

## 6. 打包访问传到tomcat运行： ##

maven:mvn clean package

> Maven打包web项目报错Error assembling WAR: webxml attribute is required (or pre-existing WEB-INF/web.xml if
> 
> **原因分析**：maven的web项目默认的webroot是在src\\main\\webapp。如果在此目录下找不到web.xml就抛出以上的异常。
> 
> **解决办法**：1、将webroot修改为webapp   2、在pom.xml中指定web.xml，如下：
> 
>     <build>
>             <plugins>
>                 <plugin>
>                     <artifactId>maven-war-plugin</artifactId>
>                     
>                         
>                     
>                 </plugin>
>             </plugins>
>         </build>
> 
>

#  #

把项目部署到Tomcat，war包名为：demo-springmvc-test.war ，然后启动或者重启Tomcat运行项目：

![20200705142452893.png][]

![20200705142522346.png][]

# 三、SpringMVC入门2:实现Controller接口 #

--------------------

通过实现org.springframework.web.servlet.mvc.Controller接口，这种配置比较繁杂，而且一个url只能对应一个controller。

其实类似直接使用HttpServlet接口。

## 1、在web.xml里面配置DispatcherServlet： ##

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

## 2、配置处理器映射 ##

apiserver2-servlet.xml的文件是用来配置处理器映射、控制器的定义、视图解析器等。URL处理映射的方式有三种

**1) BeanNameUrlHandlerMapping：通过url名字，找到对应的bean的name的控制器**

2). SimpleUrlHandlerMapping 【简单得URL处理映射】 通过key找到bean的id的控制器

<bean  name="demoController"  class="com.demo.springmvc.controller.DemoController"></bean>
        <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
            <property name="mappings">
                <props>
                    <prop key="/demo2.do">demoController</prop>
                    <prop key="/demo3.do">demoController</prop>
                </props>
            </property>
    </bean>

3). ControllerClassNameHandlerMapping 【控制器的类名处理映射】 不用配置访问路径，默认的访问路径就是类名首字母大写变小写，加.do后缀

## **3、代码实现Controller接口** ##

package com.demo.springmvc.controller;
    
    
    import org.springframework.web.servlet.ModelAndView;
    import org.springframework.web.servlet.mvc.Controller;
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    public class DemoController implements Controller {
        @Override
        public ModelAndView handleRequest(HttpServletRequest arg0, HttpServletResponse response) throws Exception {
            ModelAndView mav = new ModelAndView("demo");
            response.setCharacterEncoding("utf-8");
            response.setContentType("text/html");
            mav.addObject("message", "spring MVC");
            return mav;
        }
    }

## **4)、**src\\main\\webapp\\WEB-INF\\**demo.jsp页面:** ##

<%@ page contentType="text/html; charset=UTF-8"%>
    <body>
    message：${message}
    </body>

## **5)、打包部署测试** ##

**三种**URL处理映射的方式分别打三个包：demo1.war, demo2.war, demo3.war, 部署到tomcat访问：

![20200707120158744.png][]

![20200707121218120.png][]

![20200707121431515.png][]

> jsp页面中文乱码：
> 
> ![20200707111811102.png][]
> 
> 在jsp页面指定第一行指定JSP页面编码采用UTF-8
> 
>     <%@ page language="java" pageEncoding="UTF-8"%>
>     <body>
>     这是一个demo示例：：${message}
>     </body>
> 
> 刷新后：
> 
> ![20200707111957900.png][]
> 
>

# 四、SpringMVC框架基本流程 #

--------------------

SpringMVC框架主要由四个接口组成：  
1）、DispatcherServlet前端控制器、  
2）、HandlerMapping请求处理器映射器、  
3）、Controller、  
4）、ViewResolver

## 1、工作流程 ##

**1）、启动流程：**

当web程序启动的时候,ContextLoaderServlet会把对应的配置文件信息读取出来,通过注射去初始化控制器DispatchServlet.

<servlet>
       <servlet-name>apiserver</servlet-name>
       <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
       
          
          
       
       <load-on-startup>1</load-on-startup>
    </servlet>

**2、处理请求流程（我们使用接口的流程来说明）**

1)、请求提交给DispatcherServlet：  
       将客户端请求http://localhost:8080/demo1/demo1.do，首先被在web.xml中配置的前端控制器DispatcherServlet拦截到。

2)、根据<servlet-name>servlet.xml的配置，查找HandlerMapping：  
       在apiserver2-servlet.xml中查找能执行demo1.do请求的映射处理器，若发现没有能处理此请求的映射处理器，这时便使用默认的映射处理器BeanNameUrlHandlerMapping。我们还需注意：这种后端控制器的bean Name必须以“/”开头，并且要结合DispatcherServlet的映射配置。同时beanName支持通配符配置。比如如果配置：<bean name="/d\*.do" class="com.demo.springmvc.controller.DemoController" /> 时，当访问demo.do时也可以成功访问到DemoController类。

3)、HandlerMapping根据请求URL找到处理请求的具体Controller(Handler)  
      BeanNameUrlHandlerMapping处理器,会查找在spring容器中是否在名为“demo1.do”的bean实例。当查找到此实例后，则把此bean作为处理此请求的后端控制器。同时把自身加到映射处理器链上，并向处理器链传递此请求。

4)、后端控制器进行处理：  
      DispatcherServletd调用处理器适配器去执行Controller，Controller调用业务逻辑处理（DispatchServlet会在调用选定的Controller的handlerRequest方法）

5)、处理完成之后，返回ModelAndView对象给DispatcherServlet  
       框架通过ViewResolver找到负责显示的具体View  
       由View的render方法将结果渲染到客户端

#  #

# 五、常用注解 #

--------------------

*  @Controller：声明Action组件，负责注册bean到Spring上下文
 *  @RequestMapping：用于为控制器指定可以处理的url请求
 *  @RequestParam：用于指定参数的name属性
 *  @RequestBody：用于读取Request请求的body部分数据
 *  @ResponseBody：用于将控制器方法返回的对象写入到Response对象的body数据区
 *  @PathVariable：用于指定url作为参数
 *  @Resource用于注入，( 由j2ee提供 ) 默认按名称装配
 *  @Autowired用于注入，(由spring提供) 默认按类型装配
 *  @ExceptionHandler：用于异常处理的方法
 *  @ControllerAdvice：用于使控制器成为全局的异常处理类
 *  @ModelAttribute：用于优先调用被注解的方法，或注解参数中的隐藏对象

## 1、@RequestMapping注解 ##

使用@RequestMapping注解来映射Request 请求与处理器：

可以使用@RequestMapping 来映射URL到控制器类，或者是到Controller 控制器的处理方法上。当@RequestMapping 标记在Controller 类上的时候，里面使用@RequestMapping 标记的方法的请求地址都是相对于类上的@RequestMapping 而言的；当Controller 类上没有标记@RequestMapping 注解时，方法上的@RequestMapping 都是绝对路径。这种绝对路径和相对路径所组合成的最终路径都是相对于根路径“/ ”而言的。

## 2、使用 @RequestParam 绑定 HttpServletRequest 请求参数到控制器方法参数 ##

@RequestMapping ( "requestParam" )  
    public String testRequestParam( @RequestParam(required=false) String name, @RequestParam ( "age" ) int age) {  
       return "requestParam" ;  
    }

在上面代码中利用@RequestParam 从HttpServletRequest 中绑定了参数name 到控制器方法参数name ，绑定了参数age 到控制器方法参数age 。值得注意的是和@PathVariable 一样，当你没有明确指定从request 中取哪个参数时，Spring 在代码是debug 编译的情况下会默认取更方法参数同名的参数，如果不是debug 编译的就会报错。此外，当需要从request 中绑定的参数和方法的参数名不相同的时候，也需要在@RequestParam 中明确指出是要绑定哪个参数。在上面的代码中如果我访问/requestParam.do?name=hello&age=1 则Spring 将会把request请求参数name 的值hello 赋给对应的处理方法参数name ，把参数age 的值1 赋给对应的处理方法参数age 。

在@RequestParam 中除了指定绑定哪个参数的属性value 之外，还有一个属性required ，它表示所指定的参数是否必须在request 属性中存在，默认是true ，表示必须存在，当不存在时就会报错。在上面代码中我们指定了参数name 的required 的属性为false ，而没有指定age 的required 属性，这时候如果我们访问/requestParam.do而没有传递参数的时候，系统就会抛出异常，因为age 参数是必须存在的，而我们没有指定。而如果我们访问/requestParam.do?age=1 的时候就可以正常访问，因为我们传递了必须的参数age ，而参数name 是非必须的，不传递也可以。

## 3、使用 @CookieValue 绑定 cookie 的值到 Controller 方法参数 ##

public String testCookieValue( @CookieValue ( "hello" ) String cookieValue, @CookieValue String hello) {  
       System. out .println(cookieValue + "-----------" + hello);  
       return "cookieValue" ;  
    }

在上面的代码中我们使用@CookieValue 绑定了cookie 的值到方法参数上。上面一共绑定了两个参数，一个是明确指定要绑定的是名称为hello 的cookie 的值，一个是没有指定。使用没有指定的形式的规则和@PathVariable、@RequestParam 的规则是一样的，即在debug 编译模式下将自动获取跟方法参数名同名的cookie 值。

## 4、使用 @RequestHeader 注解绑定 HttpServletRequest 头信息到Controller 方法参数 ##

@RequestMapping ( "testRequestHeader" )  
    public String testRequestHeader( @RequestHeader ( "Host" ) String hostAddr, @RequestHeader String Host, @RequestHeader String host ) {  
        System. out .println(hostAddr + "-----" + Host + "-----" + host );  
        return "requestHeader" ;  
    }

在上面的代码中我们使用了 @RequestHeader 绑定了 HttpServletRequest 请求头 host 到Controller 的方法参数。上面方法的三个参数都将会赋予同一个值，由此我们可以知道在绑定请求头参数到方法参数的时候规则和 @PathVariable 、 @RequestParam 以及 @CookieValue 是一样的，即没有指定绑定哪个参数到方法参数的时候，在 debug 编译模式下将使用方法参数名作为需要绑定的参数。但是有一点 @RequestHeader 跟另外三种绑定方式是不一样的，那就是在使用 @RequestHeader 的时候是大小写不敏感的，即 @RequestHeader(“Host”) 和 @RequestHeader(“host”) 绑定的都是Host 头信息。记住在 @PathVariable 、 @RequestParam 和 @CookieValue 中都是大小写敏感的。

##  5、@RequestMapping 的一些高级应用 ##

在RequestMapping 中除了指定请求路径 value  属性外，还有其他的属性可以指定，如params 、method 和headers 。这样属性都可以用于缩小请求的映射范围。

method 属性主要是用于限制能够访问的方法类型的  
@RequestMapping (value= "testMethod" , method=\{RequestMethod. GET , RequestMethod. DELETE \})

params 属性用于指定请求参数的  
@RequestMapping (value= "testParams" , params=\{ "param1=value1" , "param2" , "!param3" \})

使用headers 属性可以通过请求头信息来缩小@RequestMapping 的映射范围。  
@RequestMapping (value= "testHeaders" , headers=\{ "host=localhost" , "Accept" \})

# 六、Struts2和SpringMVC的区别 #

--------------------

## 一)、框架机制 ##

1、Struts2采用Filter（StrutsPrepareAndExecuteFilter）实现，SpringMVC（DispatcherServlet）则采用Servlet实现。  
2、Filter在容器启动之后即初始化；服务停止以后坠毁，晚于Servlet。Servlet在是在调用时初始化，先于Filter调用，服务停止后销毁。

##    二)、拦截机制 ##

1、Struts2  
a、Struts2框架是类级别的拦截，每次请求就会创建一个Action，和Spring整合时Struts2的ActionBean注入作用域是原型模式prototype（否则会出现线程并发问题），然后通过setter，getter吧request数据注入到属性。  
b、Struts2中，一个Action对应一个request，response上下文，在接收参数时，可以通过属性接收，这说明属性参数是让多个方法共享的。  
c、Struts2中Action的一个方法可以对应一个url，而其类属性却被所有方法共享，这也就无法用注解或其他方式标识其所属方法了  
   
2、SpringMVC  
a、SpringMVC是方法级别的拦截，一个方法对应一个Request上下文，所以方法直接基本上是独立的，独享request，response数据。而每个方法同时又何一个url对应，参数的传递是直接注入到方法中的，是方法所独有的。处理结果通过ModeMap返回给框架。  
b、在Spring整合时，SpringMVC的Controller Bean默认单例模式Singleton，所以默认对所有的请求，只会创建一个Controller，有应为没有共享的属性，所以是线程安全的，如果要改变默认的作用域，需要添加@Scope注解修改。

##    三)、性能方面 ##

SpringMVC实现了零配置，由于SpringMVC基于方法的拦截，有加载一次单例模式bean注入。而Struts2是类级别的拦截，每次请求对应实例一个新的Action，需要加载所有的属性值注入，所以，SpringMVC开发效率和性能高于Struts2。

##    四)、拦截机制 ##

Struts2有自己的拦截Interceptor机制，SpringMVC这是用的是独立的Aop方式，这样导致Struts2的配置文件量还是比SpringMVC大。

##    五)、配置方面 ##

spring MVC和Spring是无缝的。从这个项目的管理和安全上也比Struts2高（当然Struts2也可以通过不同的目录结构和相关配置做到SpringMVC一样的效果，但是需要xml配置的地方不少）。  
SpringMVC可以认为已经100%零配置。

##    六)、设计思想 ##

Struts2更加符合OOP的编程思想， SpringMVC就比较谨慎，在servlet上扩展。

##    七)、集成方面 ##

SpringMVC集成了Ajax，使用非常方便，只需一个注解@ResponseBody就可以实现，然后直接返回响应文本即可，而Struts2拦截器集成了Ajax，在Action中处理时一般必须安装插件或者自己写代码集成进去，使用起来也相对不方便。

==============================================

Struts2是一个基于MVC设计模式的Web应用框架，它本质上相当于一个Servlet。在MVC设计模式中，Struts2作为控制器(Controller)来建立模型与视图的数据交互。Struts2是Struts的下一代产品，是在Struts1和WebWork的技术基础上进行了合并的全新的Struts2框架。其全新的Struts2的体系结构与Struts1的体系结构差别巨大。Struts2以WebWork为核心，采用拦截器的机制来处理用户的请求，这样的设计也使得业务逻辑控制器能够与ServletAPI完全脱离开，所以Struts2可以理解为WebWork的更新产品。虽然从Struts1到Struts2有着太大的变化，但是相对于WebWork，Struts2的变化很小。

Struts2在其流行的几年可谓是非常热门，不管你去哪个公司面试**，都要求会SSH（Spring+Struts2+Hibernate）**，这里的SS指的是Spring和Struts2。但是现在，曾经风靡一时的Struts2最终被SpringMVC所取代，为什么会是这样的结果呢？如果你做了五年以上的开发了，那肯定是接触过Struts2，你一定会知道Struts2的配置文件可谓是最头疼的，如果项目大了，那Servlet和配置会让人疯掉。另外，Struts还有一个通病就是他的请求是基于类的，而SpringMVC是基于方法的，请求域的范围不一样，相比之下SpringMVC要灵活得多。

随着Spring快速的发展，使用SpringMVC的人也会随之增多。从另外一个角度来看，SpringBoot大家都很熟悉吧，零XML配置，全部采用JavaBean的形式，为什么SpringBoot能够快速的代替SpringMVC的xml配置呢，就是因为他减去了xml的配置，使维护起来更加方便。Struts2相比之下则显得十分臃肿，配置项太多。

如果说SpringMVC是初步淘汰了Struts2，那么SpringBoot的崛起基本上是彻底淘汰了Struts2，除了一些老项目还在维护之外，其他的新项目基本上都在用SpringBoot，谁也不想去用一个维护复杂，配置众多的项目。

**这里列出几点：**

1.Struts2的安全漏洞不胜枚举，曾经传言京东数据泄漏就是Struts2搞的鬼。

2.Struts2就是一个Web控制器框架，个人感觉最不好的一点就是，对post、get参数并没有区分对待，天然不支持RESTful API，导致xss攻击的更难防御。

3.Struts2对每一个Web请求，都会创建一个Action实例，耗时耗资源。

4.对于高并发业务，传统Web容器tomcat通常是顶不住的，很多团队会自己开发异步、并行、高性能网络通信引擎，这时候Struts2通常就会比较鸡肋了，一般会根据自身业务特点自行开发控制器框架。

5.Spring MVC和Spring是无缝的。从这个项目的管理和安全上也比Struts2高（当然Struts2也可以通过不同的目录结构和相关配置做到SpringMVC一样的效果，但是需要xml配置的地方不少）。

6.由于Struts2需要针对每个request进行封装，把request，session等servlet生命周期的变量封装成一个一个Map，供给每个Action使用，并保证线程安全，所以在原则上，是比较耗费内存的。

7.SpringMVC开发效率和性能高于Struts2。

......

最后总结来说，业务适合的框架才是好框架啦，Struts2被淘汰还是因为SpringMVC框架太厉害了。

"随着年龄的增长，人总会变得越来越宽容，很多事情到最后并不是真的解决了，而是【算了吧】。"

你要去做一个大人，不要回头，不要难过

[SpringMVC]: http://blog.csdn.net/pineapple0/article/details/40888153
[spring]: http://lib.csdn.net/base/javaee
[Container]: http://lib.csdn.net/base/docker
[Link 1]: http://lib.csdn.net/base/mysql
[Java]: http://lib.csdn.net/base/java
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hndWlzdQ_size_16_color_FFFFFF_t_70]: /images/20220828/3dccb8b23f5d499c910cba2031aa3352.png
[20200705142452893.png]: /images/20220828/454e5935411248968d46669141a362d9.png
[20200705142522346.png]: /images/20220828/8fd8c65a62f1485dbad8dac2105db9c1.png
[20200707120158744.png]: /images/20220828/e2c12881f783463aa7b0f750ea0c9aa5.png
[20200707121218120.png]: /images/20220828/9283b01555484e0bb3ae4027f7d791f4.png
[20200707121431515.png]: /images/20220828/137484d7cf4f4219918e761ecb04183a.png
[20200707111811102.png]: /images/20220828/ee02cc259c2c49d396ed0afc8b986953.png
[20200707111957900.png]: /images/20220828/c84b6fc001ac4ca0a046a20af9364a1e.png