1.SpringMVC框架简介

1.1.框架简介

Spring MVC 是 Spring 提供给 Web 应用的框架设计。。
Spring MVC 角色划分清晰，分工明细，并且和 Spring 框架无缝结合。作为当今业界最主流的 Web 开发框架，Spring MVC 已经成为当前javaWeb框架事实上的标准。

1.2.SpringMVC核心架构流程

01.SpringMVC框架 - 图1
springMVC核心架构的具体流程步骤如下：

首先用户发送请求——>DispatcherServlet（前端控制器），前端控制器收到请求后自己不进行处理，而是委托给其他的解析器进行处理，作为统一访问点，进行全局的流程控制；
DispatcherServlet——>HandlerMapping， HandlerMapping将会把请求映射为HandlerExecutionChain对象（包含一个Handler处理器（页面控制器）对象、多个HandlerInterceptor拦截器）对象，通过这种策略模式，很容易添加新的映射策略；
DispatcherServlet——>HandlerAdapter，HandlerAdapter将会把处理器包装为适配器，从而支持多种类型的处理器，即适配器设计模式的应用，从而很容易支持很多类型的处理器；
HandlerAdapter——>处理器功能处理方法的调用，HandlerAdapter将会根据适配的结果调用真正的处理器的功能处理方法，完成功能处理；并返回一个ModelAndView对象（包含模型数据、逻辑视图名）；
ModelAndView的逻辑视图名——> ViewResolver， ViewResolver将把逻辑视图名解析为具体的View，通过这种策略模式，很容易更换其他视图技术；
View——>渲染，View会根据传进来的Model模型数据进行渲染，此处的Model实际是一个Map数据结构，因此很容易支持其他视图技术；
返回控制权给DispatcherServlet，由DispatcherServlet返回响应给用户，到此一个流程结束。

1.3.前后端分离架构下的SpringMVC
上一节中，详细描述了SpringMVC的核心架构流程。但是要注意：这是非前后端分离模式下的SpringMVC核心架构。
所以，我们会看到：在Handler处理器执行后，返回一个ModelAndView；也就是说：在非前后端分离模式下，视图层是由服务器端控制的。
那么，在前后端分离模式下，视图层要分离出去，成为一个独立工程；或者说：视图层不在由服务器端控制。 所以，在前后端分离模式下，SpringMVC的核心架构流程修改如下：

本教程中，讲解的都是在前后端分离模式下的SpringMVC

2.SpringMVC框架实例
SpringMVC框架的开发有两种方式：
配置文件方式
注解方式

本教程中，只讲解注解方式。

2.1.创建Maven工程

01.SpringMVC框架 - 图3

注意：SpringMVC是Web工程，所以打包方式要选择 war 包。

01.SpringMVC框架 - 图4

注意：Maven创建Web工程后，需要手动添加 WEB-INF 目录与 web.xml 配置文件。

2.2.在pom.xml文件中添加依赖

<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.neusoft</groupId>
    <artifactId>smvc</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>
    <build>
        <plugins>
            <!-- 设置jdk版本 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>utf-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
    <properties>
        <spring.version>5.2.8.RELEASE</spring.version>
    </properties>
    <dependencies>
        <!-- 此依赖会关联引用Spring中的所有基础jar包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- spring-webmvc会依赖spring-web -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
    </dependencies>
</project>

2.3.配置SpringMVC前端控制器

在 web.xml 文件中配置 SpringMVC 前端控制器，也就是配置 DispatcherServlet 核心组件。

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 也可不配置参数，默认加载 /WEB-INF/springmvc-servlet.xml -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

01.SpringMVC框架 - 图5

2.4.创建SpringMVC配置文件

在resources文件夹下创建springmvc-servlet.xml 配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    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/context
                        http://www.springframework.org/schema/context/spring-context.xsd
                        http://www.springframework.org/schema/aop
                        http://www.springframework.org/schema/aop/spring-aop.xsd
                        http://www.springframework.org/schema/mvc
                        http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!-- 
           此标签能够自动加载注解的处理器映射和注解的处理器适配， 
          而且还默认加载了很多其他方法。 比如：参数绑定到控制器参数、json转换解析器
    -->                 
   <mvc:annotation-driven />
   <!-- 开启注解扫描，将包下带有@Controller注解的类纳入Spring容器中-->
   <context:component-scan base-package="com.neusoft.smvc.controller" />
