SSM框架05-SpringMVC

SpingMVC简介

SpringMVC是一种基于 Java 的实现MVC 设计模型的请求驱动类型的轻量级Web 框架，属于SpringFrameWork的后续产品，已经融合在 Spring Web Flow 中
SpringMVC 已经成为目前最主流的MVC框架之一，并且随着Spring3.0 的发布，全面超越 Struts2，成为最优秀的 MVC 框架。它通过一套注解，让一个简单的 Java 类成为处理请求的控制器，而无须实现任何接口。同时它还支持RESTful编程风格的请求

SpringMVC开发步骤

在pom.xml导入SpringMVC相关坐标

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


<!--Spring坐标-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.0.5.RELEASE</version>
</dependency>
<!--SpringMVC坐标-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.0.5.RELEASE</version>
</dependency>

在web.xml配置SpringMVC核心控制器DispathcerServlet

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


<!--配置SpringMVC的前端控制器DispatcherServlet-->
<servlet>
    <servlet-name>DispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--配置加载spring-mvc.xml-->
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-mvc.xml</param-value>
    </init-param>
    <!--服务器启动时就加载DispatcherServlet-->
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>DispatcherServlet</servlet-name>
    <!--每个前端请求都要经过DispatcherServlet-->
    <url-pattern>/</url-pattern>
</servlet-mapping>

创建Controller类和视图页面
使用注解配置Controller类中业务方法的映射地址

1
2
3
4
5
6
7
8


@Controller
public class QuickController {
    @RequestMapping("/quick")
    public String quickMethod(){
        System.out.println("quickMethod running.....");
        return "index";
    }
}

配置SpringMVC核心文件 spring-mvc.xml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


<beans	xmlns="http://www.springframework.org/schema/beans"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       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.xsd
                           http://www.springframework.org/schema/mvc
                           http://www.springframework.org/schema/mvc/spring-mvc.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd">
    <!--controller的组件扫描-->
    <context:component-scan base-package="one.wangyi.controller"/>

</beans>

客户端发起请求测试

SpringMVC流程图示

用户发送请求至前端控制器DispatcherServlet。
DispatcherServlet收到请求调用HandlerMapping处理器映射器。
处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。
DispatcherServlet调用HandlerAdapter处理器适配器。
HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。
Controller执行完成返回ModelAndView。
HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。
DispatcherServlet将ModelAndView传给ViewReslover视图解析器。
ViewReslover解析后返回具体View。
DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。DispatcherServlet响应用户

SpringMVC组件

前端控制器：DispatcherServlet
- 用户请求到达前端控制器，它就相当于 MVC 模式中的 C
- DispatcherServlet 是整个流程控制的中心，由它调用其它组件处理用户的请求
- DispatcherServlet 的存在降低了组件之间的耦合性
处理器映射器：HandlerMapping
- HandlerMapping 负责根据用户请求找到 Handler(controller)
- SpringMVC 提供了不同的映射器实现不同的映射方式
  - 例如：配置文件方式，实现接口方式，注解方式等
处理器适配器：HandlerAdapter
- 通过 HandlerAdapter 对controller进行执行，这是适配器模式的应用
- 通过扩展适配器可以对更多类型的controller进行执行
处理器：Handler
- 它就是我们开发中要编写的具体业务控制器(controller)
- 由 DispatcherServlet 把用户请求转发到 Handler。由Handler 对具体的用户请求进行处理
视图解析器：View Resolver
- View Resolver 负责将处理结果生成 View 视图
- View Resolver 首先根据逻辑视图名解析成物理视图名，即具体的页面地址
- 再生成 View 视图对象
- 最后对 View 进行渲染将处理结果通过页面展示给用户
视图：View
- SpringMVC 框架提供了很多的 View 视图类型的支持，包括：jstlView、freemarkerView、pdfView等
- 最常用的视图就是 jsp，一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由程序员根据业务需求开发具体的页面

SpringMVC注解

@RequestMapping
- 作用：用于建立请求 URL 和处理请求方法之间的对应关系
- 位置：
  - 类上，请求URL 的第一级访问目录。此处不写的话，就相当于应用的根目录
  - 方法上，请求 URL 的第二级访问目录，与类上的使用@ReqquestMapping标注的一级目录一起组成访问虚拟路径
