【狂神说：秦疆】SpringMVC笔记

凉水不好喝

已于 2022-07-07 15:55:36 修改

阅读量1.7k

点赞数 2

分类专栏： SSM学习笔记文章标签： mvc 前端 java

于 2022-03-10 22:16:10 首次发布

本文链接：https://blog.csdn.net/qq_48575500/article/details/123413030

版权

SSM学习笔记专栏收录该内容

14 篇文章 3 订阅

订阅专栏

SpringMVC（SpringMVC执行流程）

1、什么是MVC

1.1、概念理解

MVC：

模型（model）一般是dao、service层
视图（view）一般是jsp页面
控制器（controller）一般是servlet
MVC是一种软件设计规范

使用这种规范的优点：

是将业务逻辑、数据，显示分离的组织代码方法
降低了视图和业务逻辑的双向耦合
它不是一种设计模式，而是一种架构模式，当然不同的MVC模式也存在差异

Model模型：

数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或者是JavaBean组件（包含数据和行为）
一般分为Dao层和Service层

View视图：

负责进行模型的展示

Controller控制：

接收用户请求，委托给模型进行处理（状态改变）。处理完之后把返回的模型数据给视图，由视图负责展示。
充当调度员的工作

最典型的MVC设计规范：jsp+servlet+javabean

在这里插入图片描述

1.2、Model1时代

Web早期开发中通常采用Model1
它主要分为两层：视图层、模型层
优点：架构简单，适合小型开发
缺点：jsp职责不单一，不便于维护，在该模式中jsp页面就相当于servlet

在这里插入图片描述

1.3、Model2时代

Model2把项目分为三部分：模型、视图、控制器

用户发送请求
Servlet接收请求数据，并调用对应的业务逻辑方法
业务处理完毕返回数据给Servlet
Servlet转向jsp，由jsp进行渲染
响应给前端更新后的页面

在这里插入图片描述

职责分析：

Controller控制器：

取得表单数据
调用对应逻辑
转向指定页面

Model模型：

业务逻辑
保存所需数据状态

View视图：

显示页面

Model2模型优点：

提高代码复用率和项目可扩展性
降低维护成本
java语言优势就是越复杂的项目越容易维护

1.4、回顾Servlet

1、新建一个Maven父工程，导入依赖

<dependencies>
   <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <version>4.12</version>
   </dependency>
   <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-webmvc</artifactId>
       <version>5.1.9.RELEASE</version>
   </dependency>
   <dependency>
       <groupId>javax.servlet</groupId>
       <artifactId>servlet-api</artifactId>
       <version>2.5</version>
   </dependency>
   <dependency>
       <groupId>javax.servlet.jsp</groupId>
       <artifactId>jsp-api</artifactId>
       <version>2.2</version>
   </dependency>
   <dependency>
       <groupId>javax.servlet</groupId>
       <artifactId>jstl</artifactId>
       <version>1.2</version>
   </dependency>
</dependencies>

2、建立一个Moudle：SpringMVC_01，添加Web APP的支持

在这里插入图片描述

3、导入servlet/jsp依赖

<dependency>
   <groupId>javax.servlet</groupId>
   <artifactId>servlet-api</artifactId>
   <version>2.5</version>
</dependency>
<dependency>
   <groupId>javax.servlet.jsp</groupId>
   <artifactId>jsp-api</artifactId>
   <version>2.2</version>
</dependency>

4、编写Servlet类，来接收用户请求

public class MyServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //取得参数
        String method = req.getParameter("method");

        if (method.equals("add")){
            req.getSession().setAttribute("msg","执行了add方法");
        }

        if (method.equals("delete")){
            req.getSession().setAttribute("msg","执行了delete方法");
        }
        //业务逻辑
        //视图跳转（请求转发、重定向）
        req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req,resp);
    }
}

5、编写jsp页面来进行验证（一般公共的jsp页面直接放在web文件夹下，如果不想要让别人看见，就放在WEB-INF文件夹下）

在这里插入图片描述

6、在web.xml中注册Servlet

<servlet>
  <servlet-name>HelloServlet</servlet-name>
  <servlet-class>com.my.servlet.MyServlet</servlet-class>
</servlet>
<servlet-mapping>
  <servlet-name>HelloServlet</servlet-name>
  <url-pattern>/user</url-pattern>
</servlet-mapping>

7、配置Tomcat，并启动测试

在这里插入图片描述

1.5、MVC框架要做哪些事情

将url映射到java类或java类的方法
封装用户提交的数据
处理请求-调用相应的业务方法-封装相应数据
将响应数据进行渲染到表示层数据

说明：常见的服务器端MVC框架：Struts2、SpringMVC、ASP.NET MVC…；常见前端MVC框架：vue、angularjs、react…；由MVC演化出的另外一些模式：MVP、MVVM等

2、什么是SpringMVC

2.1、概述

在这里插入图片描述

Spring MVC是Spring Framework的一部分，是基于Java实现MVC的轻量级Web框架

官方文档：https://docs.spring.io/spring/docs/5.2.0.RELEASE/spring-framework-reference/web.html#spring-web（4.3.24）

Spring MVC特点：

轻量级，简单易学
高效，基于请求响应的MVC框架
与Spring兼容性好，无缝结合（Spring大杂烩，我们可以将Spring MVC所有的bean注册到Spring容器中）
约定大于配置
功能强大：RESTful、数据验证、格式化、本地化等等
简洁灵活

Spring的Web框架围绕DispatcherServlet【调度Servlet】设计---->没有什么是“加一层”解决不了的

DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解形式进行开发，十分简洁

正因为SpringMVC好 , 简单 , 便捷 , 易学 , 天生和Spring无缝集成(使用SpringIoC和Aop) , 使用约定优于配置 . 能够进行简单的junit测试 . 支持Restful风格 .异常处理 , 本地化 , 国际化 , 数据验证 , 类型转换 , 拦截器等等…所以我们要学习

2.2、中心控制器

只要是实现Servlet接口的实现类都是一个Servlet

在这里插入图片描述

2.3、Spring MVC原理

当发起请求时被前置的控制器拦截到请求，根据请求参数生成代理请求，找到请求对应的实际控制器，控制器处理请求，创建数据模型，访问数据库，将模型响应给中心控制器，控制器使用模型与视图渲染视图结果，将结果返回给中心控制器，再将结果返回给请求者。

在这里插入图片描述

2.4、Spring MVC执行原理