</beans>

2.5.创建Handler处理器

在 com.neusoft.springmvc.controller 包下创建 HelloController 处理器。

package com.neusoft.smvc.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
public class HelloController {
    @ResponseBody
    @RequestMapping("/hello")
    public String hello() throws Exception {
        return "hello world!";
    }
}

@Controller：此注解声明在类上，表示此类是一个 Handler 处理器类，并被纳入到 Spring 容器中； @ResponseBody：此注解可以声明在类上，或者方法上；表示处理器方法直接返回数据。 @RequestMapping：此注解可以声明在类上，或者方法上；表示将一个请求url映射给处理器方法。

2.6.测试

将工程部署到Tomcat中，启动服务器，在浏览器地址栏中写入：http://localhost:8080/smvc/hello

2.7.相关注解详解

2.7.1.@ResponseBody注解

@responseBody注解的作用是将controller的方法返回的数据写入到response对象的body区，也就是直接将数据写入到输出流中，效果等同于使用 response.getWriter() 输出流对象向前端返回数据。需要注意的是，在使用此注解之后，响应不会再走视图处理器。

@responseBody 应用在处理器类上：此处理器类中的所有方法都直接返回数据。
@responseBody 应用在处理器类的某个方法上：此处理器类中的某个方法直接返回数据。

2.7.2.@RequestMapping注解
用于建立请求URL和处理器方法之间的对应关系。
@RequestMapping 应用在处理器类上：设置请求URL的第一级访问目录。此处不写的话，就相当于应用的根目录。写的话需要以 / 开头。它出现的目的是为了使我们的URL可以按照模块化管理。
```
@Controller
@RequestMapping("/user")
public class HelloController {
 @ResponseBody
 @RequestMapping("/hello")
 public String hello() throws Exception {
     return "hello world";
 }
}
```
上面处理器方法请求url应该这样写：http://localhost:8080/springmvc/user/hello
@RequestMapping 应用在处理器类的某个方法上：请求URL的第二级访问目录。
@RequestMapping注解中常用属性有：
value：用于指定请求的URL。 method：用于指定请求的方式。
```
@ResponseBody
@RequestMapping(value="/hello",method=RequestMethod.POST)
public String hello() throws Exception {
 return "hello world";
}
```
如果使用 get 方式访问此处理器方法时（比如：在地址栏中输入url访问），就会出现异常。

2.7.3.@GetMapping与@PostMapping

@GetMapping是一个组合注解，是@RequestMapping(method = RequestMethod.GET)的缩写。
@PostMapping是一个组合注解，是@RequestMapping(method = RequestMethod.POST)的缩写。

3.处理器方法的参数与返回值

3.1.处理器方法参数

SpringMVC也是基于Spring的，所以可以直接给处理器方法注入参数，自动绑定默认支持的各种数据类型。这些默认支持的数据类型，或者说可以注入的对象类型有：

HttpServletRequest对象。
HttpServletResponse对象。
HttpSession对象。（注意：ServletContext不会注入。）
简单数据类型。作用：获取客户端提交的单值参数。
```
public String hello(String userName,String password) throws Exception {}
```
注意：处理器方法的参数名必须与提交参数名一致。测试：http://localhost:8080/springmvc/user/hello?userName=zhangsan&password=123

5.数组类型。作用：获取客户端提交的多值参数。
```
public String hello(Integer[] aihao) throws Exception {}
```
注意：处理器方法的参数名必须与提交参数名一致。测试：http://localhost:8080/springmvc/user/hello?aihao=1&aihao=2&aihao=3

6.对象类型。作用：获取客户端提交参数。
```
public String hello(User user) throws Exception {}
```
注意：处理器方法的参数名可以任意，但参数中的属性名必须与提交参数名一致。测试：http://localhost:8080/springmvc/user/hello?userId=1&userName=zhangsan&password=123

