SSM使用之SpringMVC

单程车票
279 阅读18分钟

1. SpringMVC概述

  • SpringMVC 也叫 Spring web mvc。是 Spring 框架的一部分，是在 Spring3.0 后发布的。

  • SpringMVC优点

    • 基于 MVC 架构：基于 MVC 架构，功能分工明确。解耦合
    • 容易理解，上手快；使用简单。
    • 作为Spring框架一部分， 能够使用 Spring 的 IoC 和 Aop 。 方便整合Strtus,MyBatis,Hiberate,JPA 等其他框架。
    • SpringMVC 强化注解的使用，在控制器，Service，Dao都可以使用注解。方便灵活。使用@Controller 创建处理器对象,@Service 创建业务对象，@Autowired 或者@Resource在控制器类中注入 Service, Service 类中注入 Dao。

  • 所谓 SpringMVC 的注解式开发是指，在代码中通过对类与方法的注解，便可完成处理器在 springmvc 容器的注册。注解式开发是重点。

2. SpringMVC第一个例子

2.1 pom.xml
 <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.5.RELEASE</version>
 </dependency>
 <build> 
     <plugins>
     <!-- 编码和编译和JDK版本 -->
     <plugin>
      <artifactId>maven-compiler-plugin</artifactId>
      <version>3.1</version>
      <configuration>
      <source>1.8</source>
      <target>1.8</target>
      </configuration>
      </plugin>
     </plugins>
 </build>
2.2 注册中央调度器

image-20220714144004484.png

  • 全限定性类名

    该中央调度器为一个 Servlet，名称为 DispatcherServlet。中央调度器的全限定性类名在导入的 Jar 文件 spring-webmvc-5.2.5.RELEASE.jar 的第一个包 org.springframework.web.servlet下可找到。

  • <load-on-startup/>

    在<servlet/>中添加<load-on-startup/>的作用是，标记是否在Web服务器（这里是Tomcat）启动时会创建这个 Servlet 实例，即是否在 Web 服务器启动时调用执行该 Servlet 的 init()方法，而不是在真正访问时才创建。它的值必须是一个整数。

    • 当值大于等于 0 时，表示容器在启动时就加载并初始化这个 servlet，数值越小，该 Servlet的优先级就越高，其被创建的也就越早；
    • 当值小于 0 或者没有指定时，则表示该 Servlet 在真正被使用时才会去创建。
    • 当值相同时，容器会自己选择创建顺序。

  • <url-pattern/>

    • 对于<url-pattern/>，可以写为 / ，建议写为*.do 的形式。

  • 配置文件位置与名称

    注册完毕后，可直接在服务器上发布运行。此时，访问浏览器页面，控制台均会抛出FileNotFoundException 异常。即默认要从项目根下的 WEB-INF 目录下找名称为 Servlet 名称-servlet.xml 的配置文件。这里的“Servlet 名称”指的是注册中央调度器<servlet-name/>标签中指定的 Servlet 的 name 值。本例配置文件名为 springmvc-servlet.xml。

    而一般情况下，配置文件是放在类路径下，即 resources 目录下。所以，在注册中央调度器时，还需要为中央调度器设置查找 SpringMVC 配置文件路径，及文件名。

    image-20220714154442367.png

    打开 DispatcherServlet 的源码，其继承自 FrameworkServlet，而该类中有一个属性contextConfigLocation，用于设置 SpringMVC 配置文件的路径及文件名。该初始化参数的属性就来自于这里。

    image-20220714154604822.png

    image-20220714154616566.png

2.3 创建SpringMVC配置文件

在工程的类路径即 src 目录下创建 SpringMVC 的配置文件 springmvc.xml。该文件名可以任意命名。

image-20220714160909991.png

2.4 创建处理器

在类上与方法上添加相应注解即可。

@Controller：表示当前类为处理器

@RequestMapping：表示当前方法为处理器方法。该方法要对 value 属性所指定的 URI进行处理与响应。被注解的方法的方法名可以随意。

image-20220714160952259.png

若有多个请求路径均可匹配该处理器方法的执行，则@RequestMapping 的 value 属性中可以写上一个数组。

ModelAndView 类中的 addObject()方法用于向其 Model 中添加数据。Model 的底层为一个 HashMap。

