SpringMVC之入门案例

逃离我推掉我的手 2024-03-27 11:46 59阅读 0赞

##  ##

**目录**

一：概述

二代码实操：

步骤1:创建Maven项目，并导入对应的jar包

步骤2:创建控制器类

步骤3:创建配置类

步骤4:创建Tomcat的Servlet容器配置类

步骤5:配置Tomcat环境

步骤6:启动运行项目

步骤7:浏览器访问

知识点1：@Controller

知识点2：@RequestMapping

知识点3：@ResponseBody

三：入门案例总结

四：入门案例工作流程分析

五：启动服务器初始化过程

六：单次请求过程

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

## 一：概述 ##

因为SpringMVC是一个Web框架，将来是要替换之前我们所使用的Servlet,所以我们先来回顾下以前Servlet是如何进行开发的?

![01c69490ad584b15a81c23ebb178d7b6.png][]

1.浏览器发送请求到Tomcat服务器

2.Tomcat服务器接收到请求后，会根据请求路径来匹配对应的Servlet,并将请求交给对应的Servlet来处理

所以对于Servlet来说，我们主要完成的是Servlet类的开发以及对应路径的配置。

那么对于SpringMVC程序的流程会是什么样的呢?

![acf1eada521e4440af3bf18d4b84d35e.png][]

1.浏览器发送请求到Tomcat服务器

2.Tomcat服务器接收到请求后，会将请求交给SpringMVC中的==DispatcherServlet\[前端控制器\]==来处理请求

3.DispatcherServlet不真正处理请求，只是按照对应的规则将请求分发到对应的Bean对象

4.Bean对象是有我们自己编写来处理不同的请求，每个Bean中可以处理一个或多个不同的请求url

5.DispatcherServlet和Bean对象都需要交给Spring容器来进行管理

综上所述，需要我们编写的内容包含:

*  Bean对象的编写
 *  请求url和Bean对象对应关系的配置
 *  构建Spring容器，将DispatcherServlet和Bean对象交给容器管理
 *  配置Tomcat服务器，使其能够识别Spring容器，并将请求交给容器中的DispatcherServlet来分发请求

具体的实现步骤如下:

1.创建web工程(Maven结构)并在工程的pom.xml添加SpringMVC和Servlet坐标

2.创建SpringMVC控制器类(等同于Servlet功能)

3.初始化SpringMVC环境(同Spring环境)，设定SpringMVC加载对应的bean

4.初始化Servlet容器，加载SpringMVC环境，并设置SpringMVC技术处理的请求

## 二代码实操： ##

#### 步骤1:创建Maven项目，并导入对应的jar包 ####

打开IDEA,创建一个新的web项目

![988d7c7c9ae74ffeaead43dedf554f6d.png][]

因为使用骨架创建的项目结构不完整，需要手动补全

![6a806bcb79714265bb6af36f4a4760c5.png][]

将pom.xml中多余的内容删除掉，再添加SpringMVC需要的依赖

<?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.itheima</groupId>
      <artifactId>springmvc_01_quickstart</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>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中的，就避免冲突

#### **步骤2:创建控制器类** ####

#### **步骤3:创建配置类** ####

//3.定义配置类加载Controller对应的bean
    @Configuration
    @ComponentScan("com.itheima.controller")
    public class SpringMvcConfig {
    }

#### **步骤4:创建Tomcat的Servlet容器配置类** ####

//4.定义servlet容器的配置类
    public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
        //加载springMVC配置
        protected WebApplicationContext createServletApplicationContext() {
            //初始化WebApplicationContext对象
            AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
            //加载指定配置类
            ctx.register(SpringMvcConfig.class);
            return ctx;
        }
    
        //设置Tomcat接收的请求哪些归SpringMVC处理
        protected String[] getServletMappings() {
            return new String[]{"/"};
        }
    
        //设置spring相关配置
        protected WebApplicationContext createRootApplicationContext() {
            return null;
        }
    }

#### **步骤5:配置Tomcat环境** ####

![7d084863fa8748739f2e2f5a6109f975.png][]

#### **步骤6:启动运行项目** ####

![8f73bde1e7c3460db9fc6a58b6427e2a.png][]

#### **步骤7:浏览器访问** ####

浏览器输入`http://localhost/save`进行访问，可以看得如下内容

![3574b73f902f4c6b8dfd09871b5496ab.png][]

至此SpringMVC的入门案例就已经完成。

#### 知识点1：@Controller ####

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>@Controller</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类型</td> 
   <td>类注解</td> 
  </tr> 
  <tr> 
   <td>位置</td> 
   <td>SpringMVC控制器类定义上方</td> 
  </tr> 
  <tr> 
   <td>作用</td> 
   <td>设定SpringMVC的核心控制器bean</td> 
  </tr> 
 </tbody> 
</table>

#### 知识点2：@RequestMapping ####

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

#### 知识点3：@ResponseBody ####

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

####  ####

## 三：入门案例总结 ##

SpringMVC入门程序开发总结(1+N)

