👩🏻‍🚀博客主页：十八岁讨厌编程
📖所属专栏：SpringMVC专栏
🌌写文目的：记录学习中的知识点
🛕目前已更新内容涵盖：🔥【前端】、🔥【后端】、🔥【人工智能】、🔥【数据分析】、🔥【网络爬虫】、🔥【数据结构与算法】、🔥【PS】、🔥【计算机数学】等几个大方面
如果这篇文章对你有帮助，欢迎❤️关注、👍🏻点赞、🤞🏻收藏、👏🏻留言，看到我会积极回复。

文章目录

SpringMVC概述
MVC设计模式
SpringMVC入门案例
案例工作流程解析
- 启动服务器初始化过程
- 单次请求过程
Tomcat是如何加载Spring和SpringMVC的？
Spring和SpringMVC的容器问题

SpringMVC概述

SpringMVC是隶属于Spring框架的一部分，主要是用来进行Web开发，是对Servlet进行了封装。

一定要注意：

三层架构和MVC是两个东西，他们没有什么必然关系。

MVC是一种设计模式。MVC指MVC模式的某种框架，它强制性地使应用程序的输入、处理和输出分开。使用MVC应用程序被分成三个核心部件：模型、视图、控制器。它们各自处理自己的任务。最典型的MVC就是JSP + servlet + javabean的模式。

三层架构是为了实现高内聚低耦合而提出的软件架构，也就是我们在项目中常说的数据持久层、业务逻辑层、表现层。

MVC 是在三层架构的基础上设计的一种框架型架构，三层架构是一种宏观的概念，而 MVC 就是一种比较具体的三层架构的框架实现。

之所以我们会混淆，是因为在进行web开发时两者会同时使用。
1：在三层架构设计中，表现层可由MVC设计模式中的视图（view）和控制器（controller）来实现，而业务逻辑层和数据访问层则组成MVC设计模式中的模型的实现(model)。
2：因此，在实际的应用中，都是采用三层架构来搭建系统的框架，而表示层与业务逻辑层和数据访问层的交互则是通过MVC设计模式来实现。

如果还是存有疑惑，可以参考以下文章：
SSM，三层结构，MVC三者的说明及关系

我们先来回顾下现在web程序是如何做的，咱们现在web程序大都基于三层架构来实现。

浏览器发送一个请求给后端服务器，后端服务器现在是使用Servlet来接收请求和数据
如果所有的处理都交给Servlet来处理的话，所有的东西都耦合在一起，对后期的维护和扩展极为不利
将后端服务器Servlet拆分成三层(也就是三层架构)，分别是web、service和dao
- web层主要由servlet来处理，负责页面请求和数据的收集以及响应结果给前端
- service层主要负责业务逻辑的处理
- dao层主要负责数据的增删改查操作
servlet处理请求和数据的时候，存在的问题是一个servlet只能处理一种请求
针对web层进行了优化，采用了MVC设计模式，将其设计为controller、view和model
- controller负责请求和数据的接收，接收后将其转发给service进行业务处理
- service根据需要会调用dao对数据进行增删改查
- dao把数据处理完后将结果交给service,service再交给controller
- controller根据需求组装成model和view,model和view组合起来生成页面转发给前端浏览器
- 这样做的好处就是controller可以处理多个请求，并对请求进行分发，执行不同的业务操作。

MVC设计模式

MVC设计模式：Model-View-Controller简写

MVC是软件工程中的一种软件架构模式，它是一种分离业务逻辑与显示界面的设计方法，它把软件系统分为三个基本部分：模型（model）、视图（view）、控制器（controller）

控制器 controller：对请求进行处理，负责请求转发，也就是事件，用于流程的控制；

视图view：界面设计人员进行图形界面设计，也就是GUI组件，用于数据的展示；

模型model：编写程序应用功能（实现算法等等），数据库管理，也就是实体类。用于数据的封装和数据的传输；

模型model分为两类：

数据承载bean，数据承载bean是指实体类专门承载业务数据的，比如Student，User
业务承载bean，业务处理bean是指Service或者Dao对象，专门处理用户的请求的。

MVC框架的工作流程：