- 属性：
  - value：用于指定请求的URL。它和path属性的作用是一样的
  - method：用于指定请求的方式
  - params：用于指定限制请求参数的条件。它支持简单的表达式。要求请求参数的key和value必须和配置的一模一样
- 例如：
  - params = {“accountName”}，表示请求参数必须有accountName
  - params = {“moeny!100”}，表示请求参数中money不能是100

SpringMVC的XML配置

配置视图解析器

SpringMVC有默认组件配置，默认组件都是DispatcherServlet.properties配置文件中配置的，该配置文件地址org/springframework/web/servlet/DispatcherServlet.properties，该文件中配置了默认的视图解析器，如下：

1

org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver

翻看该解析器源码，可以看到该解析器的默认设置，如下：

1
2
3
4


REDIRECT_URL_PREFIX = "redirect:" --重定向前缀
FORWARD_URL_PREFIX = "forward:" --转发前缀（默认值）
prefix = ""; --视图名称前缀
suffix = ""; --视图名称后缀

我们可以通过属性注入的方式修改视图的的前后缀，如下：

1
2
3
4
5


<!--配置内部资源视图解析器-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/views/"></property>
    <property name="suffix" value=".jsp"></property>
</bean>

知识要点：
- SpringMVC的相关组件
  - 前端控制器：DispatcherServlet
  - 处理器映射器：HandlerMapping
  - 处理器适配器：HandlerAdapter
  - 处理器：Handler
  - 视图解析器：View Resolver
  - 视图：View
- SpringMVC的注解和配置
  - 请求映射注解：@RequestMapping
  - 视图解析器配置：
    - REDIRECT_URL_PREFIX = "redirect:"
    - FORWARD_URL_PREFIX = "forward:"
    - prefix = "";
    - suffix = "";

SpringMVC的请求和响应

SpringMVC的数据响应

SpringMVC的数据响应方式有以下两种：

页面跳转
- 直接返回字符串
- 通过ModelAndView对象返回
回写数据
- 直接返回字符串
- 返回对象或集合

页面跳转

直接返回字符串

重定向是客户端再次请求，因为WEB-INF是一个受保护的目录，外界不能直接访问，所以重定向时资源需处在一个可以被外界访问的位置
返回值加/，访问webapp目录；不加/，拼接前缀后缀后访问

通过ModelAndView返回

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


// model由参数获得,返回view,将model和view分离
@RequestMapping(value="/quick4")
public String save4(Model model){
    model.addAttribute("username","博学谷");
    return "index";
}
// ModelAndView由参数获得
@RequestMapping(value="/quick3")
public ModelAndView save3(ModelAndView modelAndView){
    modelAndView.addObject("username","itheima");
    modelAndView.setViewName("success");
    return modelAndView;
}
// 手动创建ModelAndView对象
@RequestMapping(value="/quick2")
public ModelAndView save2(){
    /*
            Model:模型 作用封装数据
            View：视图 作用展示数据
         */
    ModelAndView modelAndView = new ModelAndView();
    //设置模型数据
    modelAndView.addObject("username","itcast");
    //设置视图名称
    modelAndView.setViewName("success");
    return modelAndView;
}

回写数据

直接返回字符串

将需要回写的字符串直接返回，但此时需要通过@ResponseBody注解告知SpringMVC框架，方法返回的字符串不是页面跳转，而是直接在http响应体中返回

1
2
3
4
5


@RequestMapping("/quick5")
@ResponseBody
public String quickMethod5() throws IOException {
    return "hello springMVC!";
}

返回对象或集合

通过SpringMVC帮助我们对对象或集合进行json字符串的转换并回写，为处理器适配器配置消息转换参数，指定使用jackson进行对象或集合的转换，因此需要在spring-mvc.xml中进行如下配置：

1
2
3
4
5
6
7
8
9


<!--配置处理器映射器-->
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
    <property name="messageConverters">
        <list>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
            </bean>
        </list>
    </property>
</bean>