Model 中的数据存储在 request 作用域中，SringMVC 默认采用转发的方式跳转到视图，本次请求结束，模型中的数据被销毁。

2.5 声明组件扫描器

在 springmvc.xml 中注册组件扫描器

image-20220714161109986.png

2.6 修改视图解析器的注册

SpringMVC 框架为了避免对于请求资源路径与扩展名上的冗余，在视图解析器InternalResouceViewResolver 中引入了请求的前辍与后辍。而 ModelAndView 中只需给出要跳转页面的文件名即可，对于具体的文件路径与文件扩展名，视图解析器会自动完成拼接。

image-20220714161438798.png

修改处理器

image-20220714162046729.png

2.7 使用SpringMVC框架web请求处理顺序

image-20220714162150368.png

2.8 SpringMVC的MVC组件

image-20220714162728056.png

2.9 SpringMVC执行流程（理解）
  • 流程图

image-20220714162808251.png

  • 执行流程简单分析

    • 浏览器提交请求到中央调度器
    • 中央调度器直接将请求转给处理器映射器。
    • 处理器映射器会根据请求，找到处理该请求的处理器，并将其封装为处理器执行链后返回给中央调度器
    • 中央调度器根据处理器执行链中的处理器，找到能够执行该处理器的处理器适配器。
    • 处理器适配器调用执行处理器。
    • 处理器将处理结果及要跳转的视图封装到一个对象 ModelAndView 中，并将其返回给处理器适配器。
    • 处理器适配器直接将结果返回给中央调度器。
    • 中央调度器调用视图解析器，将 ModelAndView 中的视图名称封装为视图对象。
    • 视图解析器将封装了的视图对象返回给中央调度器
    • 中央调度器调用视图对象，让其自己进行渲染，即进行数据填充，形成响应对象。
    • 中央调度器响应浏览器。

3. SpringMVC注解式开发

3.1 @RquestMapping 定义请求规则
3.1.1 指定模块名称

  • 通过@RequestMapping 注解可以定义处理器对于请求的映射规则。该注解可以注解在方法上，也可以注解在类上，但意义是不同的。value 属性值常以“/”开始。

  • @RequestMapping 的 value 属性用于定义所匹配请求的 URI。但对于注解在方法上与类上，其 value 属性所指定的 URI，意义是不同的。

  • 一个 @Controller 所注解的类中，可以定义多个处理器方法。当然，不同的处理器方法所匹配的 URI 是不同的。这些不同的 URI 被指定在注解于方法之上的 @RequestMapping 的 value 属性中。但若这些请求具有相同的 URI 部分，则这些相同的 URI，可以被抽取到注解在类之上的 @RequestMapping 的 value 属性中。此时的这个 URI 表示模块的名称。URI 的请求是相对于 Web 的根目录。

  • 换个角度说，要访问处理器的指定方法，必须要在方法指定 URI 之前加上处理器类前定义的模块名称

image-20220714172216026.png

3.1.2 对请求提交方式的定义

  • 对于 @RequestMapping，其有一个属性 method，用于对被注解方法所处理请求的提交方式进行限制，即只有满足该 method 属性指定的提交方式的请求，才会执行该被注解方法。

  • Method 属性的取值为 RequestMethod 枚举常量。常用的为 RequestMethod.GET 与RequestMethod.POST，分别表示提交方式的匹配规则为 GET 与 POST 提交。

    image-20220714172322104.png

  • 以上处理器方法只能处理 POST 方式提交的请求。客户端浏览器常用的请求方式，及其提交方式有以下几种：

    image-20220714172356686.png

    也就是说，只要指定了处理器方法匹配的请求提交方式为 POST，则相当于指定了请求发送的方式：要么使用表单请求，要么使用 AJAX 请求。其它请求方式被禁用。当然，若不指定 method 属性，则无论是 GET 还是 POST 提交方式，均可匹配。即对于请求的提交方式无要求。

    image-20220714172505874.png

3.2 处理器方法的参数

处理器方法可以包含以下四类参数，这些参数会在系统调用时由系统自动赋值，即程序员可在方法内直接使用。

  • HttpServletRequest
  • HttpServletResponse
  • HttpSession
  • 请求中所携带的请求参数
3.2.1 逐个参数接收