3.2.使用@RequestParam匹配参数

获取客户端提交参数时，处理器的参数名必须与提交参数名一致。但如果处理器的参数名与提交参数名不一致时，可以使用@RequestParam注解来匹配参数。

public String hello(@RequestParam("userName") String un, 
                    @RequestParam("password") String pw) throws Exception {}

注意：@RequestParam的value值必须与提交参数名一致。测试：http://localhost:8080/springmvc/user/hello?userName=zhangsan&password=123

3.3.接收AJAX提交json数据

在前后端分离项目中，前端的 ajax 会向服务器端提交 json 数据，SpringMVC也可以直接接收 json 数据。

注意：

提交的是json对象，所以 SpringMVC 也必须要使用对象来接收。
需要添加CORS过滤器，设置服务器端允许跨域（需要导入servlet-api.jar）。

pom.xml中添加servlet-api依赖

<dependency>
 <groupId>javax.servlet</groupId>
 <artifactId>javax.servlet-api</artifactId>
 <version>4.0.0</version>
 <scope>provided</scope>
</dependency>

添加CORS过滤器

package com.neusoft.smvc.filter;
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@WebFilter("/*")
public class CorsFilter implements Filter {
 @Override
 public void init(FilterConfig filterConfig) throws ServletException {}
 @Override
 public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
         throws IOException, ServletException {
     HttpServletRequest request = (HttpServletRequest)req;
     HttpServletResponse response = (HttpServletResponse)resp;
     //设置允许跨域
     response.setHeader("Access-Control-Allow-Origin",request.getHeader("Origin"));
     //设置开启Cookie
     response.setHeader("Access-Control-Allow-Credentials", "true"); 
     chain.doFilter(req, resp);    
 }
 @Override
 public void destroy() {}
}

SpringMVC处理器中要使用对象接收提交的json数据
```
public String hello(User user) throws Exception {}
```

使用Axios提交

<button onclick="hello()">提交</button>
<script src="https://unpkg.com/axios/dist/axios.js"></script>
<script src="https://cdn.bootcss.com/qs/6.5.1/qs.min.js"></script>
<script>
 let user = {
     userId:1,
     userName:'zhangsan',
     password:'123'
 };
 function hello() {
     axios.post('http://localhost:8080/smvc/user/hello',Qs.stringify(user))
         .then(response=>{
             console.log(response.data);
         }).catch(error=>{
             console.log(error);
         });    
     /*
     axios.get('http://localhost:8080/smvc/user/hello',{params:user})
         .then(response=>{
             console.log(response.data);
         }).catch(error=>{
             console.log(error);
         });
     */
 }
</script>

3.4.处理器方法返回值

SpringMVC的处理器方法可以返回 ModelAndView ，也可以直接返回数据。在前后端分离模式中，SpringMVC的处理器方法直接返回数据。所以，返回 ModelAndView 的情况不做讨论。

返回 String
上面实例中，SpringMVC的处理器方法就是直接返回String。

返回 json
首先，在 pom.xml 文件中添加 jackson 依赖：

<!-- jackson相关依赖 -->
<dependency>
 <groupId>com.fasterxml.jackson.core</groupId>
 <artifactId>jackson-databind</artifactId>
 <version>2.9.0</version>
</dependency>

服务器端代码：

//返回值设置为对象或者集合
@ResponseBody
@RequestMapping("/hello")
public User hello(User user) throws Exception {
System.out.println(user);
 return user;
}
/*
@ResponseBody
@RequestMapping("/hello")
public List<User> hello(User user) throws Exception {
 List<User> list = new ArrayList<>();
 list.add(user);
 list.add(user);
 list.add(user);
 return list;
}
*/

前端代码：
```
axios.post('http://localhost:8080/smvc/user/hello',Qs.stringify(user))
 .then(response=>{
     console.log(response.data);
 }).catch(error=>{
     console.log(error);
 });
```
注意：
1. springmvc-servlet.xml 配置文件中必须要有 mvc:annotation-driven 标签配置。这里配置了json转换解析器。
2. 只要 SpringMVC 的处理器返回值设置为对象，或者集合，那么就能返回 json 数据。