可以使用mvc的注解驱动代替上述配置
在 SpringMVC 的各个组件中，处理器映射器、处理器适配器、视图解析器称为 SpringMVC 的三大组件
使用<mvc:annotation-driven>自动加载处理器映射器和处理器适配器，可用在Spring-xml.xml配置文件中使用<mvc:annotation-driven>替代注解处理器和适配器的配置
同时使用<mvc:annotation-driven>注解，默认底层就会集成jackson进行对象或集合的json格式字符串的转换：

1
2


<!--mvc的注解驱动-->
<mvc:annotation-driven/>

使用默认底层就会集成jackson进行对象或集合的json格式字符串的转换

1
2
3
4
5
6
7
8


@RequestMapping("/quick8")
@ResponseBody
public User quickMethod8() throws IOException {
    User user = new User();
    user.setUsername("zhangsan");
    user.setAge(18);
    return user;
}

SpringMVC获得请求数据

客户端请求参数的格式是：name=value&name=value ……

服务器端要获得请求的参数，有时还需要进行数据的封装，SpringMVC可以接收如下类型的参数：

基本类型参数
POJO类型参数
数组类型参数
集合类型参数

获得基本类型参数

Controller中的业务方法的参数名称要与请求参数的name一致，参数值会自动映射匹配：

1

http://localhost:8080/springmvc/quick9?username=zhangsan&age=12

1
2
3
4
5
6


@RequestMapping("/quick9")
@ResponseBody
public void quickMethod9(String username,int age) throws IOException {
    System.out.println(username);
    System.out.println(age);
}

获得POJO类型参数

Controller中的业务方法的POJO参数的属性名与请求参数的name一致，参数值会自动映射匹配

1

http://localhost:8080/springmvc/quick10?username=zhangsan&age=12

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


public class User {
    private String username;
    private int age;
    getter/setter…
}
@RequestMapping("/quick10")
@ResponseBody
public void quickMethod10(User user) throws IOException {
    System.out.println(user);
}

获得数组类型参数

Controller中的业务方法数组名称与请求参数的name一致，参数值会自动映射匹配

1

http://localhost:8080/springmvc/quick11?strs=111&strs=222&strs=333

1
2
3
4
5


@RequestMapping("/quick11")
@ResponseBody
public void quickMethod11(String[] strs) throws IOException {
    System.out.println(Arrays.asList(strs));
}

获得集合类型参数

获得集合参数时，要将集合参数包装到一个POJO(javabean)中才可以：

1
2
3
4
5
6
7


<form action="${pageContext.request.contextPath}/quick12" method="post">
    <input type="text" name="userList[0].username"><br>
    <input type="text" name="userList[0].age"><br>
    <input type="text" name="userList[1].username"><br>
    <input type="text" name="userList[1].age"><br>
    <input type="submit" value="提交"><br>
</form>

1
2
3
4
5


@RequestMapping("/quick12")
@ResponseBody
public void quickMethod12(Vo vo) throws IOException {
    System.out.println(vo.getUserList());
}

当使用ajax提交时，可以指定contentType为json形式，那么在方法参数位置使用@RequestBody可以直接接收集合数据而无需使用POJO进行包装：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


<script>
    //模拟数据
    var userList = new Array();
    userList.push({username: "zhangsan",age: "20"});
    userList.push({username: "lisi",age: "20"});
    $.ajax({
        type: "POST",
        url: "/springmvc/quick13",
        data: JSON.stringify(userList),
        contentType : 'application/json;charset=utf-8'
    });
</script>

1
2
3
4
5


@RequestMapping("/quick13")
@ResponseBody
public void quickMethod13(@RequestBody List<User> userList) throws IOException {
    System.out.println(userList);
}

注意：通过浏览器的开发者工具抓包发现，没有加载到jquery文件，原因是SpringMVC的前端控制器DispatcherServlet的url-pattern配置的是/,代表对所有的资源都进行过滤操作，我们可以通过以下两种方式指定放行静态资源：
- 在spring-mvc.xml配置文件中指定放行的资源
  - <mvc:resources mapping="/js/**" location="/js/"/>
- 使用<mvc:default-servlet-handler/>标签当springmvc找不到指定资源时交友原始容器tomcat寻找指定资源