在这里插入图片描述

图为SpringMVC的一个较完整的流程图，实线表示SpringMVC框架提供的技术，不需要开发者实现，虚线表示需要开发者实现

DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心；用户发出请求，DispatcherServlet接收请求并拦截请求
说明：
- 假设请求的url为 : http://localhost:8080/SpringMVC/hello
- url拆分成三部分：
  - http://localhost:8080 ------> 服务器域名
  - SpringMVC ------> 部署在服务器上的web站点
  - hello ------> 表示控制器
- 通过分析，如上url表示为：请求位于服务器localhost:8080上的SpringMVC站点的hello控制器
HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping,HandlerMapping根据请求url查找Handler
HandlerExecution表示具体的Handler,其主要作用是根据url查找控制器，如上url被查找控制器为：hello
HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等
HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler（意思就是在实现Controller接口的类中找到对应的Handler）
Handler让具体的Controller执行（实现该接口的类执行）
Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView
HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet
DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名
视图解析器将解析的逻辑视图名传给DispatcherServlet
DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图
最终视图呈现给用户

3、第一个Spring MVC程序

3.1、详细步骤（“原理版”）

新建Module，添加Web支持
导入Spring MVC依赖

配置web.xml，注册DispatcherServlet

<!--1.注册DispatcherServlet-->
<!--配置DispatcherServlet：这个是SpringMVC的核心，请求分发器、前端控制器-->
<servlet>
  <servlet-name>springmvc</servlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  <!--关联一个springmvc的配置文件:【servlet-name】-servlet.xml-->
  <init-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:springmvc-servlet.xml</param-value>
  </init-param>
<!--启动级别设置为1：当服务器启动时，它的许多配置文件也回启动；设置为1就是让咱们的这个项目和这些配置文件一起启动;
意思就是运行Tomcat进行测试时，直接使用默认服务器进入index.jsp
-->
  <load-on-startup>1</load-on-startup>
</servlet>
<!--注意：在SpringMVC中，/和/*的区别：
        /：只匹配所有的请求，不去匹配.jsp页面
        /*：匹配所有的请求，包括.jsp页面
-->
<servlet-mapping>
  <servlet-name>springmvc</servlet-name>
  <url-pattern>/</url-pattern>
</servlet-mapping>

编写Spring MVC的配置文件：springmvc-servlet.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"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>

添加处理映射器（SpringMVC的核心三要素）

<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>

添加处理适配器（SpringMVC的核心三要素）

<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

添加视图解析器（SpringMVC的核心三要素）

<!--视图解析器:DispatcherServlet给他的ModelAndView--><bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">   <!--前缀-->   <property name="prefix" value="/WEB-INF/jsp/"/>   <!--后缀-->   <property name="suffix" value=".jsp"/>
</bean>

编写操作业务controller

//注意：这里我们先实现Controller接口！
public class MyController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        //ModelAndView：模型和视图
        ModelAndView modelAndView = new ModelAndView();

        //封装对象，放在modelAndView中
        modelAndView.addObject("msg","Spring MVC  Hello!");

        //封装要跳转的视图，放到ModelAndView中
        modelAndView.setViewName("hello");

        return modelAndView;

    }
}

将编写的类在Spring容器中进行bean注册

<!--    Handler-->
<bean id="/hello" class="com.my.controller.MyController"/>

编写要跳转的jsp页面
配置Tomcat，进行测试

3.2、可能遇到的问题

访问出现404：

查看控制台输出，查看是否缺少jar包
如果jar包存在，显示无法输出，就在IDEA项目中，添加lib依赖
重启Tomcat解决

3.3、详细步骤（注解版）

新建Module，添加Web支持

可能会存在Maven项目资源过滤问题（看有没有对应的报错）

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

导入相关依赖

配置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">

    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
<!--启动级别设置为1：当服务器启动时，它的许多配置文件也回启动；设置为1就是让咱们的这个项目和这些配置文件一起启动
    意思就是运行Tomcat进行测试时，直接使用默认服务器进入index.jsp-->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
<!--在SpringMVC中，/和/*的区别：-->
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

配置SpringMVC配置文件

<?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
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       https://www.springframework.org/schema/mvc/spring-mvc.xsd">
    
    <!-- 自动扫描包，让指定包下的注解生效,由IOC容器统一管理 -->
    <context:component-scan base-package="com.my.controller"/>

    <!-- 让Spring MVC不处理静态资源 :例如.mp3  .mp4  .css  .js  .html等等，来过滤这些静态资源-->
    <mvc:default-servlet-handler />

    <!--    支持mvc注解驱动
    在spring中一般采用@RequestMapping注解来完成映射关系
    要想使@RequestMapping注解生效
    必须向上下文中注册DefaultAnnotationHandlerMapping
    和一个AnnotationMethodHandlerAdapter实例
    这两个实例分别在类级别和方法级别处理。
    而annotation-driven配置帮助我们自动完成上述两个实例的注入。
    -->
    <mvc:annotation-driven />

    <!-- 视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <!-- 前缀 -->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!-- 后缀 -->
        <property name="suffix" value=".jsp"/>
    </bean>
    <!--这也是固定配置，需要修改的只有需要注入IOC的包-->
    
</beans>

创建Controller

@Controller
//@RequestMapping注解可以修饰类和方法，
// 这样的话，路径就存在“父子关系”，http://localhost:8080/项目名/hello/h1，
// 一般直接写在方法名上，便于排查
@RequestMapping("/hello")
public class AnnotationController {

    @RequestMapping("/h1")//真实访问地址：项目名/AnnotationController/hello
    public String Hello(Model model){
        //封装数据：向模型中添加msg和对应的值，可以在jsp页面中取出并渲染
        model.addAttribute("msg","Hello,Spring_Annotation");
        //：  /WEB-INF/jsp/hello.jsp
        return "hello";//会被视图解析器处理
    }
    @RequestMapping("/h2")
    public String Hello1(Model model){
        //封装数据
        model.addAttribute("msg","Hello,Spring_Annotation");
        return "hello";//会被视图解析器处理
    }
    @RequestMapping("/h3")
    public String Hello2(Model model){
        //封装数据
        model.addAttribute("msg","Hello,Spring_Annotation");
        return "hello";//会被视图解析器处理
    }
}

创建视图层（hello.jsp）
配置Tomcat测试执行

注意：在SpringMVC中，/和/*的区别

< url-pattern > / </ url-pattern > 不会匹配到.jsp，只针对我们编写的请求；即：.jsp 不会进入spring的 DispatcherServlet类
< url-pattern > /* </ url-pattern > 会匹配 *.jsp，会出现返回 jsp视图时再次进入spring的DispatcherServlet 类，导致找不到对应的controller所以报404错

小结：SpringMVC配置的三大件（处理器映射器、处理器适配器、视图解析器），通常我们使用注解的方式，只需要手动配置视图解析器即可，余下两个开启注解驱动即可！

4、控制器和RestFul

4.1、控制器（Controller）

控制器复杂提供访问应用程序的行为，通常通过接口定义或注解定义两种方法实现
控制器负责解析用户的请求并将其转换为一个模型
在Spring MVC中一个控制器类可以包含多个方法
在Spring MVC中，对于Controller的配置方式有很多种

4.2、实现Controller接口

Controller是一个接口，在org.springframework.web.servlet.mvc包下，接口中只有一个方法：

//实现该接口的类获得控制器功能
public interface Controller {
   //处理请求且返回一个模型与视图对象
   ModelAndView handleRequest(HttpServletRequest var1, HttpServletResponse var2) throws Exception;
}

步骤：

新建Module，添加Web支持
在web.xml文件中配置DispatcherServlet
编写SpringMVC配置文件：springmvc-servlet.xml==（只编写视图解析器，之前在上面加的处理器映射器。处理器适配器是为了讲解原理，现在可以省略也行）==
定义控制器（编写实现Controller接口的类。从而获取控制器功能）
编写在跳转的jsp页面
之后在springmvc-servlet.xml配置文件中，来注册bean
启动Tomcat，测试执行
具体示例参考：SpringMVC_04_Controller

说明：

实现接口Controller定义控制器是较老的办法
缺点：一个控制器中只有一个方法，如果要多个方法则需要定义多个Controller，会导致定义的方式比较麻烦

4.3、使用注解@Controller

@Controller注解：用于声明Spring类的实例是一个控制器（在讲IOC时还提到了另外3个注解）
Spring可以使用扫描机制来找到应用程序中所有基于注解的控制器类，为了保证Spring能找到你的控制器，需要在配置文件中声明组件扫描
```

<context:component-scan base-package="com.my.controller"/>
```

新建ControllerTest02类，使用注解方式

@Controller//代表这个类被Spring接管
/*
* 被这类注解的所有方法，如果返回值是String类型
* 并且有具体页面的话
* 那么返回的字符串就会被视图解析器跳转
* */
public class ControllerTest02 {