4.SpringMVC文件上传

4.1.添加文件上传jar包依赖

<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>

4.2.配置文件上传解析器

在springmvc-servlet.xml 配置文件中配置文件上传解析器。

<!--必须要有此id名 -->
<bean id="multipartResolver"
    class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <!--上传文件大小限制，单位：字节 -->
    <property name="maxUploadSize" value="5000000"></property>
</bean>

4.3.创建上传文件处理器

package com.neusoft.smvc.controller;
import java.io.File;
import java.util.UUID;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;
@Controller
public class UploadController {
    @ResponseBody
    @RequestMapping("/upload")
    // 必须要有MultipartFile类型参数。而且参数名必须与表单file控件名一致
    public String upload(MultipartFile myFile) {
        //上传图片存储目录
        String path = "d:/upload";
        //获取文件名并使用UUID生成新文件名
        String fileName = myFile.getOriginalFilename();
        String newFileName = UUID.randomUUID() + fileName.substring(fileName.lastIndexOf("."));
        //在指定上传图片存储目录中创建新文件
        File targetFile = new File(path, newFileName);
        //如果找不到指定目录和文件，就新创建此目录和文件
        if (!targetFile.exists()) {
            targetFile.mkdirs();
        }
        //将文件写入硬盘（myFile在内存中）
        try {
            myFile.transferTo(targetFile);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "ok";
    }
}

4.4.客户端表单提交

<form action="http://localhost:8080/smvc/upload" enctype="multipart/form-data" method="post">
    <input type="file" name="myFile"><br>
    <input type="submit" value="上传">
</form>

注意：

enctype：设置表单的MIME编码。
默认情况，这个编码格式是application/x-www-form-urlencoded（标准键值对格式），不能用于文件上传；只有使用了multipart/form-data，才能上传二进制数据;
method：必须为post方式提交。

5.SpringMVC拦截器

早期MVC框架将一些通用操作写死在核心控制器中，致使框架灵活性不足、可扩展性降低。
Spring将预处理与后处理功能放到多个拦截器中实现，拦截器可自由选择和组合，增强了灵活性，有利于系统的解耦。SpringMVC的拦截器类似于Servlet中的过滤器Filter，用于对处理器进行预处理和后处理。

5.1.创建SpringMVC拦截器

创建 SpringMVC 拦截器，只需要实现 HandlerInterceptor 接口即可。接口中有三个方法需要实现：

preHandle：该方法在 controller 执行前执行，可以实现对数据的预处理。如果方法返回 true ，则继续调用下一个资源。否则不在继续调用。
postHandle：该方法在处理器执行后，生成视图前执行。这里有机会修改视图层数据。

afterCompletion：最后执行，通常用于记录日志，释放资源，处理异常。

package com.neusoft.springmvc.interceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
public class CorsInterceptor implements HandlerInterceptor{
 @Override
 public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
     System.out.println("在到达处理器之前做前置工作");
     return true;
 }
 @Override
 public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,ModelAndView modelAndView) throws Exception {}
 @Override
 public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)throws Exception {}
}

5.2.配置SpringMVC拦截器

在springmvc-servlet.xml 配置文件中配置 SpringMVC 拦截器。

<!-- 可以配置多个拦截器 -->  
<mvc:interceptors>
 <mvc:interceptor>
     <mvc:mapping path="/**" />
     <bean class="com.neusoft.springmvc.interceptor.CorsInterceptor" />
 </mvc:interceptor>
</mvc:interceptors>

01.SpringMVC框架 - 图6

5.3.拦截器与过滤器的区别

Filter是Servlet容器的，Interceptor是SpringMvc实现的(结合springBoot看)
Filter对所有请求起作用，Intercptor可以设置拦截规则，而且只对经过DispatchServlet的请求起作用。
Filter只能拿到request和response，interceptor可以拿到整个请求上下文，包括request和response。
Filter是基于函数回调，Interceptor是基于反射(AOP思想)

6.RESTful互联网软件架构