请求数据乱码问题

当post请求时，中文数据会出现乱码，我们可以设置一个过滤器来进行编码的过滤：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


<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>
</filter>
<filter-mapping>
    <filter-name>CharacterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

参数绑定注解@requestParam

当请求的参数名称与Controller的业务方法参数名称不一致时，就需要通过@RequestParam注解显式的绑定

1
2
3
4


<form action="${pageContext.request.contextPath}/quick14" method="post">
    <input type="text" name="name"><br>
    <input type="submit" value="提交"><br>
</form>

注解@RequestParam有如下参数可以使用：

value：与请求参数名称一致
required：指定请求是否必须包括该参数，默认是true，请求提交时如果没有此参数则报错
defaultValue：当没有指定请求参数时，则使用指定的默认值

1
2
3
4
5


@RequestMapping("/quick14")
@ResponseBody
public void quickMethod14(@RequestParam(value="name",required = false,defaultValue = "未命名") String username) throws IOException {
    System.out.println(username);
}

自定义类型转换器

SpringMVC 默认已经提供了一些常用的类型转换器，例如客户端提交的字符串转换成int型进行参数设置。
但是不是所有的数据类型都提供了转换器，没有提供的就需要自定义转换器，例如：日期类型的数据就需要自定义转换器。
自定义类型转换器的开发步骤：
- 定义转换器类实现Converter接口
- 在配置文件中声明转换器
- 在<annotation-driven>中引用转换器

获得Servlet相关API

SpringMVC支持使用原始ServletAPI对象作为控制器方法的参数进行注入，常用的对象如下：

HttpServletRequest
HttpServletResponse
HttpSession

1
2
3
4
5
6
7


@RequestMapping("/quick16")
@ResponseBody
public void quickMethod16(HttpServletRequest request,HttpServletResponse response,HttpSession session){
    System.out.println(request);
    System.out.println(response);
    System.out.println(session);
}

获得请求头

使用@RequestHeader可以获得请求头信息，相当于request.getHeader(name)
@RequestHeader注解的属性如下：
- value：请求头的名称
- required：是否必须携带此请求头

1
2
3
4
5
6


@RequestMapping("/quick17")
@ResponseBody
public void quickMethod17(
    @RequestHeader(value = "User-Agent",required = false) String headerValue){
    System.out.println(headerValue);
}

使用@CookieValue可以获得指定Cookie的值
@CookieValue注解的属性如下：
- value：指定cookie的名称
- required：是否必须携带此cookie

1
2
3
4
5
6


@RequestMapping("/quick18")
@ResponseBody
public void quickMethod18(
    @CookieValue(value = "JSESSIONID",required = false) String jsessionid){
    System.out.println(jsessionid);
}

文件上传

文件上传客户端三要素：

表单项type="file"
表单的提交方式是post
表单的enctype属性是多部分表单形式，及enctype="multipart/form-data"

1
2
3
4
5


<form action="${pageContext.request.contextPath}/quick20" method="post" enctype="multipart/form-data">
    名称：<input type="text" name="name"><br>
    文件：<input type="file" name="file"><br>
    <input type="submit" value="提交"><br>
</form>

文件上传原理：

单文件上传

导入fileupload和io坐标：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.2.2</version>
</dependency>
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.4</version>
</dependency>

配置文件上传解析器：

1
2
3
4
5
6
7
8


<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <!--上传文件总大小-->
    <property name="maxUploadSize" value="5242800"/>
    <!--上传单个文件的大小-->
    <property name="maxUploadSizePerFile" value="5242800"/>
    <!--上传文件的编码类型-->
    <property name="defaultEncoding" value="UTF-8"/>
</bean>

编写文件上传代码：

1
2
3
4
5
6
7
8


@RequestMapping("/quick20")
@ResponseBody
public void quickMethod20(String name,MultipartFile uploadFile) throws IOException {
    //获得文件名称
    String originalFilename = uploadFile.getOriginalFilename();
    //保存文件
    uploadFile.transferTo(new File("C:\\upload\\"+originalFilename));
}

多文件上传