    @RequestMapping("/t1")
    public String test01(Model model){
        model.addAttribute("msg","ControllerTest02_t1");
        return "test";
    }

    @RequestMapping("/t2")
    public String test02(Model model){
        model.addAttribute("msg","ControllerTest02_t2");
        return "test";
    }
}

说明：通过这个类的示例可以看出，两个请求都可以使用同一个视图（test），但是页面的结果是不一样的（ControllerTest02_t1、ControllerTest02_t2）；从这里看出视图是被复用的，而控制器和视图之间是弱耦合关系

注解是平时最常用的方式！

4.4、RequestMapping

@RequestMapping注解用于映射url到控制器类或一个特定的处理程序方法。可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径

该注解同时作用在类和方法上：http://localhost:8080/c3/t1（访问格式）

@Controller
@RequestMapping("/c3")//http://localhost:8080/c3/t1
public class ControllerTest03 {

    @RequestMapping("/t1")
    public String test01(Model model){
        model.addAttribute("msg","ControllerTest03");
        return "test";
    }
}

该注解只作用在方法上：http://localhost:8080/t1（访问格式）

@Controller
//http://localhost:8080/t1
public class ControllerTest03 {

    @RequestMapping("/t1")
    public String test01(Model model){
        model.addAttribute("msg","ControllerTest03");
        return "test";
    }
}

4.5、RestFul风格

概念：

Restful就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制

功能：

资源：互联网所有事物都可以被抽象为资源
资源操作：使用POST/DELETE/PUT/GET，使用不同的方法对资源进行相应的操作；分别对应添加、删除、修改、查询

传统方式操作资源：通过不同的参数来实现不同的效果，方法单一，post、get

http://127.0.0.1/item/queryItem.action?id=1 查询,GET
http://127.0.0.1/item/saveItem.action 新增,POST
http://127.0.0.1/item/updateItem.action 更新,POST
http://127.0.0.1/item/deleteItem.action?id=1 删除,GET或POST

使用RestFul风格操作资源：

http://127.0.0.1/item/1 查询,GET
http://127.0.0.1/item 新增,POST
http://127.0.0.1/item 更新,PUT
http://127.0.0.1/item/1 删除,DELETE

通过测试来理解什么是RestFul风格：

新建一个类（RestFulController）

原来的请求方式和RestFul风格对比,以及了解什么是RestFul风格（使用 @PathVariable 注解，让方法参数的值对应绑定到一个URI模板变量上）

//原来的请求方式：http://localhost:8080/add?a=1&b=2
//RestFul风格：http://localhost:8080/add/3/4
@RequestMapping("/add/{a}/{b}")
public String test01(@PathVariable int a, @PathVariable int b, Model model){
  int result = a+b;
  model.addAttribute("msg","计算1结果："+result);
  return "test";
}

原来的风格->RestFul风格，映射访问路径必须是get请求；method属性指定请求的类型

方法级别的RequestMapping注解变体：@GetMapping 是一个组合注解，平时使用的会比较多；它所扮演的是 @RequestMapping(method =RequestMethod.GET) 的一个快捷方式

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping

//@RequestMapping(value/path = "/add/{a}/{b}",method = RequestMethod.GET)，映射访问路径必须是get请求，method属性指定请求的类型
@GetMapping("/add/{a}/{b}")
public String test02(@PathVariable int a, @PathVariable int b, Model model){
  int result = a+b;
  model.addAttribute("msg","计算2结果："+result);
  return "test";
}

@PostMapping ("/add/{a}/{b}")
public String test03(@PathVariable int a, @PathVariable int b, Model model){
  int result = a+b;
  model.addAttribute("msg","计算3结果："+result);
  return "test";
}

所有的地址栏请求默认都会是 HTTP GET 类型的

小结：使用这种风格的好处

使路径变得更加简洁
获得参数更加方便，框架会自动进行类型转换
通过路径变量的类型可以约束访问参数，如果类型不一样，则访问不到对应的请求方法；如这里访问是的路径是/add/1/a，则路径与方法不匹配，而不会是参数转换失败