*  一次性工作
    
     *  创建工程，设置服务器，加载工程
     *  导入坐标
     *  创建web容器启动类，加载SpringMVC配置，并设置SpringMVC请求拦截路径
     *  SpringMVC核心配置类（设置配置类，扫描controller包，加载Controller控制器bean）
 *  多次工作
    
     *  定义处理请求的控制器类
     *  定义处理请求的控制器方法，并配置映射路径（@RequestMapping）与返回json数据（@ResponseBody）
     *  多次工作我们可以通过实现一个用户的删除功能来体验一把
        
         *  controller类中编写删除方法

//2.制作控制器类，等同于Servlet
    //2.1必须是一个spring管理的bean
    //2.2定义具体处理请求的方法
    //2.3设置当前方法的访问路径
    //2.4设置响应结果为json数据
    @Controller
    public class UserController {
        
        @RequestMapping("/save")
        @ResponseBody
        public String save(){
            System.out.println("user save ...");
            return "{'module':'springmvc'}";
        }
        @RequestMapping("/delete")
        @ResponseBody
        public String delete(){
            System.out.println("user delete ...");
            return "{'module':'springmvc delete '}";
        }
    }

*  重启服务器，访问`http://localhost/delete`,可以看得如下效果:

![9fff9a0bff1543d788ea73dc7a0bd8d3.png][]

最后针对本案例中出现的Tomcat的Servlet容器配置再来总结下:

*  AbstractDispatcherServletInitializer类是SpringMVC提供的快速初始化Web3.0容器的抽象类
 *  AbstractDispatcherServletInitializer提供三个接口方法供用户实现
    
     *  createRootApplicationContext()方法，如果创建Servlet容器时需要加载非SpringMVC对应的bean，使用当前方法进行，使用方式同createServletApplicationContext()
     *  createServletApplicationContext()方法，创建Servlet容器时，加载SpringMVC对应的bean并放入WebApplicationContext对象范围中，而WebApplicationContext的作用范围为ServletContext范围，即整个web容器范围
     *  ngetServletMappings()方法，设定SpringMVC对应的请求映射路径，设置为/表示拦截所有请求，任意请求都将转入到SpringMVC进行处理
     *  createServletApplicationContext用来加载SpringMVC环境
     *  createRootApplicationContext用来加载Spring环境

## 四：入门案例工作流程分析 ##

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

![797b11efb9d64726a52a675a00ce3021.png][]

## **五：启动服务器初始化过程** ##

1.  服务器启动，执行ServletContainersInitConfig类，初始化web容器
2.  执行createServletApplicationContext方法，创建了WebApplicationContext对象
    
     *  该方法加载SpringMVC的配置类SpringMvcConfig来初始化SpringMVC的容器
3.  加载SpringMvcConfig配置类

![691e6f2ce6f24960a0bf3317490ed2d1.png][]

1.  执行@ComponentScan加载对应的bean
    
     *  扫描指定包下所有类上的注解，如Controller类上的@Controller注解
2.  加载UserController，每个@RequestMapping的名称对应一个具体的方法

![b985c39b7adf41738e13d5e845f916cd.png][]

1.  此时就建立了 `/save` 和 save方法的对应关系
2.  执行getServletMappings方法，定义所有的请求都通过SpringMVC

![08f12bb11fff432f864409f7f661e697.png][]

*  `/`代表所拦截请求的路径规则，只有被拦截后才能交给SpringMVC来处理请求

## 六：单次请求过程 ##

1.  发送请求localhost/save
2.  web容器发现所有请求都经过SpringMVC，将请求交给SpringMVC处理
    
     *  因为符合上面第六步设置的请求路径，所以该请求会交给SpringMVC来处理
3.  解析请求路径/save
4.  由/save匹配执行对应的方法save(）
    
     *  上面的第五步已经将请求路径和方法建立了对应关系，通过/save就能找到对应的save方法
5.  执行save()
6.  检测到有@ResponseBody直接将save()方法的返回值作为响应求体返回给请求方

[01c69490ad584b15a81c23ebb178d7b6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/60ee372906764912be3a45e2ed14499b.png
[acf1eada521e4440af3bf18d4b84d35e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/36740d030abb4a2dbaaa54641edb4a23.png
[988d7c7c9ae74ffeaead43dedf554f6d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/59cca183375d419d89a57bf6ec1f0142.png
[6a806bcb79714265bb6af36f4a4760c5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/eb087c891d9c457cb234838945388d0f.png
[7d084863fa8748739f2e2f5a6109f975.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/b3d905fa4c2242f5aef032c4df27b4f9.png
[8f73bde1e7c3460db9fc6a58b6427e2a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/47e4516a94c444799104f72953d205ad.png
[3574b73f902f4c6b8dfd09871b5496ab.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/857a0e82ab684837a51cbf847c012fc0.png
[9fff9a0bff1543d788ea73dc7a0bd8d3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/87ef4f52561e42d399f222873fee791a.png
[797b11efb9d64726a52a675a00ce3021.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/6897051f8cb24b1b868642a82bf0b3c4.png
[691e6f2ce6f24960a0bf3317490ed2d1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/bcc81b03297349498bbbcb15778965c0.png
[b985c39b7adf41738e13d5e845f916cd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/e80333e6a2204f86873617b1653c03a9.png
[08f12bb11fff432f864409f7f661e697.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/c8eec55e012b42fa96e04b33a2245760.png