用户通过View页面向服务端提出请求，可以是表单请求、超链接请求、AJAX请求等。
服务端Controller控制器接收到请求后对请求进行解析，找到相应的Model对用户请求进行处理。
Model处理后，将处理结果再交给Controller
Controller在接到处理结果后，根据处理结果找到要作为向客户端发回的响应View页面。页面经渲染（数据填充）后，再发送给客户端

最典型的MVC就是我们的JSP + Servlet + javabean的模式:

随着互联网的发展，上面的模式因为是同步调用，性能慢慢的跟不是需求，所以异步调用慢慢的走到了前台，是现在比较流行的一种处理方式。

因为是异步调用，所以后端不需要返回view视图，将其去除
前端如果通过异步调用的方式进行交互，后台就需要将返回的数据转换成json格式进行返回
SpringMVC主要负责的就是
- controller如何接收请求和数据
- 如何将请求和数据转发给业务层
- 如何将响应数据转换成json发回到前端

我们也可以这么表示后端的三层服务架构：

我们的数据层本来是使用JDBC技术，现在可以被Mybatis框架取代
我们的表现层本来是使用Servlet技术，现在可以使用SpringMVC替代

介绍了这么多，对SpringMVC进行一个定义

SpringMVC是一种基于Java实现MVC模型的轻量级Web框架
优点
- 使用简单、开发便捷(相比于Servlet)
- 灵活性强

我们可以简单地从代码量上去体会他的强大，实现相同的功能：

不使用SpringMVC框架：

使用SpringMVC框架：

SpringMVC入门案例

因为SpringMVC是一个Web框架，将来是要替换Servlet,所以先来回顾下以前

Servlet是如何进行开发的?

1.创建web工程(Maven结构)

2.设置tomcat服务器，加载web工程(tomcat插件)

3.导入坐标(Servlet)

4.定义处理请求的功能类(UserServlet)

5.设置请求映射(配置映射关系)

SpringMVC的制作过程和上述流程几乎是一致的，具体的实现流程是什么?

1.创建web工程(Maven结构)

2.设置tomcat服务器，加载web工程(tomcat插件)

3.导入坐标(SpringMVC+Servlet)

4.定义处理请求的功能类(UserController)

5.设置请求映射(配置映射关系)

6.将SpringMVC设定加载到Tomcat容器中

步骤实现

步骤1：首先创建一个maven项目
步骤2:补全目录结构
步骤3：导入jar包：

<?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.nefu</groupId>
  <artifactId>SpringMVC_try</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <dependencies>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.1</version>
        <configuration>
          <port>80</port>
          <path>/</path>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

说明:servlet的坐标为什么需要添加<scope>provided</scope>?

scope是maven中jar包依赖作用范围的描述，
如果不设置默认是compile在在编译、运行、测试时均有效
如果运行有效的话就会和tomcat中的servlet-api包发生冲突，导致启动报错
provided代表的是该包只在编译和测试的时候用，运行的时候无效直接使用tomcat中的，就避免冲突

步骤4:创建配置类

@Configuration
@ComponentScan("com.nefu.controller")
public class SpringMvcConfig {
}

步骤5:创建Controller类

@Controller
public class UserController {
    
    @RequestMapping("/save")
    public void save(){
        System.out.println("user save ...");
    }
}

步骤6:使用配置类替换web.xml

将web.xml删除，换成ServletContainersInitConfig

public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
    //加载springmvc配置类
    protected WebApplicationContext createServletApplicationContext() {
        //初始化WebApplicationContext对象
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        //加载指定配置类
        ctx.register(SpringMvcConfig.class);
        return ctx;
    }

    //设置由springmvc控制器处理的请求映射路径
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    //加载spring配置类
    protected WebApplicationContext createRootApplicationContext() {
        return null;
    }
}

配置完这些之后如果直接使用tomcat运行时会报错的，因为后台没有指定返回的页面(但是我们可以在控制台看到user save ...)

我们可以修改Controller返回值解决上述问题：

前面我们说过现在主要的是前端发送异步请求，后台响应json数据，所以接下来我们把Controller类的save方法进行修改

@Controller
public class UserController {
    
    @RequestMapping("/save")
    public String save(){
        System.out.println("user save ...");
        return "{'info':'springmvc'}";
    }
}