扩展：小黄鸭调试法

5、结果跳转方式

5.1、ModelAndView

设置ModelAndView对象，根据ViewName和视图解析器来跳转对应的页面

视图解析器：页面（视图解析器前缀+ViewName+视图解析器后缀）

<!-- 视图解析器 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
     id="internalResourceViewResolver">
   <!-- 前缀 -->
   <property name="prefix" value="/WEB-INF/jsp/" />
   <!-- 后缀 -->
   <property name="suffix" value=".jsp" />
</bean>

对应的Controller类：

public class ControllerTest01 implements Controller {

   public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
       //返回一个模型视图对象
       ModelAndView mv = new ModelAndView();
       mv.addObject("msg","ControllerTest01");
       mv.setViewName("test");
       return mv;
  }
}

5.2、ServletAPI

通过设置ServletAPI , 不需要视图解析器

通过HttpServletResponse进行输出
通过HttpServletResponse实现重定向
通过HttpServletResponse实现转发

@Controller
public class ResultGo {

   @RequestMapping("/result/t1")
   public void test1(HttpServletRequest req, HttpServletResponse rsp) throws IOException {
       rsp.getWriter().println("Hello,Spring BY servlet API");
  }

   @RequestMapping("/result/t2")
   public void test2(HttpServletRequest req, HttpServletResponse rsp) throws IOException {
       rsp.sendRedirect("/index.jsp");
  }

   @RequestMapping("/result/t3")
   public void test3(HttpServletRequest req, HttpServletResponse rsp) throws Exception {
       //转发
       req.setAttribute("msg","/result/t3");
       req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,rsp);
  }
}

5.3、SpringMVC

通过SpringMVC来实现转发和重定向，无需视图解析器

1、测试（无视图解析器）：

请求转发（默认的）不需要特别声明
重定向需要特别声明：redirect

@Controller
public class ServletAPI2 {
    @RequestMapping("/m2/t1")
    public String test01(Model model){
        model.addAttribute("msg","SpringMVC方式实现结果跳转！test01");
        return "forward:/WEB-INF/jsp/test.jsp";//forward可省略！！！默认
    }

    @RequestMapping("/m2/t2")
    public String test02(Model model){
        model.addAttribute("msg","SpringMVC方式实现结果跳转！test02");
        return "redirect:/index.jsp";
    }
}

结论：

测试test01时，可以正常跳转，URL没有改变（http://localhost:8080/m2/t1）；请求转发
测试test02时，访问URL为：http://localhost:8080/m2/t2；进行重定向之后，URL发生改变：http://localhost:8080/index.jsp?msg=SpringMVC%3F%3F%3F%3F%3F%3F%3F%3F%3Ftest02

2、测试（有视图解析器）：

请求转发（默认的），不可以加上（原因：视图解析器拼接的思想）
重定向：有无视图解析器，写法都是一样的（反正都要转发到一个新地方）

    @RequestMapping("/m2/t3")
    public String test03(Model model){
        model.addAttribute("msg","SpringMVC方式实现结果跳转！test03");
        return "test";
    }

    @RequestMapping("/m2/t4")
    public String test04(Model model){
        model.addAttribute("msg","SpringMVC方式实现结果跳转！test04");
        return "redirect:/index.jsp";
    }

6、数据处理

6.1、处理前端提交的数据

前端提交的参数名（域名称）和后端方法参数名一致时

//http://localhost:8080/user/t1?name=麻腾飞
@RequestMapping("/t1")
public String test01(String name, Model model){
  //1、接收前端参数
  System.out.println("接收的前端参数为："+name);
  //2、将结果返回给前端
  model.addAttribute("msg",name);
  //3、视图跳转
  return "test";
}

前端提交的参数名（域名称）和后端方法参数名不一致时：@RequestParam

//http://localhost:8080/user/t2?username=麻腾飞
@RequestMapping("/t2")
//@RequestParam：该注解既可以表明前端需要操作该参数，也可以解决地址栏和方法参数名不一致的情况！
public String test02(@RequestParam("username") String name, Model model){
  model.addAttribute("msg",name);
  System.out.println("接收的前端参数为："+name);
  return "test";
}

当前端提交的是一个对象时（一个实体类的所有字段）

/*
    * 当前端传递的参数和方法名的参数一致时，则可以直接进行匹配使用
    * 当前端传递一个对象时，同时参数名也为对象类型，则前端会匹配对象实体类的字段
    *       前提是前端传递参数的字段名必须与实体类的字段名保持一致
    * */
//http://localhost:8080/user/t3?id=1&name=麻腾飞&age=18
@RequestMapping("/t3")
public String test03(User user){
  System.out.println("接收的前端参数为："+user);
  return "test";
}

6.2、数据显示到前端

Model

@RequestMapping("/ct2/hello")
public String hello(@RequestParam("username") String name, Model model){
   //封装要显示到视图中的数据
   //相当于req.setAttribute("name",name);
   model.addAttribute("msg",name);
   System.out.println(name);
   return "test";
}

ModelMap

@RequestMapping("/hello")
public String hello(@RequestParam("username") String name, ModelMap modelMap){
   //封装要显示到视图中的数据
   //相当于req.setAttribute("name",name);
   modelMap.addAttribute("name",name);
   System.out.println(name);
   return "hello";
}

ModelAndView

public class ControllerTest1 implements Controller {
   public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
       //返回一个模型视图对象
       ModelAndView mv = new ModelAndView();
       mv.addObject("msg","ControllerTest1");
       mv.setViewName("test");
       return mv;
  }
}

三种方式的对比：

Model 只有寥寥几个方法只适合用于储存数据，简化了新手对于Model对象的操作和理解；
ModelMap 继承了 LinkedMap ，除了实现了自身的一些方法，同样的继承 LinkedMap 的方法和特性；
ModelAndView 可以在储存数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转；

7、乱码问题

解决方式：

通过设置请求时的编码格式（Post提交方式中没有成功）

@PostMapping("/e/t2")
public String test02(String name, Model model, HttpServletRequest request) throws UnsupportedEncodingException {
  //第一种解决方式，没有成功！
  //request.setCharacterEncoding("utf-8");
  System.out.println(name);
  model.addAttribute("msg",name);
  return "test";
}

手动设置过滤器，并在web.xml进行引用（有效）