只要保证请求参数名与该请求处理方法的参数名相同即可。

image-20220714172647112.png

image-20220714172833364.png

3.2.2 请求参数中文乱码问题

对于前面所接收的请求参数，若含有中文，则会出现中文乱码问题。

Spring 对于请求参数中的中文乱码问题，给出了专门的字符集过滤器：spring-web-5.2.5.RELEASE.jar的org.springframework.web.filter 包下的 CharacterEncodingFilter 类。

解决方案：

在 web.xml 中注册字符集过滤器，即可解决 Spring 的请求参数的中文乱码问题。不过，最好将该过滤器注册在其它过滤器之前。因为过滤器的执行是按照其注册顺序进行的。

image-20220714173613065.png

字符集的源码分析：字符集设置核心方法

image-20220714173729338.png

3.2.3 校正请求参数名 @RequestParam

所谓校正请求参数名，是指若请求 URL 所携带的参数名称与处理方法中指定的参数名不相同时，则需在处理方法参数前，添加一个注解 @RequestParam(“请求参数名”)，指定请求 URL 所携带参数的名称。该注解是对处理器方法参数进行修饰的。value 属性指定请求参数的名称。

image-20220714174010773.png

image-20220714174037351.png

image-20220714174048267.png

3.2.4 对象参数接收

将处理器方法的参数定义为一个对象，只要保证请求参数名与这个对象的属性同名即可。

image-20220714174656008.png

image-20220714174713849.png

3.3 处理器方法的返回值

使用 @Controller 注解的处理器的处理器方法，其返回值常用的有四种类型：

  • 第一种：ModelAndView
  • 第二种：String
  • 第三种：无返回值 void
  • 第四种：返回自定义类型对象

根据不同的情况，使用不同的返回值。

3.3.1 返回ModelAndView

若处理器方法处理完后，需要跳转到其它资源，且又要在跳转的资源间传递数据，此时处理器方法返回ModelAndView 比较好。当然，若要返回 ModelAndView，则处理器方法中需要定义 ModelAndView 对象。在使用时，若该处理器方法只是进行跳转而不传递数据，或只是传递数据而并不向任何资源跳转（如对页面的 Ajax 异步响应），此时若返回 ModelAndView，则将总是有一部分多余：要么 Model 多余，要么 View 多余。即此时返回 ModelAndView 将不合适。

3.3.2 返回String

处理器方法返回的字符串可以指定逻辑视图名，通过视图解析器解析可以将其转换为物理视图地址

返回内部资源逻辑视图名

若要跳转的资源为内部资源，则视图解析器可以使用 InternalResourceViewResolver 内部资源视图解析器。此时处理器方法返回的字符串就是要跳转页面的文件名去掉文件扩展名后的部分。这个字符串与视图解析器中的 prefix、suffix 相结合，即可形成要访问的 URI。

image-20220714175936234.png

image-20220714180106525.png

3.3.3 返回void

对于处理器方法返回 void 的应用场景，AJAX 响应。

若处理器对请求处理后，无需跳转到其它任何资源，此时可以让处理器方法返回 void。例如，对于 AJAX 的异步请求的响应。

image-20220714202358193.png

image-20220714202410405.png

处理器对于 AJAX 请求中所提交的参数，可以使用逐个接收的方式，也可以以对象的方式整体接收。只要保证 AJAX 请求参数与接收的对象类型属性同名。

image-20220714202443814.png

3.3.4 返回对象Object

处理器方法也可以返回 Object 对象。这个 Object 可以是 Integer，String，自定义对象，Map，List 等。但返回的对象不是作为逻辑视图出现的，而是作为直接在页面显示的数据出现的。