多文件上传，只需要将页面修改为多个文件上传项，将方法参数MultipartFile类型修改为MultipartFile[]即可：

1
2
3
4
5
6
7
8


<h1>多文件上传测试</h1>
<form action="${pageContext.request.contextPath}/quick21" method="post" enctype="multipart/form-data">
    名称：<input type="text" name="name"><br>
    文件1：<input type="file" name="uploadFiles"><br>
    文件2：<input type="file" name="uploadFiles"><br>
    文件3：<input type="file" name="uploadFiles"><br>
    <input type="submit" value="提交"><br>
</form>

1
2
3
4
5
6
7
8


@RequestMapping("/quick21")
@ResponseBody
public void quickMethod21(String name,MultipartFile[] uploadFiles) throws IOException {
    for (MultipartFile uploadFile : uploadFiles){
        String originalFilename = uploadFile.getOriginalFilename();
        uploadFile.transferTo(new File("C:\\upload\\"+originalFilename));
    }
}

SpringMVC拦截器

拦截器的作用

Spring MVC 的拦截器(interceptor)类似于 Servlet 开发中的过滤器 Filter，用于对处理器进行预处理和后处理
将拦截器按一定的顺序联结成一条链，这条链称为拦截器链（Interceptor Chain)
在访问被拦截的方法或字段时，拦截器链中的拦截器就会按其之前定义的顺序被调用
拦截器也是AOP思想的具体实现

拦截器快速入门

创建拦截器类实现HandlerInterceptor接口

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


public class MyHandlerInterceptor1 implements HandlerInterceptor {
    // 在目标方法执行之前 执行
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler){
        System.out.println("preHandle running...");
        return true; // 返回true代表放行 放回false代表不放行
    }
    // 在目标方法执行之后 视图对象返回之前执行
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
        System.out.println("postHandle running...");
    }
    // 在流程都执行完毕后 执行
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        System.out.println("afterCompletion running...");
    }
}

在springmvc.xml配置拦截器

1
2
3
4
5
6
7
8


<!--配置拦截器-->
<mvc:interceptors>
    <mvc:interceptor>
        <!--对哪些资源执行拦截操作-->
        <mvc:mapping path="/**"/>
        <bean class="one.wangyi.interceptor.MyHandlerInterceptor1"/>
    </mvc:interceptor>
</mvc:interceptors>

测试拦截器的拦截效果
- 编写一个MyHandlerInterceptor2操作，测试执行顺序(与spring-mvc.xml中的配置顺序相关)

SpringMVC异常处理

系统中异常包括两类：预期异常和运行时异常RuntimeException，前者通过捕获异常从而获取异常信息，后者主要通过规范代码开发、测试等手段减少运行时异常的发生
系统的Dao、Service、Controller出现异常都通过throws Exception向上抛出，最后由SpringMVC前端控制器交由异常处理器进行异常处理，如下图：

异常处理两种方式

使用Spring MVC提供的简单异常处理器SimpleMappingExceptionResolver
实现Spring的异常处理接口HandlerExceptionResolver自定义自己的异常处理器

简单异常处理器SimpleMappingExceptionResolver

SpringMVC已经定义好了该类型转换器，在使用时可以根据项目情况进行相应异常与视图的映射配置

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


<!--配置简单映射异常处理器-->
<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
    <!--配置默认错误视图-->
    <property name="defaultErrorView" value="error"/> 
    <property name="exceptionMappings">
        <map> 
            <!--配置异常类型和错误视图-->
            <entry key="one.wangyi.exception.MyException" value="error1"/>
            <entry key="java.lang.ClassCastException" value="error2"/>
        </map>
    </property>
</bean>

自定义异常处理

创建异常处理器类实现HandlerExceptionResolver

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


public class MyExceptionResolver implements HandlerExceptionResolver {
    @Override
    // Exception:异常对象;ModelAndView:跳转到错误视图
    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {

        //处理异常的代码实现

        //创建ModelAndView对象
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("exceptionPage");
        return modelAndView;
    }
}

在spring-mvc.xml配置异常处理器

1

<bean id="exceptionResolver" class="com.itheima.exception.MyExceptionResolver"/>

编写异常页面
测试异常跳转