//第二种方式：通过手动设置过滤器，需要在web.xml文件中进行配置
public class EncodingFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        servletRequest.setCharacterEncoding("utf-8");
        servletResponse.setCharacterEncoding("utf-8");

        filterChain.doFilter(servletRequest,servletResponse);
    }

    @Override
    public void destroy() {

    }
}

<!--配值过滤器：EncodingFilter-->
<filter>
  <filter-name>encoding</filter-name>
  <filter-class>com.my.filter.EncodingFilter</filter-class>
</filter>
<filter-mapping>
  <filter-name>encoding</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

SpringMVC给我们提供了一个过滤器，只需要在web.xml进行配置即可（有效）

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

在网上下载大神码的自定义过滤器试试，只需要在web.xml进行相应配置就可以了（有效）

package com.kuang.filter;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Map;

/**
* 解决get和post请求 全部乱码的过滤器
*/
public class GenericEncodingFilter implements Filter {

   @Override
   public void destroy() {
  }

   @Override
   public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
       //处理response的字符编码
       HttpServletResponse myResponse=(HttpServletResponse) response;
       myResponse.setContentType("text/html;charset=UTF-8");

       // 转型为与协议相关对象
       HttpServletRequest httpServletRequest = (HttpServletRequest) request;
       // 对request包装增强
       HttpServletRequest myrequest = new MyRequest(httpServletRequest);
       chain.doFilter(myrequest, response);
  }

   @Override
   public void init(FilterConfig filterConfig) throws ServletException {
  }

}

//自定义request对象，HttpServletRequest的包装类
class MyRequest extends HttpServletRequestWrapper {

   private HttpServletRequest request;
   //是否编码的标记
   private boolean hasEncode;
   //定义一个可以传入HttpServletRequest对象的构造函数，以便对其进行装饰
   public MyRequest(HttpServletRequest request) {
       super(request);// super必须写
       this.request = request;
  }

   // 对需要增强方法 进行覆盖
   @Override
   public Map getParameterMap() {
       // 先获得请求方式
       String method = request.getMethod();
       if (method.equalsIgnoreCase("post")) {
           // post请求
           try {
               // 处理post乱码
               request.setCharacterEncoding("utf-8");
               return request.getParameterMap();
          } catch (UnsupportedEncodingException e) {
               e.printStackTrace();
          }
      } else if (method.equalsIgnoreCase("get")) {
           // get请求
           Map<String, String[]> parameterMap = request.getParameterMap();
           if (!hasEncode) { // 确保get手动编码逻辑只运行一次
               for (String parameterName : parameterMap.keySet()) {
                   String[] values = parameterMap.get(parameterName);
                   if (values != null) {
                       for (int i = 0; i < values.length; i++) {
                           try {
                               // 处理get乱码
                               values[i] = new String(values[i]
                                      .getBytes("ISO-8859-1"), "utf-8");
                          } catch (UnsupportedEncodingException e) {
                               e.printStackTrace();
                          }
                      }
                  }
              }
               hasEncode = true;
          }
           return parameterMap;
      }
       return super.getParameterMap();
  }

   //取一个值
   @Override
   public String getParameter(String name) {
       Map<String, String[]> parameterMap = getParameterMap();
       String[] values = parameterMap.get(name);
       if (values == null) {
           return null;
      }
       return values[0]; // 取回参数的第一个值
  }

   //取所有值
   @Override
   public String[] getParameterValues(String name) {
       Map<String, String[]> parameterMap = getParameterMap();
       String[] values = parameterMap.get(name);
       return values;
  }
}

小结：乱码问题，需要平时多注意，在尽可能能设置编码的地方，都设置为统一编码 UTF-8！

Tomcat重启问题：

改变Java类文件，只需要redeploy（重新部署）
改变.jsp等文件，只需要update calsses and resource
改动web.xml文件，需要重新启动tomcat

8、Json交互处理

8.1、什么是Json

JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式，目前使用特别广泛
采用完全独立于编程语言的文本格式来存储和表示数据
简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言
易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率

在 JavaScript 语言中，一切都是对象。因此，任何JavaScript 支持的类型都可以通过 JSON 来表示，例如字符串、数字、对象、数组等。看看他的要求和语法格式：

对象表示为键值对，数据由逗号分隔
花括号保存对象
方括号保存数组

JSON 键值对是用来保存 JavaScript 对象的一种方式，和 JavaScript 对象的写法也大同小异，键/值对组合中的键名写在前面并用双引号 “” 包裹，使用冒号 : 分隔，然后紧接着值：

{"name": "QinJiang"}
{"age": "3"}
{"sex": "男"}

很多人搞不清楚 JSON 和 JavaScript 对象的关系，甚至连谁是谁都不清楚。其实，可以这么理解：JSON 是 JavaScript 对象的字符串表示法，它使用文本表示一个 JS （JavaScript ）对象的信息，本质是一个字符串

var obj = {a: 'Hello', b: 'World'}; //这是一个对象，注意键名也是可以使用引号包裹的
var json = '{"a": "Hello", "b": "World"}'; //这是一个 JSON 字符串，本质是一个字符串

8.2、Json和JavaScript对象互转

要实现从JSON字符串转换为JavaScript 对象，使用 JSON.parse() 方法

var obj = JSON.parse('{"a": "Hello", "b": "World"}');
//结果是 {a: 'Hello', b: 'World'}

要实现从JavaScript 对象转换为JSON字符串，使用 JSON.stringify() 方法

var json = JSON.stringify({a: 'Hello', b: 'World'});
//结果是 '{"a": "Hello", "b": "World"}'

代码测试：

<script type="text/javascript">
    /*
    * Json对象和Js对象的互相转换
    * */
    //编写一个JavaScript对象
    var user={
        name:"麻腾飞",
        age:18,
        sex:"男"
    };

    var json = JSON.stringify(user);
    console.log(json);

    console.log("==============")

    var js = JSON.parse(json);
    console.log(js);
</script>

8.3、Controller返回Json数据（Jackson使用）

Jackson应该是目前比较好的json解析工具
当然工具不止这一个，比如还有阿里巴巴的 fastjson 等等

我们这里使用Jackson，需要导入它的依赖：

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
<dependency>
   <groupId>com.fasterxml.jackson.core</groupId>
   <artifactId>jackson-databind</artifactId>
   <version>2.9.8</version>
</dependency>

步骤：

Jackson解析工具依赖

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.9.8</version>
</dependency>