6.1.什么是REST
REST（Representational State Transfer 表现层状态转化）：是一种互联网软件架构规范。
如果按照上面的字面含义去理解，那是永远也无法理解的。实际上，REST省略的主语。REST的全称应该是 Resource Representational State Transfer。通俗来讲就是：资源在网络中以某种表现形式进行状态转移。
所以，REST包含三个结构：
资源（Resources）：
资源是 RESTful 的主体，主要指代互联网上的一个实体，可以是一段文本、一张图片、一首歌曲、一种服务，总之就是一个具体的实在。资源通过 URI 来唯一标识。
表现层（Representation）
资源的信息载体形式，叫做表现层。它可以是文本、XML、JSON 或者是一个二进制文件。它的具体表现形式，应该在HTTP请求的头信息中用Accept和Content-Type字段指定，这两个字段才是对”表现层”的描述。
状态转化（State Transfer）
互联网通信协议HTTP协议，是一个无状态协议。这意味着，所有的状态都保存在服务器端。因此，如果客户端想要操作服务器，必须通过某种手段，让服务器端发生”状态转化”（State Transfer）。而这种转化是建立在表现层之上的，所以就是”表现层状态转化”。

REST：是一种为了让信息在互联网上顺利传递而设计的软件架构风格，即一种采用标准URI进行调用的规范。

注意，它并不是一个框架，它只是一种理念。它结构清晰、符合标准、易于理解、扩展方便，所以正得到越来越多网站的采用。

6.2.RESTful架构

如果一个互联网软件架构符合REST原则，就称它为RESTful架构。

具体来说：RESTful架构的规范与约束要求我们：

对url进行规范，写出符合RESTful格式的url。
优雅RESTful风格的资源URL不希望带 .html 或 .do 或？或& 等后缀。
指定请求资源格式。也就是说：在RESTful架构中，每个URI代表一种资源，客户端通过四个HTTP方法（四个动词），对服务器端资源进行操作：
- GET用来获取资源；
- POST用来新建资源（也可以用于更新资源）；
- PUT用来更新资源；
- DELETE用来删除资源；
  6.2.使用RESTful风格URL

前端控制器url映射配置必须为 “/” ,不能是 .do 或 .action 等后缀

<servlet-mapping>
 <servlet-name>springmvc</servlet-name>
 <url-pattern>/</url-pattern>
</servlet-mapping>

客户端提交方式：

http://localhost:8080/springmvc/hello/zhangsan/123

处理器接收参数方式：

@ResponseBody
@RequestMapping("/hello/{userName}/{password}")
public String hello(@PathVariable("userName") String userName,@PathVariable("password") String password) throws Exception {
 System.out.println(userName+","+password);
 return "hello world!";
}

注意：
如果想支持put delete方式请求，需要在web.xml里新增如下的配置：

  <!--使⽤Rest风格的URI，将页⾯普通的post请求转为指定的delete或者put请求-->
<filter>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <servlet-name>springmvc</servlet-name>
</filter-mapping>
<filter>
    <filter-name>HttpPutFormContentFilter</filter-name>
    <filter-class>org.springframework.web.filter.HttpPutFormContentFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>HttpPutFormContentFilter</filter-name>
    <servlet-name>springmvc</servlet-name>
</filter-mapping>

本章作业

简单介绍下对springMVC的理解?
Spring MVC的主要组件有哪些？
SpringMVC如何通过AJAX向前端返回数据？
SpringMvc的控制器是不是单例模式,如果是,有什么问题,怎么解决？
如果在拦截请求中，想拦截get方式提交的方法,怎么配置？
怎样在Controller方法里面得到Request,或者Session？
SpingMvc中的控制器的注解一般用那个,有没有别的注解可以替代？
编程题：
1. 使用SpringMVC实现一个登录案例。
2. 使用前后端分离的模式实现。
3. 服务器端要有数据层组件、业务层组件、控制层组件。
4. 数据层组件中可以不真正的连接数据库，而是返回模拟数据。
5. 控制层组件要向前端返回json数据。
6. 前端使用ajax请求，并通过服务器端返回的json数据来判断是否登录成功。

01.SpringMVC框架