再次重启tomcat服务器，然后重新通过浏览器测试访问,会发现还是会报错，这次的错是404。出错的原因是，如果方法直接返回字符串，springmvc会把字符串当成页面的名称在项目中进行查找返回，因为不存在对应返回值名称的页面，所以会报404错误，找不到资源。

而我们其实是想要直接返回的是json数据，具体如何修改呢?

那么设置返回数据为json：

@Controller
public class UserController {
    
    @RequestMapping("/save")
    @ResponseBody
    public String save(){
        System.out.println("user save ...");
        return "{'info':'springmvc'}";
    }
}

再次运行tomcat：

成功！

案例注意点

注意事项：

SpringMVC是基于Spring的，在pom.xml只导入了spring-webmvcjar包的原因是它会自动依赖spring相关坐标
AbstractDispatcherServletInitializer类是SpringMVC提供的快速初始化Web3.0容器的抽象类
AbstractDispatcherServletInitializer提供了三个接口方法供用户实现
- createServletApplicationContext方法，创建Servlet容器时，加载SpringMVC对应的bean并放入WebApplicationContext对象范围中，而WebApplicationContext的作用范围为ServletContext范围，即整个web容器范围
- getServletMappings方法，设定SpringMVC对应的请求映射路径，即SpringMVC拦截哪些请求
- createRootApplicationContext方法，如果创建Servlet容器时需要加载非SpringMVC对应的bean,使用当前方法进行，使用方式和createServletApplicationContext相同。
- createServletApplicationContext用来加载SpringMVC环境
- createRootApplicationContext用来加载Spring环境

此处可知初始化servlet容器的时候，也会对SpringMVC，Spring进行初始化、加载。

WebApplicationContext是专门为web应用准备的,他允许从相对于web根目录的路径中装载配置文件完成初始化工作，从WebApplicationContext中可以获得ServletContext的引用，整个Web应用上下文对象将作为属性放置在ServletContext中，以便web应用可以访问spring上下文。

ServletContext介绍:
JavaEE标准规定：在项目启动时，Servlet容器（Tomcat、Jboss等）需要给项目初始化一个ServletContext作为公共环境容器存放公共信息，而ServletContext中的信息都是由容器提供的。
一般来说，一个 Web 应用会有多个 Servlet ，而它们的 ServletContext 则是共用的一个。这个是由 Servlet 容器（如 Tomcat 、 Jetty ）来决定。
因此Servlet对象之间可以通过ServletContext对象来实现通讯。
如果有一段配置信息希望多个servlet都可以使用，可以为多个servlet都配置相关信息，这个操作会造成代码冗余。可以把这段配置信息抽取成一个全局配置这样所有的servlet都可以获取这个信息。

如果不理解上下文什么意思，你可以暂时理解成为运行环境
运行环境再转化以下你还可以理解为容器

案例总结

其实这个案例基本就涉及四个步骤：
步骤一：

步骤二：

步骤三：

步骤四：

知识点1：@Controller

名称	@Controller
类型	类注解
位置	SpringMVC控制器类定义上方
作用	设定SpringMVC的核心控制器bean

知识点2：@RequestMapping

名称	@RequestMapping
类型	类注解或方法注解
位置	SpringMVC控制器类或方法定义上方
作用	设置当前控制器方法请求访问路径
相关属性	value(默认)，请求访问路径

知识点3：@ResponseBody

名称	@ResponseBody
类型	类注解或方法注解
位置	SpringMVC控制器类或方法定义上方
作用	设置当前控制器方法响应内容为当前返回值，无需解析

我们在上面案例中的操作，有的以后我们可能不需要再重复：

一次性工作
- 创建工程，设置服务器，加载工程
- 导入坐标
- 创建web容器启动类，加载SpringMVC配置，并设置SpringMVC请求拦截路径
- SpringMVC核心配置类（设置配置类，扫描controller包，加载Controller控制器bean）
多次工作
- 定义处理请求的控制器类
- 定义处理请求的控制器方法，并配置映射路径（@RequestMapping）与返回json数据（@ResponseBody）

案例工作流程解析