配置web.xml（配置DispatcherServlet）和过滤器（防止乱码）

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

    <!--1.注册servlet-->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--通过初始化参数指定SpringMVC配置文件的位置，进行关联-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!-- 启动顺序，数字越小，启动越早 -->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--所有请求都会被springmvc拦截 -->
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
	<!--SpringMVC自带过滤器-->
    <filter>
        <filter-name>encoding</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>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

</web-app>

配置SpringMVC核心配置文件：springmvc-servlet.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
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 自动扫描指定的包，下面所有注解类交给IOC容器管理 -->
    <context:component-scan base-package="com.my.controller"/>

    <!-- 视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          id="internalResourceViewResolver">
        <!-- 前缀 -->
        <property name="prefix" value="/WEB-INF/jsp/" />
        <!-- 后缀 -->
        <property name="suffix" value=".jsp" />
    </bean>

</beans>

编写控制器

@Controller
public class UserController {
    @RequestMapping("/json")
    @ResponseBody
    public String Json01() throws JsonProcessingException {
        User user = new User(1,"麻腾飞",18);

        ObjectMapper mapper = new ObjectMapper();
        String s = mapper.writeValueAsString(user);
        return s;
    }
}

出现的问题：使用Jackson返回给前端Json数据出现乱码

@RequestMapping(value = “/json”,produces=“application/json;charset=utf-8”)中的produces

乱码统一解决：这样不用每次都添加produces

<mvc:annotation-driven>
   <mvc:message-converters register-defaults="true">
       <bean class="org.springframework.http.converter.StringHttpMessageConverter">
           <constructor-arg value="UTF-8"/>
       </bean>
       <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
           <property name="objectMapper">
               <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                   <property name="failOnEmptyBeans" value="false"/>
               </bean>
           </property>
       </bean>
   </mvc:message-converters>
</mvc:annotation-driven>

小结：

@ResponseBody注解：使修饰的方法不经过视图解析器，而仅仅返回字符串（修饰方法）
@RestController注解：修饰该类下的所有方法都不经过视图解析器，仅仅返回字符串（修饰类）

使用Jackson步骤：

导入Jackson依赖
解决乱码使用统一乱码解决方式或者produces都可以
创建ObjectMapper对象调用相应方法来将java对象转换为json对象并返回给前段

重点：该8.3节讲到了抽取工具类和重载方法实现代码复用的思想，参考SpringMVC_06_JsonAgain，重点理解思想！

8.4、FastJson

fastjson.jar是阿里开发的一款专门用于Java开发的包
实现json对象与JavaBean对象的转换
实现JavaBean对象与json字符串的转换
实现json对象与json字符串的转换
实现json的转换方法很多，最后的实现结果都是一样的

FastJson依赖：

<dependency>
   <groupId>com.alibaba</groupId>
   <artifactId>fastjson</artifactId>
   <version>1.2.60</version>
</dependency>

代码测试：

@Controller
public class FastJsonController {

    @RequestMapping("/f/j")
    @ResponseBody
    public String FastJson01(){

        User user1 = new User(1,"麻腾飞",18);
        User user2 = new User(1,"麻腾飞",18);
        User user3 = new User(1,"麻腾飞",18);
        User user4 = new User(1,"麻腾飞",18);

        ArrayList<User> list = new ArrayList<>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        list.add(user4);

        System.out.println("=============java对象  转  json字符串==========");
        String str1 = JSON.toJSONString(list);
        System.out.println(str1);
        String str2 = JSON.toJSONString(user1);
        System.out.println(str2);

        System.out.println("=============json字符串  转  java对象=========");
        User user = JSON.parseObject(str2, User.class);
        System.out.println(user);

        System.out.println("==============java对象  转  json对象===========");
        JSONObject json = (JSONObject) JSON.toJSON(user2);
        System.out.println(json);

        System.out.println("==============json对象  转  java对象===========");
        User user5 = JSON.toJavaObject(json, User.class);
        System.out.println(user5);

        return "four";
    }
}

9、Ajax研究

9.1、简介

什么是Ajax？

AJAX = Asynchronous JavaScript and XML（异步的 JavaScript 和 XML）
AJAX 是一种在无需重新加载整个网页的情况下，能够更新部分网页的技术
Ajax 不是一种新的编程语言，而是一种用于创建更好更快以及交互性更强的Web应用程序的技术

历史发展和工作原理

在 2005 年，Google 通过其 Google Suggest 使 AJAX 变得流行起来。Google Suggest能够自动帮你完成搜索单词
Google Suggest 使用 AJAX 创造出动态性极强的 web 界面：当您在谷歌的搜索框输入关键字时，JavaScript 会把这些字符发送到服务器，然后服务器会返回一个搜索建议的列表
就和国内百度的搜索框一样
传统的网页(即不用ajax技术的网页)，想要更新内容或者提交一个表单，都需要重新加载整个网页
使用ajax技术的网页，通过在后台服务器进行少量的数据交换，就可以实现异步局部更新
使用Ajax，用户可以创建接近本地桌面应用的直接、高可用、更丰富、更动态的Web用户界面

9.2、伪造Ajax

新建一个test.html文件来伪造一下ajax的效果：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>iframe测试体验页面无刷新</title>
</head>

<script>
    function go(){
        var url = document.getElementById("url").value;
        document.getElementById("iframe1").src=url;
    }
</script>

<body>

<div>
    <p>请输入地址：</p>
    <p>
        <input type="text" id="url" value="https://www.bilibili.com/">
        <input type="button" value="提交" onclick="go()">
    </p>
</div>
<div>
    <iframe id="iframe1" style="width: 100%;height: 500px"></iframe>
</div>
</body>
</html>

9.3、jQuery.ajax

纯JS原生实现Ajax我们不去讲解这里，直接使用jquery提供的，方便学习和使用，避免重复造轮子，有兴趣的同学可以去了解下JS原生XMLHttpRequest
Ajax的核心是XMLHttpRequest对象(XHR)。XHR为向服务器发送请求和解析服务器响应提供了接口。能够以异步方式从服务器获取新数据
jQuery 提供多个与 AJAX 有关的方法
通过 jQuery AJAX 方法，您能够使用 HTTP Get 和 HTTP Post 从远程服务器上请求文本、HTML、XML 或 JSON – 同时您能够把这些外部数据直接载入网页的被选元素中
jQuery 不是生产者，而是大自然搬运工
jQuery Ajax本质就是 XMLHttpRequest，对它进行了封装，方便调用
jQuery 是一个库，里面包含了js的大量函数

