1、基本介绍

▶ 基本概念

springmvc是一种基于Java实现MVC模型的轻量级WEB框架

▷ 优点

● 使用简单、开发便捷(相比于Servlet)
● 灵活性强

▷ 当前WEB程序的工作流程:

● 三层架构

○ web程序通过浏览器访问前端页面，发送异步请求到后端 服务器

○ 后台服务器采用三层架构进行功能开发
○表现层负责接收请求和数据然后将数据转交给业务层
○ 业务层负责调用数据层完成数据库表的增删改查，并将结果返给表现层
○ 表现层将数据转换成JSON格式返回给前端

○前端页面将数据进行解析最终展示给用户。

▷ 表现层与数据层的技术选型:

● 数据层采用mybatis框架
● 变现层采用SpringMVC框架，SpringMVC主要负责的内容有:
○controller如何接收请求和数据
○ 如何将请求和数据转发给业务层
○ 如何将响应数据转换成json发回到前端

▶ 程序流程

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

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

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

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

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

▶ 知识点

@Controller

@RequestMapping

@ResponseBody

▶ 入门案例

● AbstractDispatcherServletInitializer类是SpringMVC提供的快速初始化Web3.0容器的抽象类

● AbstractDispatcherServletInitializer提供三个接口方法供用户实现

○ createServletApplicationContext()方法，创建Servlet容器时，加载SpringMVC对应bean并放入WebApplicationContext对象范围中，而WebApplicationContext的作用范围为ServletContext范围，即整个web容器范围
protected WebApplicationContext createServletApplicationContext() {            AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();      ctx.reGISter(SpringMvcConfig.class);         return ctx; }
○ createRootApplicationContext()方法，如果创建Servlet容器时需要加载非SpringMVC对的bean，使用当前方法进行，使用方式同createServletApplicationContext()
protected WebApplicationContext createRootApplicationContext() {         return null; }
○ getServletMappings()方法，设定SpringMVC对应的请求映射路径，设置为/表示拦截所请求，任意请求都将转入到SpringMVC进行处理
protected String[] getServletMappings() {    return new String[]{"/"};}
2、工作流程

▶ 启动服务器初始化过程

服务器启动，执行ServletContainersInitConfig类，初始化web容器

执行createServletApplicationContext方法，创建了WebApplicationContext对象

● 该方法加载SpringMVC的配置类SpringMvcConfig来初始化SpringMVC的容器

加载SpringMvcConfig配置类

执行@ComponentScan加载对应的bean

● 扫描指定包下所有类上的注解，如Controller类上的@Controller注解

加载UserController，每个@RequestMapping的名称对应一个具体的方法

● 此时就建立了 `/save` 和 save方法的对应关系

执行getServletMappings方法，定义所有的请求都通过SpringMVC

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

▶ 单次请求过程

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

3、bean加载控制

▶ Controller加载控制与业务bean加载控制

● SpringMVC相关bean（表现层bean）

● Spring控制的bean

○ 业务bean（Service）

○ 功能bean（DataSource等）

●SpringMVC相关bean加载控制

○ SpringMVC加载的bean对应的包均在com.itheima.controller包内

● Spring相关bean加载控制

○ 方式一：Spring加载的bean设定扫描范围为com.itheima，排除掉controller包内的bean

○ 方式二：Spring加载的bean设定扫描范围为精准范围，例如service包、dao包等

○ 方式三：不区分Spring与SpringMVC的环境，加载到同一个环境中

▶ 知识点

▶ bean的加载格式
public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {         protected WebApplicationContext createServletApplicationContext() {                AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();                ctx.register(SpringMvcConfig.class);                return ctx;        }        protected WebApplicationContext createRootApplicationContext() {                AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();                ctx.register(SprinGConfig.class);                return ctx;        }        protected String[] getServletMappings() {                return new String[]{"/"};        }}
▶ 简化开发
public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer{            protected Class[] getServletConfigClasses() {                       return new Class[]{SpringMvcConfig.class};            }            protected String[] getServletMappings() {                        return new String[]{"/"};            }            protected Class[] getRootConfigClasses() {                        return new Class[]{SpringConfig.class};            }}

二、请求

1、请求映射路径

2、请求方式

▶ Get请求

● 普通参数：url地址传参，地址参数名与形参变量名相同，定义形参即可接收参数
@RequestMapping("/commonParam")@ResponseBodypublic String commonParam(String name ,int age){        System.out.println("普通参数传递 name ==> "+name);        System.out.println("普通参数传递 age ==> "+age);        return "{'module':'common param'}";}
▶ post请求