返回对象，需要使用@ResponseBody 注解，将转换后的 JSON 数据放入到响应体中。

  • 声明注解驱动

    将 Object 数据转化为 JSON 数据，需要由消息转换器 HttpMessageConverter 完成。而转换器的开启，需要由<mvc:annotation-driven/>来完成。

    SpringMVC 使用消息转换器实现请求数据和对象，处理器方法返回对象和响应输出之间的自动转换

    当 Spring 容器进行初始化过程中，在<mvc:annotation-driven/>处创建注解驱动时，默认创建了七个 HttpMessageConverter 对象。也就是说，我们注册<mvc:annotation-driven/>，就是为了让容器为我们创建 HttpMessageConverter 对象。

    image-20220714203302961.png

  • 返回自定义类型对象

    返回自定义类型对象时，不能以对象的形式直接返回给客户端浏览器，而是将对象转换为 JSON 格式的数据发送给浏览器的。

    由于转换器底层使用了Jackson转换方式将对象转换为JSON数据，所以需要导入Jackson的相关 Jar 包。

    image-20220714203446263.png

  • 返回List集合

    image-20220714203513596.png

  • 返回字符串对象

    若要返回非中文字符串，将前面返回数值型数据的返回值直接修改为字符串即可。但若返 回 的 字 符 串 中 带 有 中 文 字 符 ， 则 接 收 方 页 面 将 会 出 现 乱 码 。 此 时 需 要 使 用@RequestMapping 的 produces 属性指定字符集。produces，产品，结果，即该属性用于设置输出结果类型。

    image-20220714203600807.png

3.4 解读<url-pattern>
3.4.1 配置详解

（1） *.do

在没有特殊要求的情况下，SpringMVC 的中央调度器 DispatcherServlet 的<url-pattern/>常使用后辍匹配方式，如写为*.do 或者 *.action, *.mvc 等。

（2） /

可以写为/，因为 DispatcherServlet 会将向静态资源的获取请求，例如.css、.js、.jpg、.png等资源的获取请求，当作是一个普通的 Controller 请求。中央调度器会调用处理器映射器为其查找相应的处理器。当然也是找不到的，所以在这种情况下，所有的静态资源获取请求也均会报 404 错误。

3.4.2 静态资源访问

<url-pattern/>的值并不是说写为/后，静态资源就无法访问了。经过一些配置后，该问题也是可以解决的。

（1） 使用<mvc:default-servlet-handler/>

声明了<mvc:default-servlet-handler/>后 ，springmvc框 架会在容器中创建DefaultServletHttpRequestHandler 处理器对象。它会像一个检查员，对进入 DispatcherServlet的 URL 进行筛查，如果发现是静态资源的请求，就将该请求转由 Web 应用服务器默认的Servlet 处理。一般的服务器都有默认的 Servlet。

在 Tomcat 中，有一个专门用于处理静态资源访问的 Servlet 名叫 DefaultServlet。其<servlet-name/>为 default。可以处理各种静态资源访问请求。该 Servlet 注册在 Tomcat 服务器的 web.xml 中。在 Tomcat 安装目录/conf/web.xml。

image-20220714204022597.png

只需要在 springmvc.xml 中添加<mvc:default-servlet-handler/>标签即可。

image-20220714204043309.png

<mvc:default-servlet-handler/>表示使用 DefaultServletHttpRequestHandler 处理器对象。而该处理器调用了 Tomcat 的 DefaultServlet 来处理静态资源的访问请求。要想使用<mvc: …/>标签，需要引入 mvc 约束

（2） 使用<mvc:resources/>（掌握）

在 Spring3.0 版本后，Spring 定义了专门用于处理静态资源访问请求的处理器ResourceHttpRequestHandler。并且添加了<mvc:resources/>标签，专门用于解决静态资源无法访问问题。需要在 springmvc 配置文件中添加如下形式的配置：

image-20220714204351927.png

location 表示静态资源所在目录。当然，目录不要使用/WEB-INF/及其子目录。

mapping 表 示 对 该 资 源 的 请 求 （ 以 /images/ 开 始 的 请 求 ， 如 /image/beauty.jpg , /images/car.png 等）。注意，后面是两个星号**。

（3） 声明注解驱动

image-20220714204553142.png

4. SSM整合开发

SSM 编程，即 SpringMVC + Spring + MyBatis 整合，是当前最为流行的 JavaEE 开发技术架构。其实 SSM 整合的实质，仅仅就是将 MyBatis整合入 Spring。因为 SpringMVC原本就是 Spring的一部分，不用专门整合。

SSM 整合的实现方式可分为两种：基于 XML 配置方式，基于注解方式。