jQuery.ajax(...)
      部分参数：
            url：请求地址
            type：请求方式，GET、POST（1.9.0之后用method）
        headers：请求头
            data：要发送的数据
    contentType：即将发送信息至服务器的内容编码类型(默认: "application/x-www-form-urlencoded; charset=UTF-8")
          async：是否异步
        timeout：设置请求超时时间（毫秒）
      beforeSend：发送请求前执行的函数(全局)
        complete：完成之后执行的回调函数(全局)
        success：成功之后执行的回调函数(全局)
          error：失败之后执行的回调函数(全局)
        accepts：通过请求头发送给服务器，告诉服务器当前客户端可接受的数据类型
        dataType：将服务器端返回的数据转换成指定类型
          "xml": 将服务器端返回的内容转换成xml格式
          "text": 将服务器端返回的内容转换成普通文本格式
          "html": 将服务器端返回的内容转换成普通文本格式，在插入DOM中时，如果包含JavaScript标签，则会尝试去执行。
        "script": 尝试将返回值当作JavaScript去执行，然后再将服务器端返回的内容转换成普通文本格式
          "json": 将服务器端返回的内容转换成相应的JavaScript对象
        "jsonp": JSONP 格式使用 JSONP 形式调用函数时，如 "myurl?callback=?" jQuery 将自动替换 ? 为正确的函数名，以执行回调函数

简单测试：

配置web.xml和SpringMVC的配置文件

<?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
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       https://www.springframework.org/schema/mvc/spring-mvc.xsd">

   <!-- 自动扫描指定的包，下面所有注解类交给IOC容器管理 -->
   <context:component-scan base-package="com.kuang.controller"/>
    <!--静态资源过滤-->
   <mvc:default-servlet-handler />
    <!--注解驱动配-->
   <mvc:annotation-driven />

   <!-- 视图解析器 -->
   <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
         id="internalResourceViewResolver">
       <!-- 前缀 -->
       <property name="prefix" value="/WEB-INF/jsp/" />
       <!-- 后缀 -->
       <property name="suffix" value=".jsp" />
   </bean>

</beans>

编写一个AjaxController类

@Controller
public class AjaxController {

   @RequestMapping("/a1")
   public void ajax1(String name , HttpServletResponse response) throws IOException {
       if ("admin".equals(name)){
           response.getWriter().print("true");
      }else{
           response.getWriter().print("false");
      }
  }
}

导入jquery ，可以使用在线的CDN ，也可以下载导入
编写（index.jsp）

  <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  <html>
    <head>
      <title>$Title$</title>
    </head>
    <%--jQuery文件的引用--%>
<script src="${pageContext.request.contextPath}/static/js/jquery-3.6.0.js"></script>

<script>
    function a(){
      $.post({
        url:"${pageContext.request.contextPath}/test02",
        data:{"name":$("#username").val()},
        success:function (data,status){
          console.log(data);
          console.log(status);
        },error:function (){
        }
      })
    }
</script>

<body>
<%--失去一个焦点的时候，会发送一个请求(携带信息)到后台--%>
<input type="text" id="username" onblur="a()">
</body>
</html>

启动tomcat测试！打开浏览器的控制台，当我们鼠标离开输入框的时候，可以看到发出了一个ajax的请求！是后台返回给我们的结果！测试成功

9.4、SpringMVC实现

实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private String name;
    private int age;
    private String sex;
}


1. 编写Controller来返回给前端一个list集合