● 普通参数：fORM表单post请求传参，表单参数名与形参变量名相同，定义形参即可接收参数
@RequestMapping("/commonParam")@ResponseBodypublic String commonParam(String name ,int age){        System.out.println("普通参数传递 name ==> "+name);        System.out.println("普通参数传递 age ==> "+age);        return "{'module':'common param'}";}
▶ Post请求中文乱码处理

● 为web容器添加过滤器并指定字符集，Spring-web包中提供了专用的字符过滤器
public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer{        // 配字符编码过滤器        protected Filter[] getServletFilters() {                CharacterEncodingFilter filter = new CharacterEncodingFilter();                filter.setEncoding("utf-8");                return new Filter[]{filter};        }}
3、请求参数

▶ 普通参数：url地址传参，地址参数名与形参变量名相同，定义形参即可接收参数
@RequestMapping("/commonParam")@ResponseBody public String commonParam(String name ,int age){         System.out.println("普通参数传递 name ==> "+name);        System.out.println("普通参数传递 age ==> "+age);        return "{'module':'common param'}";}
▶ 普通参数：请求参数名与形参变量名不同，使用@RequestParam绑定参数关系
@RequestMapping("/commonParamDifferentName")@ResponseBodypublic String commonParamDifferentName(@RequestParam("name")String userName , int age){        System.out.println("普通参数传递 userName ==> "+userName);        System.out.println("普通参数传递 age ==> "+age);        return "{'module':'common param different name'}";}
▶ @RequestParam

▶ POJO参数：请求参数名与形参对象属性名相同，定义POJO类型形参即可接收参数
@RequestMapping("/pojoParam")@ResponseBodypublic String pojoParam(User user){        System.out.println("pojo参数传递 user ==> "+user);        return "{'module':'pojo param'}";}
▶ 嵌套POJO参数：POJO对象中包含POJO对象

▶ 嵌套POJO参数：请求参数名与形参对象属性名相同，按照对象层次结构关系即可接收嵌套POJO属性参数
@RequestMapping("/pojoContainPojoParam")@ResponseBodypublic String pojoContainPojoParam(User user){        System.out.println("pojo嵌套pojo参数传递 user ==> "+user);        return "{'module':'pojo contain pojo param'}";}
▶ 数组参数：请求参数名与形参对象属性名相同且请求参数为多个，定义数组类型形参即可接收参数
@RequestMapping("/arrayParam")@ResponseBodypublic String arrayParam(String[] likes){        System.out.println("数组参数传递 likes ==> "+ Arrays.toString(likes));        return "{'module':'array param'}";}
▶ 集合保存普通参数：请求参数名与形参集合对象名相同且请求参数为多个，@RequestParam绑定参数关系
@RequestMapping("/listParam")@ResponseBodypublic String listParam(@RequestParam List likes){        System.out.println("集合参数传递 likes ==> "+ likes);        return "{'module':'list param'}";}
4、请求参数（传递json数据）

▶ 接收请求中的json数据

▷ ①：添加json数据转换相关坐标
      com.fasterxml.jackson.core      jackson-databind      2.9.0
▷ ②：设置发送json数据（请求body中添加json数据）

▷ ③：开启自动转换json数据的支持
@Configuration@ComponentScan("com.itheima.controller")@EnableWebMvcpublic class SpringMvcConfig {}
注意事项：@EnableWebMvc注解功能强大，该注解整合了多个功能，此处仅使用其中一部分功能，即json数据进行自动类型转换。

▷ ④：设置接收json数据
@RequestMapping("/listParamForJson")@ResponseBodypublic String listParamForJson(@RequestBody List likes){                     System.out.println("list common(json)参数传递 list ==> "+likes);        return "{'module':'list common for json param'}";}
▶ @EnableWebMvc

▶ @RequestBody

▶ POJO参数：json数据与形参对象属性名相同，定义POJO类型形参即可接收参数
@RequestMapping("/pojoParamForJson")@ResponseBodypublic String pojoParamForJson(@RequestBody User user){         System.out.println("pojo(json)参数传递 user ==> "+user);        return "{'module':'pojo for json param'}";}
▶ POJO集合参数：json数组数据与集合泛型属性名相同，定义List类型形参即可接收参数
@RequestMapping("/listPojoParamForJson")@ResponseBodypublic String listPojoParamForJson(@RequestBody List list){         System.out.println("list pojo(json)参数传递 list ==> "+list);        return "{'module':'list pojo for json param'}";}
▶ @RequestBody与@RequestParam区别

● 区别

○ @RequestParam用于接收url地址传参，表单传参【application/x-www-form-urlencoded】

○ @RequestBody用于接收json数据【application/json】

● 应用

○ 后期开发中，发送json格式数据为主，@RequestBody应用较广

○ 如果发送非json格式数据，选用@RequestParam接收请求参数

5、日期类型参数传递

▶ 参数传递

● 日期类型数据基于系统不同格式也不尽相同

○ 2088-08-18

○ 2088/08/18

○ 08/18/2088

● 接收形参时，根据不同的日期格式设置不同的接收方式
@RequestMapping("/dataParam")@ResponseBodypublic String dataParam(Date date,                @DateTimeFormat(pattern = "yyyy-MM-dd") Date date1,                                         @DateTimeFormat(pattern = "yyyy/MM/dd HH:mm:ss")Date date2){           System.out.println("参数传递 date ==> "+date);            System.out.println("参数传递 date(yyyy-MM-dd) ==> "+date1);        System.out.println("参数传递 date(yyyy/MM/dd HH:mm:ss) ==> "+date2);            return "{'module':'data param'}";}
Http://localhost/dataParam?date=2088/08/08&date1=2088-08-18&date2=2088/08/28 8:08:08
▶ @DateTimeFormat

▶ 类型转换器

● Converter接口
public interface Converter {        @Nullable        T convert(S var1);}
○ 请求参数年龄数据（String→Integer）

○ json数据转对象（json → POJO）

○ 日期格式转换（String → Date）

● @EnableWebMvc功能之一：根据类型匹配对应的类型转换器

三、响应

▶ 响应页面（了解）

@RequestMapping("/toPage")public String toPage(){        return "page.jsp";}

▶ 响应文本数据（了解）

@RequestMapping("/toText")@ResponseBodypublic String toText(){        return "response text";}

▶ 响应json数据（对象转json）

@RequestMapping("/toJsonPOJO")@ResponseBodypublic User toJsonPOJO(){        User user = new User();        user.setName("赵云");        user.setAge(41);        return user;}

▶ 响应json数据（对象集合转json数组）

@RequestMapping("/toJsonList")@ResponseBodypublic List toJsonList(){        User user1 = new User();        user1.setName("赵云");        user1.setAge(41);        User user2 = new User();        user2.setName("master 赵云");        user2.setAge(40);        List userList = new ArrayList();        userList.add(user1);        userList.add(user2);        return userList;}

▶ @ResponseBody

▶ HttpMessageConverter接口

public interface HttpMessageConverter {        boolean canRead(Class clazz, @Nullable MediaType mediaType);        boolean canWrite(Class clazz, @Nullable MediaType mediaType);        List getSupportedMediaTypes();        T read(Class clazz, HttpInputMessage inputMessage)                  throws IOException, HttpMessageNotReadableException;        void write(T t, @Nullable MediaType contentType, HttpOutputMessage outputMessage)                  throws IOException, HttpMessageNotWritableException; }

四、REST风格

1、REST简介

▶ 基本介绍

REST（Representational State Transfer），表现形式状态转换

● 传统风格资源描述形式

○ http://localhost/user/getById?id=1

○ http://localhost/user/saveUser

● REST风格描述形式

○ http://localhost/user/1

○ http://localhost/user

● 优点：

○ 隐藏资源的访问行为，无法通过地址得知对资源是何种操作

○ 书写简化

▶ 风格简介

上述行为是约定方式，约定不是规范，可以打破，所以称REST风格，而不是REST规范描述模块的名称通常使用复数，也就是加s的格式描述，表示此类资源，而非单个资源，例如：users、books、accounts……

2、RESTful入门案例

▶ ①：设定http请求动作（动词）
@RequestMapping(value = "/users", method = RequestMethod.POST)@ResponseBodypublic String save(@RequestBody User user){        System.out.println("user save..." + user);        return "{'module':'user save'}";}@RequestMapping(value = "/users" ,method = RequestMethod.PUT)@ResponseBody    public String update(@RequestBody User user){        System.out.println("user update..."+user);        return "{'module':'user update'}";}
▶ ②：设定请求参数（路径变量）
@RequestMapping(value = "/users/{id}" ,method = RequestMethod.DELETE) @ResponseBodypublic String delete(@PathVariable Integer id){        System.out.println("user delete..." + id);        return "{'module':'user delete'}";}
▶ @RequestMapping

▶ @PathVariable

▶ @RequestBody，@RequestParam，@PathVariable 三者区别

● 区别

○ @RequestParam用于接收url地址传参或表单传参

○ @RequestBody用于接收json数据

○ @PathVariable用于接收路径参数，使用{参数名称}描述路径参数

● 应用

○ 后期开发中，发送请求参数超过1个时，以json格式为主，@RequestBody应用较广

○ 如果发送非json格式数据，选用@RequestParam接收请求参数

○ 采用RESTful进行开发，当参数数量较少时，例如1个，可以采用@PathVariable接收请求径变量，通常用于传递id值

3、RESTful快速开发

▶ 快速开发

▶ @RestController

▶ @GetMapping @PostMapping @PutMapping @DeleteMapping

▶ 基于RESTful页面数据交互

①：制作SpringMVC控制器，并通过PostMan测试接口功能

②：设置对静态资源的访问放行

③：前端页面通过异步提交访问后台控制器

五、拦截器

1、拦截器概念

▶ 基本介绍

(1)浏览器发送一个请求会先到Tomcat的web服务器

(2)Tomcat服务器接收到请求以后，会去判断请求的是静态资源还是动态资源

(3)如果是静态资源，会直接到Tomcat的项目部署目录下去直接访问

(4)如果是动态资源，就需要交给项目的后台代码进行处理

(5)在找到具体的方法之前，我们可以去配置过滤器(可以配置多个)，按照顺序进行执行

(6)然后进入到到中央处理器(SpringMVC中的内容)，SpringMVC会根据配置的规则进行拦截

(7)如果满足规则，则进行处理，找到其对应的controller类中的方法进行执行,完成后返回结果

(8)如果不满足规则，则不进行处理

(9)这个时候，如果我们需要在每个Controller方法执行的前后添加业务，具体该如何来实现?

这个就是拦截器要做的事。

▷ 拦截器（Interceptor）是一种动态拦截方法调用的机制，在SpringMVC中动态拦截控制器方法的执行
● 作用:
○ 在指定的方法调用前后执行预先设定的代码
○ 阻止原始方法的执行
○ 总结：拦截器就是用来做增强

▶ 拦截器和过滤器之间的区别是什么?

● 归属不同：Filter属于Servlet技术，Interceptor属于SpringMVC技术
● 拦截内容不同：Filter对所有访问进行增强，Interceptor仅针对SpringMVC的访问进行增强

2、拦截器开发

▶ 步骤1 : 创建拦截器类

让类实现HandlerInterceptor接口，重写接口中的三个方法。
@Component//定义拦截器类，实现HandlerInterceptor接口//注意当前类必须受Spring容器控制public class ProjectInterceptor implements HandlerInterceptor {    @Override    //原始方法调用前执行的内容    public boolean preHandle(httpservletRequest request, HttpServletResponse response, Object handler) throws Exception {        System.out.println("preHandle...");        return true;    }    @Override    //原始方法调用后执行的内容    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {        System.out.println("postHandle...");    }    @Override    //原始方法调用完成后执行的内容    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {        System.out.println("afterCompletion...");    }}
注意: 拦截器类要被SpringMVC容器扫描到。

▶步骤2 : 配置拦截器类
@Configurationpublic class SpringMvcSupport extends WebMvcConfigurationSupport {    @Autowired    private ProjectInterceptor projectInterceptor;    @Override    protected void addResourceHandlers(ResourceHandlerRegistry registry) {        registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");    }    @Override    protected void addInterceptors(InterceptorRegistry registry) {        //配置拦截器        registry.addInterceptor(projectInterceptor).addPathPatterns("/books" );    }}
▶步骤3 : SpringMVC添加SpringMvcSupport包扫描
@Configuration@ComponentScan({"com.itheima.controller","com.itheima.config"})@EnableWebMvcpublic class SpringMvcConfig{   }
▶ 步骤4 : 运行程序测试

使用PostMan发送`http://localhost/books`

如果发送`http://localhost/books/100`会发现拦截器没有被执行，原因是拦截器的`addPathPatterns`方法配置的拦截路径是`/books`,我们现在发送的是`/books/100`，所以没有匹配上，因此没有拦截，拦截器就不会执行。

▶ 步骤5 : 修改拦截器拦截规则
@Configurationpublic class SpringMvcSupport extends WebMvcConfigurationSupport {    @Autowired    private ProjectInterceptor projectInterceptor;    @Override    protected void addResourceHandlers(ResourceHandlerRegistry registry) {        registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");    }    @Override    protected void addInterceptors(InterceptorRegistry registry) {        //配置拦截器        registry.addInterceptor(projectInterceptor).addPathPatterns("/books","/books/*" );    }}
这个时候，如果再次访问`http://localhost/books/100`，拦截器就会被执行。拦截器中的`preHandler`方法，如果返回true,则代表放行，会执行原始Controller类中要请求的方法，如果返回false，则代表拦截，后面的就不会再执行了。

▶ 步骤6 : 简化SpringMvcSupport的编写
@Configuration@ComponentScan({"com.itheima.controller"})@EnableWebMvc//实现WebMvcConfigurer接口可以简化开发，但具有一定的侵入性public class SpringMvcConfig implements WebMvcConfigurer {    @Autowired    private ProjectInterceptor projectInterceptor;    @Override    public void addInterceptors(InterceptorRegistry registry) {        //配置多拦截器        registry.addInterceptor(projectInterceptor).addPathPatterns("/books","/books/*");    }}
▶ 拦截器的执行流程

当有拦截器后，请求会先进入preHandle方法，

如果方法返回true，则放行继续执行后面的handle[controller的方法]和后面的方法

如果返回false，则直接跳过后面方法的执行。

3、拦截器参数

▶ 前置处理方法

原始方法之前运行preHandle
public boolean preHandle(HttpServletRequest request,                         HttpServletResponse response,                         Object handler) throws Exception {    System.out.println("preHandle");    return true;}
● request:请求对象
● response:响应对象
● handler:被调用的处理器对象，本质上是一个方法对象，对反射中的Method对象进行了再包装

使用request对象可以获取请求数据中的内容，如获取请求头的`Content-Type`
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {    String contentType = request.getHeader("Content-Type");    System.out.println("preHandle..."+contentType);    return true;}
使用handler参数，可以获取方法的相关信息
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {    HandlerMethod hm = (HandlerMethod)handler;    String methodName = hm.getMethod().getName();//可以获取方法的名称    System.out.println("preHandle..."+methodName);    return true;}
▶ 后置处理方法

原始方法运行后运行，如果原始方法被拦截，则不执行
public void postHandle(HttpServletRequest request,                       HttpServletResponse response,                       Object handler,                       ModelAndView modelAndView) throws Exception {    System.out.println("postHandle");}
前三个参数和上面的是一致的。

modelAndView : 如果处理器执行完成具有返回结果，可以读取到对应数据与页面信息，并进行调整。因为现在都是返回json数据，所以该参数的使用率不高。

▶ 完成处理方法

拦截器最后执行的方法，无论原始方法是否执行
public void afterCompletion(HttpServletRequest request,                            HttpServletResponse response,                            Object handler,                            Exception ex) throws Exception {    System.out.println("afterCompletion");}
前三个参数与上面的是一致的。

ex : 如果处理器执行过程中出现异常对象，可以针对异常情况进行单独处理，因为我们现在已经有全局异常处理器类，所以该参数的使用率也不高。

这三个方法中，最常用的是preHandle,在这个方法中可以通过返回值来决定是否要进行放行，我们可以把业务逻辑放在该方法中，如果满足业务则返回true放行，不满足则返回false拦截。

4、拦截器链配置

▶ 配置多个拦截器

▷ 步骤1 : 创建拦截器类

实现接口，并重写接口中的方法
@Componentpublic class ProjectInterceptor2 implements HandlerInterceptor {    @Override    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {        System.out.println("preHandle...222");        return false;    }    @Override    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {        System.out.println("postHandle...222");    }    @Override    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {        System.out.println("afterCompletion...222");    }}
▷ 步骤2 : 配置拦截器类
@Configuration@ComponentScan({"com.itheima.controller"})@EnableWebMvc//实现WebMvcConfigurer接口可以简化开发，但具有一定的侵入性public class SpringMvcConfig implements WebMvcConfigurer {    @Autowired    private ProjectInterceptor projectInterceptor;    @Autowired    private ProjectInterceptor2 projectInterceptor2;    @Override    public void addInterceptors(InterceptorRegistry registry) {        //配置多拦截器        registry.addInterceptor(projectInterceptor).addPathPatterns("/books","/books/*");        registry.addInterceptor(projectInterceptor2).addPathPatterns("/books","/books/*");    }}
▷ 步骤3 : 运行程序，观察顺序

拦截器执行的顺序是和配置顺序有关。先进后出。

● 当配置多个拦截器时，形成拦截器链
● 拦截器链的运行顺序参照拦截器添加顺序为准
● 当拦截器中出现对原始处理器的拦截，后面的拦截器均终止运行
● 当拦截器运行中断，仅运行配置在前面的拦截器的afterCompletion操作

● preHandle ：与配置顺序相同，必定运行

● postHandle : 与配置顺序相反，可能不运行

● afterCompletion : 与配置顺序相反，可能不运行。