为了更好的使用SpringMVC,我们将SpringMVC的使用过程总共分两个阶段来分析，分别是启动服务器初始化过程和单次请求过程：

启动服务器初始化过程

服务器启动，执行ServletContainersInitConfig类，初始化web容器
- 功能类似于以前的web.xml
执行createServletApplicationContext方法，创建了WebApplicationContext对象
- 该方法加载SpringMVC的配置类SpringMvcConfig来初始化SpringMVC的容器
加载SpringMvcConfig配置类
执行@ComponentScan加载对应的bean
- 扫描指定包及其子包下所有类上的注解，如Controller类上的@Controller注解
加载UserController，每个@RequestMapping的名称对应一个具体的方法
- 此时就建立了 /save 和 save方法的对应关系
执行getServletMappings方法，设定SpringMVC拦截请求的路径规则
- /代表所拦截请求的路径规则，只有被拦截后才能交给SpringMVC来处理请求

单次请求过程

发送请求http://localhost/save
web容器发现该请求满足SpringMVC拦截规则，将请求交给SpringMVC处理
解析请求路径/save
由/save匹配执行对应的方法save(）
- 上面的第五步已经将请求路径和方法建立了对应关系，通过/save就能找到对应的save方法
执行save()
检测到有@ResponseBody直接将save()方法的返回值作为响应体返回给请求方

Tomcat是如何加载Spring和SpringMVC的？

首先我们来回顾几个概念：

Servlet本质就是一个接口，提供了WEB应用的业务开发规范。没有main方法，不能独立运行，因此必须把它部署到Servlet容器中，由容器来实例化并调用 Servlet。

Tomcat其实是Web服务器和Servlet容器的结合体.

Web服务器:监听端口，对外提供WEB远程访问功能；将主机上的资源映射为可供外界访问的URL。—————-资源映射，静态的
Servlet容器：管理容器中的Servlet，接收WEB服务器的请求，分发至对应的Servlet处理相应的业务逻辑。——业务处理，动态的

SpringMVC：本质是对Servlet的封装（请求分发、参数解析、相应处理），核心DispatcherServlet最终继承自HttpServlet。

Spring容器是管理service和dao的
SpringMVC容器是管理controller对象的

web容器中有servlet容器，spring项目部署后存在spring容器和springmvc容器。
其中spring控制service层和dao层的bean对象。springmvc容器控制controller层bean对象。servlet容器控制servlet对象。
项目启动流程，首先 servlet初始化，初始化过程中通过web.xml中spring的配置加载spring配置，初始化spring容器和springmvc容器。待容器加载完成。servlet初始化完成，则完成启动。
HTTP请求到达web容器后，会到达Servlet容器，容器通过分发器分发到具体的spring的Controller层。执行业务操作后返回结果。

⚠️注意：这里的Spring容器和SpringMVC容器是父子关系，子容器控制的对象可以访问父容器的对象反之则不行

还有人问为什么tomcat初始化的时候，Spring、SpringMVC都要初始化，加载他们各自的配置？
作为一个web项目，你此时是把这个项目运行在tomcat上，你不把每一个配置加载到，项目是肯定跑不起来的。好，假定你此时只初始化tomcat，一个请求发过来了，tomcat把它分发给了SpringMVC去处理。但是此时SpringMVC没有初始化，没有加载配置，压根起不到作用，这个项目就挂了。

以上是一个粗略的过程，我们再深入一点：

我们现在加载一个加载Web程序（Spring+SpringMVC框架）。

tomcat启动完毕后，最关键的是生成了ServletContext（Tomcat的上下文），然后会根据webapps项目里的web.xml进行加载项目。tomcat首先会加载进ContextLoaderListener，然后将applicationContext.xml里写的参数注入进去，来完成一系列的Spring初始化（如各种bean，数据库资源等等）。

这里最重要的是通过ServletContext，初始化属于Spring的上下文WebApplicationContext，并将其存放在ServletContext中。

此时Spring初始化(加载)完毕，在说初始化SpringMVC之前，我们再来提提servlet：

Servlet是一个接口，为web通信而生。

tomcat有一套定义好的程序（其实不只是tomcat，能跑java写的web应用服务器如Jetty等，都有这固定程序）