```java
   @RequestMapping("/test03")
   public List<User> test03(){
     ArrayList<User> list = new ArrayList<>();
     //添加数据
     list.add(new User("ma",1,"男"));
     list.add(new User("teng",1,"女"));
     list.add(new User("fei",1,"男"));
     return list;
   }

前端页面（test02.jsp）

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>展示页面</title>
</head>
<%--jQuery文件的引用--%>
<script src="${pageContext.request.contextPath}/static/js/jquery-3.6.0.js"></script>
<script>
    $(function (){
        $("#btn").click(function (){
            /*console.log("111");*/
            /*
            * 简写：
            * */
            $.post("${pageContext.request.contextPath}/test03",function (data){
                console.log(data);
                let html =  "";
                for (let i = 0; i < data.length; i++) {
                    html += `<tr>
                                    <td>${"${data[i].name}"}</td>
                                    <td>${"${data[i].age}"}</td>
                                    <td>${"${data[i].sex}"}</td>
                                </tr>`
                }
                $("#content").html(html)
            })
        })
    })
</script>
<body>
<input type="button" value="加载数据" id="btn">
<table>
    <tr>
        <td>姓名</td>
        <td>年龄</td>
        <td>性别</td>
    </tr>
    <tbody id="content">
        <%--数据：后台--%>
    </tbody>
</table>
</body>
</html>

9.5、注册提示效果

编写Controller

@RequestMapping("/test04")
public String test04(String name,String password){
  String msg = "";
  if (name!=null){
    if ("admin".equals(name)){
      msg = "OK";
    }else {
      msg = "用户名有误";
    }
  }
  if (password!=null){
    if ("123456".equals(password)){
      msg = "OK";
    }else {
      msg = "密码错误";
    }
  }
  return msg;
}

前端页面：login.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>用户登录</title>
</head>

<%--jQuery文件的引用--%>
<script src="${pageContext.request.contextPath}/static/js/jquery-3.6.0.js"></script>

<script>

    function a1(){
        //用户名输入框失去焦点，后台验证用户名是否存在
        $.post({
            url:"${pageContext.request.contextPath}/test04",
            data:{"name":$("#name").val()},
            success:function (data) {
                if (data==='OK'){
                    $("#userInfo").css("color", "green");
                } else {
                    $("#userInfo").css("color", "red");
                }
                $("#userInfo").html(data);
            }
        })
    }
    function a2(){
        $.post({
            url: "${pageContext.request.contextPath}/test04",
            data:{"password":$("#password").val()},
            success:function (data){
                if (data==='OK'){
                    $("#passwordInFo").css("color","green");
                }else {
                    $("#passwordInFo").css("color","red");
                }
                $("#passwordInFo").html(data);
            }
        })
    }

</script>

<body>

<p>
    用户名：<input type="text" id="name" onblur="a1()">
    <span id="nameInFo"></span>
</p>

<p>
    密码：<input type="text" id="password" onblur="a2()">
    <span id="passwordInFo"></span>
</p>

</body>
</html>

记得处理json乱码

<!--JSON乱码问题配置-->
<mvc:annotation-driven>
  <mvc:message-converters register-defaults="true">
    <bean class="org.springframework.http.converter.StringHttpMessageConverter">
      <constructor-arg value="UTF-8"/>
    </bean>
    <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
      <property name="objectMapper">
        <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
          <property name="failOnEmptyBeans" value="false"/>
        </bean>
      </property>
    </bean>
  </mvc:message-converters>
</mvc:annotation-driven>

10、拦截器

10.1、概述

SpringMVC的处理器拦截器类似于Servlet开发中的过滤器Filter,用于对处理器进行预处理和后处理
开发者可以自己定义一些拦截器来实现特定的功能

10.2、过滤器和拦截器的区别

拦截器
- 拦截器是AOP思想的具体应用
- 拦截器是SpringMVC框架自己的，只有使用了SpringMVC框架的工程才能使用
- 拦截器只会拦截访问的控制器方法，如果访问的是jsp/html/css/image/js是不会进行拦截的（自带静态资源过滤）
过滤器
- servlet规范中的一部分，任何javaweb工程都可以使用
- 在url-pattern中配置了/*之后，可以对所有要访问的资源进行拦截

10.3、自定义拦截器

新建Module，添加web支持

配置web.xml和applicationContext.xml

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

    <!--注册DispatcherServlet-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <!--加载SpringMVC配置文件-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext.xml</param-value>
        </init-param>

        <!--设置启动级别-->
        <load-on-startup>1</load-on-startup>
    </servlet>

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

    <!--SpringMVC自带的乱码过滤-->
    <filter>
        <filter-name>encoding</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>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

</web-app>

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: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
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--自动扫描controller包-->
    <context:component-scan base-package="com.my.controller"/>

    <!--静态资源过滤-->
    <mvc:default-servlet-handler/>

    <!--开启注解驱动，以及防止json乱码-->
    <mvc:annotation-driven>
        <mvc:message-converters register-defaults="true">
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <constructor-arg value="UTF-8"/>
            </bean>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
                <property name="objectMapper">
                    <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                        <property name="failOnEmptyBeans" value="false"/>
                    </bean>
                </property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>

    <!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp"/>
        <property name="suffix" value=".jsp"/>
    </bean>
     <!--配置拦截器-->
   <mvc:interceptors>
       <mvc:interceptor>
           <!--path：
               /admin/**：意思就是执行当前路径下，admin路径下，的所以请求
               /**：意思就是执行当前路径下的所有请求
           -->
           <mvc:mapping path="/**"/>
           <bean class="com.my.config.MyInterceptor"/>
       </mvc:interceptor>
   </mvc:interceptors>
     </beans>

3.编写一个拦截器（必须实现HandlerInterceptor接口）

import org.springframework.web.servlet.HandlerInterceptor;
   import org.springframework.web.servlet.ModelAndView;

   import javax.servlet.http.HttpServletRequest;
   import javax.servlet.http.HttpServletResponse;

   public class MyInterceptor implements HandlerInterceptor {
       /*
       * return true;放行，来执行下一个拦截器
       * return false;不放行
       * */
       @Override
       public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
           /*return HandlerInterceptor.super.preHandle(request, response, handler);*/
           System.out.println("==========拦截前==========");
           return true;
       }
       //后两个一般日志会用到
       @Override
       public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
           HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
           System.out.println("==========拦截后==========");
       }

       @Override
       public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
           HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
           System.out.println("==========清理==========");
       }
   }

在SpringMVC的配置文件中配置拦截器

<!--配置拦截器-->
<mvc:interceptors>
  <mvc:interceptor>
    <!--path：
                /admin/**：意思就是执行当前路径下，admin路径下，的所以请求
                /**：意思就是执行当前路径下的所有请求
            -->
    <mvc:mapping path="/**"/>
    <bean class="com.my.config.MyInterceptor"/>
  </mvc:interceptor>
</mvc:interceptors>

编写一个Controller

@RestController
public class TestHandlerInterceptor {
    @RequestMapping("/test01")
    public String test01(){
        System.out.println("执行了test01测试方法！");
        return "success";
    }
}

启动测试

10.4、验证用户是否登录（认证用户）

场景描述：就是在登录一个网站时候，如果用户没有登录该网站时，那么用户不能直接进入首页，而是需要先进行登录。

问题来了：网站怎么判断用户是否已经登录呢？

11、文件的上传和下载

11.1、准备工作

文件上传是项目开发中最常见的功能之一 ,springMVC 可以很好的支持文件上传
SpringMVC上下文中默认没有装配MultipartResolver，因此默认情况下其不能处理文件上传工作。如果想使用Spring的文件上传功能，则需要在上下文中配置MultipartResolver
前端表单要求：为了能上传文件，必须将表单的method设置为POST，并将enctype属性设置为multipart/form-data。只有在这样的情况下，浏览器才会把用户选择的文件以二进制数据发送给服务器

11.2、enctype属性详解

application/x-www=form-urlencoded：默认方式，只处理表单域中的 value 属性值，采用这种编码方式的表单会将表单域中的值处理成 URL 编码方式
multipart/form-data：这种编码方式会以二进制流的方式来处理表单数据，这种编码方式会把文件域指定文件的内容也封装到请求参数中，不会对字符编码
text/plain：除了把空格转换为 “+” 号外，其他字符都不做编码处理，这种方式适用直接通过表单发送邮件

示例：

<form action="" enctype="multipart/form-data" method="post">
   <input type="file" name="file"/>
   <input type="submit">
</form>

一旦设置了enctype为multipart/form-data，浏览器即会采用二进制流的方式来处理表单数据，而对于文件上传的处理则涉及在服务器端解析原始的HTTP响应。在2003年，Apache Software Foundation发布了开源的Commons FileUpload组件，其很快成为Servlet/JSP程序员上传文件的最佳选择

总结：

Servlet3.0规范已经提供方法来处理文件上传，但这种上传需要在Servlet中完成
而Spring MVC则提供了更简单的封装
Spring MVC为文件上传提供了直接的支持，这种支持是由即插即用的MultipartResolver实现的
Spring MVC使用Apache Commons FileUpload技术实现了一个MultipartResolver实现类，因此，SpringMVC的文件上传还需要依赖Apache Commons FileUpload的组件