附上常用的SSM模板

  • pom.xml

     <?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.tbabs</groupId>
   <artifactId>项目名</artifactId>
   <version>版本号</version>
   <packaging>war</packaging>
 ​
   <properties>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     <maven.compiler.source>11</maven.compiler.source>
     <maven.compiler.target>11</maven.compiler.target>
   </properties>
 ​
   <dependencies>
     <!-- junit -->
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <version>4.11</version>
       <scope>test</scope>
     </dependency>
     <!-- spring -->
     <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-context</artifactId>
       <version>5.2.5.RELEASE</version>
     </dependency>
     <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-beans</artifactId>
       <version>5.2.5.RELEASE</version>
     </dependency>
     <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-webmvc</artifactId>
       <version>5.2.5.RELEASE</version>
     </dependency>
     <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-jdbc</artifactId>
       <version>5.2.5.RELEASE</version>
     </dependency>
     <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-aspects</artifactId>
       <version>5.2.5.RELEASE</version>
     </dependency>
     <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-jms</artifactId>
       <version>5.2.5.RELEASE</version>
     </dependency>
     <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-context-support</artifactId>
       <version>5.2.5.RELEASE</version>
     </dependency>
     <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-test</artifactId>
       <version>5.2.5.RELEASE</version>
     </dependency>
     <!-- Mybatis -->
     <dependency>
       <groupId>org.mybatis</groupId>
       <artifactId>mybatis</artifactId>
       <version>3.5.1</version>
     </dependency>
     <dependency>
       <groupId>org.mybatis</groupId>
       <artifactId>mybatis-spring</artifactId>
       <version>1.3.1</version>
     </dependency>
     <!-- 逆向工程生成mapper，pojo等文件 -->
     <dependency>
       <groupId>org.mybatis.generator</groupId>
       <artifactId>mybatis-generator-core</artifactId>
       <version>1.3.5</version>
     </dependency>
     <dependency>
       <groupId>com.github.miemiedev</groupId>
       <artifactId>mybatis-paginator</artifactId>
       <version>1.2.15</version>
     </dependency>
     <dependency>
       <groupId>com.github.pagehelper</groupId>
       <artifactId>pagehelper</artifactId>
       <version>5.1.2</version>
     </dependency>
     <!-- MySql -->
     <dependency>
       <groupId>mysql</groupId>
       <artifactId>mysql-connector-java</artifactId>
       <version>5.1.9</version>
     </dependency>
     <!-- 连接池 -->
     <dependency>
       <groupId>com.alibaba</groupId>
       <artifactId>druid</artifactId>
       <version>1.1.12</version>
     </dependency>
     <!-- JSP相关 -->
     <dependency>
       <groupId>jstl</groupId>
       <artifactId>jstl</artifactId>
       <version>1.2</version>
     </dependency>
     <dependency>
       <groupId>javax.servlet</groupId>
       <artifactId>javax.servlet-api</artifactId>
       <version>3.1.0</version>
       <scope>provided</scope>
     </dependency>
     <dependency>
       <groupId>javax.servlet</groupId>
       <artifactId>jsp-api</artifactId>
       <scope>provided</scope>
       <version>2.0</version>
     </dependency>
     <!-- Jackson Json处理工具包 -->
     <dependency>
       <groupId>com.fasterxml.jackson.core</groupId>
       <artifactId>jackson-databind</artifactId>
       <version>2.9.6</version>
     </dependency>
     <dependency>
       <groupId>org.json</groupId>
       <artifactId>json</artifactId>
       <version>20140107</version>
     </dependency>
     <!--文件异步上传-->
     <dependency>
       <groupId>commons-io</groupId>
       <artifactId>commons-io</artifactId>
       <version>2.4</version>
     </dependency>
     <dependency>
       <groupId>commons-fileupload</groupId>
       <artifactId>commons-fileupload</artifactId>
       <version>1.3.1</version>
     </dependency>
   </dependencies>
 ​
   <build>
     <plugins>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-compiler-plugin</artifactId>
         <configuration>
           <source>11</source>
           <target>11</target>
           <encoding>UTF-8</encoding>
         </configuration>
       </plugin>
       <!-- mybatis逆向工程插件 -->
         <plugin>
             <groupId>org.mybatis.generator</groupId>
             <artifactId>mybatis-generator-maven-plugin</artifactId>
             <version>1.3.5</version>
             <configuration>
                 <!-- 配置文件的位置 -->
             <configurationFile>${basedir}/generatorConfig.xml</configurationFile>
                 <verbose>true</verbose>
                 <overwrite>true</overwrite>
             </configuration>
             <executions>
                 <execution>
                     <id>Generate MyBatis Artifacts</id>-->
                     <goals>
                         <goal>generate</goal>-->
                     </goals>
                 </execution>
             </executions>
             <dependencies>
                 <dependency>
                     <groupId>org.mybatis.generator</groupId>
                     <artifactId>mybatis-generator-core</artifactId>
                     <version>1.3.5</version>
                 </dependency>
             </dependencies>
         </plugin>
     </plugins>
     <!--识别所有的配置文件-->
     <resources>
       <resource>
         <directory>src/main/java</directory>
         <includes>
           <include>**/*.properties</include>
           <include>**/*.xml</include>
         </includes>
         <filtering>false</filtering>
       </resource>
       <resource>
         <directory>src/main/resources</directory>
         <includes>
           <include>**/*.properties</include>
           <include>**/*.xml</include>
         </includes>
         <filtering>false</filtering>
       </resource>
     </resources>
   </build>
 </project>
 ​

  • 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">
 ​
     <!--注册字符集过滤器-->
     <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>forceRequestEncoding</param-name>
             <param-value>true</param-value>
         </init-param>
         <init-param>
             <param-name>forceResponseEncoding</param-name>
             <param-value>true</param-value>
         </init-param>
     </filter>
     <filter-mapping>
         <filter-name>characterEncodingFilter</filter-name>
         <url-pattern>/*</url-pattern>
     </filter-mapping>
 ​
     <!--注册中央调度器-->
     <servlet>
         <servlet-name>dispatcherServlet</servlet-name>
         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
         <init-param>
             <param-name>contextConfigLocation</param-name>
             <param-value>classpath:springmvc.xml</param-value>
         </init-param>
         <load-on-startup>1</load-on-startup>
     </servlet>
     <servlet-mapping>
         <servlet-name>dispatcherServlet</servlet-name>
         <url-pattern>/</url-pattern>
     </servlet-mapping>
 ​
     <!--spring框架注册-->
     <listener>
         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
     </listener>
     <context-param>
         <param-name>contextConfigLocation</param-name>
         <param-value>classpath:applicationContext.xml</param-value>
     </context-param>
 ​
 </web-app>

  • jdbc.properties

     jdbc.url=jdbc:mysql://localhost:3306/项目名?useUnicode=true&characterEncoding=utf-8
 jdbc.username=root
 jdbc.password=123456

  • mybatis.xml

     <?xml version="1.0" encoding="UTF-8" ?>
 <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
         "http://mybatis.org/dtd/mybatis-3-config.dtd">
 <configuration>
 ​
     <!-- 设置日志 -->
     <settings>
         <setting name="mapUnderscoreToCamelCase" value="true"/>
     </settings>
 ​
     <!--设置别名-->
     <typeAliases>
         <!--name:实体类所在的包名-->
         <package name="com.tbabs.pojo"/>
     </typeAliases>
 ​
     <!--分页插件的配置-->
     <plugins>
         <plugin interceptor="com.github.pagehelper.PageInterceptor">
         </plugin>
     </plugins>
 ​
 </configuration>

  • 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"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:tx="http://www.springframework.org/schema/tx"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
 ​
     <!--配置属性文件-->
     <context:property-placeholder location="classpath:jdbc.properties"/>
 ​
     <!--声明数据源，连接数据库-->
     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
           init-method="init" destroy-method="close">
         <property name="url" value="${jdbc.url}" />
         <property name="username" value="${jdbc.username}" />
         <property name="password" value="${jdbc.password}" />
     </bean>
 ​
     <!--SqlSessionFactoryBean创建SqlSessionFactory-->
     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
         <property name="dataSource" ref="dataSource" />
         <property name="configLocation"  value="classpath:mybatis.xml" />
         <!--指定mybatis的mapper配置文件-->
         <property name="mapperLocations" value="classpath:mapper/*.xml"/>
     </bean>
 ​
     <!--声明mybatis的扫描器，创建dao对象-->
     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
         <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
         <property name="basePackage" value="com.tbabs.dao" />
     </bean>
 ​
     <!--配置业务逻辑层，给spring扫描识别该包下的所有类，使用注解方式-->
     <context:component-scan base-package="com.tbabs.service"/>
 ​
     <!-- 以下是事务的配置信息 -->
     <!-- 声明事务管理器-->
     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
         <property name="dataSource" ref="dataSource"/>
     </bean>
     <!-- 添加事物的切面-->
     <tx:advice id="myadvice" transaction-manager="transactionManager">
         <tx:attributes>
             <tx:method name="*select*" read-only="true"/>
             <tx:method name="*find*" read-only="true"/>
             <tx:method name="*get*" read-only="true"/>
             <tx:method name="*search*" read-only="true"/>
             <tx:method name="*insert*" propagation="REQUIRED"/>
             <tx:method name="*save*" propagation="REQUIRED"/>
             <tx:method name="*add*" propagation="REQUIRED"/>
             <tx:method name="*delete*" propagation="REQUIRED"/>
             <tx:method name="*remove*" propagation="REQUIRED"/>
             <tx:method name="*clear*" propagation="REQUIRED"/>
             <tx:method name="*update*" propagation="REQUIRED"/>
             <tx:method name="*modify*" propagation="REQUIRED"/>
             <tx:method name="*change*" propagation="REQUIRED"/>
             <tx:method name="*set*" propagation="REQUIRED"/>
             <tx:method name="*" propagation="SUPPORTS"/>
         </tx:attributes>
     </tx:advice>
 ​
     <!--通知应用的切入点-->
     <aop:config>
         <aop:pointcut id="mypointcut" expression="execution(* *..service..*.*(..))"/>
         <aop:advisor advice-ref="myadvice" pointcut-ref="mypointcut"/>
     </aop:config>
 </beans>

  • springmvc.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.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">
 ​
     <!--扫描根包 -->
     <context:component-scan base-package="com.tbabs.controller"/>
 ​
     <!--视图解析器-->
     <bean id="resourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
         <property name="prefix" value="/WEB-INF/pages/"/>
         <property name="suffix" value=".jsp"/>
     </bean>
 ​
     <!--文件上传插件-->
     <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
         <!-- 默认编码 -->
         <property name="defaultEncoding" value="UTF-8"/>
         <!-- 上传文件大小限制为31M，31*1024*1024 -->
         <property name="maxUploadSize" value="32505856"/>
         <!-- 内存中的最大值 -->
         <property name="maxInMemorySize" value="4096"/>
     </bean>
 ​
     <!--将springmvc不能处理的请求交给tomcat-->
     <mvc:default-servlet-handler />
     <!--注解驱动-->
     <mvc:annotation-driven/>
 ​
 </beans>

5. SpringMVC核心技术

5.1 请求重定向和转发

当处理器对请求处理完毕后，向其它资源进行跳转时，有两种跳转方式：请求转发与重定向。而根据所要跳转的资源类型，又可分为两类：跳转到页面与跳转到其它处理器。

注意，对于请求转发的页面，可以是WEB-INF中页面；而重定向的页面，是不能为WEB-INF中页的。因为重定向相当于用户再次发出一次请求，而用户是不能直接访问 WEB-INF 中资源的。

image-20220714211451028.png

SpringMVC 框架把原来 Servlet 中的请求转发和重定向操作进行了封装。现在可以使用简单的方式实现转发和重定向。

  • forward:表示转发，实现 request.getRequestDispatcher("xx.jsp").forward()
  • redirect:表示重定向，实现response.sendRedirect("xxx.jsp")
5.1.1 请求转发

处理器方法返回 ModelAndView 时，需在 setViewName()指定的视图前添加 forward:，且此时的视图不再与视图解析器一同工作，这样可以在配置了解析器时指定不同位置的视图。

视图页面必须写出相对于项目根的路径。forward 操作不需要视图解析器。处理器方法返回 String,在视图路径前面加入 forward: 视图完整路径。

image-20220714212643789.png

5.1.2 请求重定向

在处理器方法返回的视图字符串的前面添加 redirect:，则可实现重定向跳转。

image-20220714212704948.png

5.2 异常处理

SpringMVC 框架处理异常的常用方式：使用@ExceptionHandler 注解处理异常。

5.2.1 @ExceptionHandler 注解

使用注解 @ExceptionHandler 可以将一个方法指定为异常处理方法。该注解只有一个可选属性 value，为一个 Class<?>数组，用于指定该注解的方法所要处理的异常类，即所要匹配的异常。

而被注解的方法，其返回值可以是 ModelAndView、String，或 void，方法名随意，方法参数可以是 Exception 及其子类对象、HttpServletRequest、HttpServletResponse 等。系统会自动为这些方法参数赋值。

对于异常处理注解的用法，也可以直接将异常处理方法注解于 Controller 之中。

  • 自定义异常类

    定义三个异常类：NameException、AgeException、MyUserException。其中 MyUserException是另外两个异常的父类。

    image-20220714213152021.png

    image-20220714213203893.png

  • 修改Controller抛出的异常

    image-20220714213219510.png

  • 定义异常响应页面

    image-20220714213257413.png

  • 定义全局异常处理类

    不过，一般不这样使用。而是将异常处理方法专门定义在一个类中，作为全局的异常处理类。

    需要使用注解 @ControllerAdvice，字面理解就是“控制器增强”，是给控制器对象增强功能的。使用@ControllerAdvice 修饰的类中可以使用 @ExceptionHandler。

    当使用 @RequestMapping 注解修饰的方法抛出异常时，会执行 @ControllerAdvice 修饰的类中的异常处理方法。

    @ControllerAdvice 是使用 @Component 注解修饰的，可以<context:component-scan>扫描到@ControllerAdvice 所在的类路径(包名)，创建对象。

    image-20220714213432352.png

  • 定义Spring配置文件

    image-20220714213445065.png

5.3 拦截器

SpringMVC 中的 Interceptor 拦截器是非常重要和相当有用的，它的主要作用是拦截指定的用户请求，并进行相应的预处理与后处理。其拦截的时间点在“处理器映射器根据用户提交的请求映射出了所要执行的处理器类，并且也找到了要执行该处理器类的处理器适配器，在处理器适配器执行处理器之前”。当然，在处理器映射器映射出所要执行的处理器类时，已经将拦截器与处理器组合为了一个处理器执行链，并返回给了中央调度器。

5.3.1 一个拦截器的执行

  • 自定义拦截器

    image-20220714213721672.png

    自定义拦截器，需要实现 HandlerInterceptor 接口。而该接口中含有三个方法：

    • preHandle(request,response, Object handler) ：

      该方法在处理器方法执行之前执行。其返回值为 boolean，若为 true，则紧接着会执行处理器方法，且会将 afterCompletion()方法放入到一个专门的方法栈中等待执行。

    • postHandle(request,response, Object handler,modelAndView)：

      该方法在处理器方法执行之后执行。处理器方法若最终未被执行，则该方法不会执行。由于该方法是在处理器方法执行完后执行，且该方法参数中包含 ModelAndView，所以该方法可以修改处理器方法的处理结果数据，且可以修改跳转方向。

    • afterCompletion(request,response, Object handler, Exception ex)：

      当 preHandle()方法返回 true 时，会将该方法放到专门的方法栈中，等到对请求进行响应的所有工作完成之后才执行该方法。即该方法是在中央调度器渲染（数据填充）了响应页面之后执行的，此时对 ModelAndView 再操作也对响应无济于事。

      afterCompletion 最后执行的方法，清除资源，例如在 Controller 方法中加入数据

      image-20220714213855840.png

      image-20220714213906071.png

  • 注册拦截器

    image-20220714213930180.png

5.3.2 多个拦截器的执行

多拦截器的注册

image-20220714214023228.png

当有多个拦截器时，形成拦截器链。拦截器链的执行顺序，与其注册顺序一致。需要再次强调一点的是，当某一个拦截器的 preHandle()方法返回 true 并被执行到时，会向一个专门的方法栈中放入该拦截器的 afterCompletion()方法。

image-20220714214051301.png

从图中可以看出，只要有一个 preHandle()方法返回 false，则上部的执行链将被断开，其后续的处理器方法与 postHandle()方法将无法执行。但，无论执行链执行情况怎样，只要方法栈中有方法，即执行链中只要有 preHandle()方法返回 true，就会执行方法栈中afterCompletion()方法。最终都会给出响应。

avatar
文章
阅读
粉丝