SpringMVC学习笔记

学习视频链接：B站 遇见狂神说 动力节点

Spring MVC是一个模型-视图-控制器（MVC）的Web框架建立在中央前端控制器servlet（DispatcherServlet），它负责发送每个请求到合适的处理程序，使用视图来最终返回响应结果的概念。

一、什么是MVC？

• MVC是模型（Model）、视图（View）、控制器（Controller）的简写，是一种软件设计规范。
• 是将业务逻辑、数据、显示分离的方法来组织代码。
• MVC主要作用是降低了视图与业务逻辑间的双向耦合。
• MVC不是一种设计模式，MVC是一种架构模式。当然不同的MVC存在差异。

Model（模型）：数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或JavaBean组件（包含数据和行为），不过现在一般都分离开来：Value Object（数据Dao）和服务层（行为Service）。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包含数据和业务。

View（视图）：负责进行模型的展示，一般就是我们见到的用户界面，客户想要看到的东西。

Controller（控制器）：接收用户请求，委托给模型进行处理（状态改变），处理完毕后把返回的模型数据返回给视图，由视图负责展示。也就是说控制器做了个调度员的工作。

最典型的MVC就是JSP+servlet+JavaBean的模式。

二、什么是SpringMVC

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

Spring MVC的特点：

• 轻量级，简单易学
• 高效，基于请求响应的MVC框架
• 与Spring兼容性好，无缝结合
• 约定优于配置
• 功能强大RESTful、数据验证、格式化、本地化、主题等
• 简洁灵活

Spring的web框架围绕DispatchServlet设计。DispatchServlet的作用是将请求分发到不同的处理器。从Spring2.5开始，使用Java5或者以上版本的用户可以采用基于注解的controller声明方式。

Spring MVC框架像许多其他MVC框架一样，以请求为驱动，围绕一个中心Servlet分派请求及提供其他功能，DispatchServlet是一个实际的Servlet（它继承自HTTPServlet基类）。

Spring MVC的原理如下图所示：

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

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

简单分析执行流程：

1. DispatchServlet表示前置控制器，是整个SpringMVC的控制中心。用户发出请求，DispatchServlet接收请求并拦截请求。

   • 假设请求的url为http://localhost:8080/SpringMVC/hello
   • 将url拆分为三部分
   • http://localhost:8080服务器域名
   • SpringMVC部署在服务器上的web站点
   • hello表示控制器
   • url表示请求位于服务器localhost:8080上的SpringMVC站点的hello控制器

2. HandlerMapping为处理器映射（实现了HandlerMapping接口的类都叫做映射器）。DispatchServlet调用HandlerMapping，HandlerMapping根据请求url查找Handler。

   根据请求，从SpringMVC容器对象中获取处理器对象（MyController controller = ctx.getBean(“/hello”)），框架把找到的处理器对象放到一个叫做处理器执行链（HandlerExecutionChain）的类保存。

   HandlerExceptionChain：类中保存着（1）处理器对象（MyController）（2）项目中的所有的拦截器List interceptorList

3. HandlerExecution表示具体的Handler，其主要作用是根据url查找控制器，例如上面的url被查找控制器为：hello

4. HandlerExecution将解析后的信息传递给DispatchServlet，如解析控制器映射等。

5. HandlerAdapter表示处理适配器，其按照特定的规则去执行Handler。

6. Handler让具体的Controller执行。

7. Controller将具体的执行信息返回给HandlerAdapter，如ModelAndView。

8. HandlerAdapter将视图逻辑名称或模型传递给DispatcherServlet。

9. DispatcherServlet调用视图解析器（ViewResolver）来解析HandlerAdapter传递的逻辑视图名。

10. 视图解析器解析的逻辑视图名传给DispatchServlet。

11. DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。

12. 最终视图呈现给用户。

三、第一个MVC程序

1、配置版

• 新建一个Module，添加web的支持

• 确定导入了SpringMVC的依赖

• 配置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、注册DispatchServlet-->
      <servlet>
          <servlet-name>springmvc</servlet-name>
          <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
          <!--
              springmvc创建容器对象时，读取的配置文件默认是/WEB-INF/[servlet-name]-servlet.xml
          -->
          <!--关联一个springmvc的配置文件：[Servlet-name]-servlet.xml-->
          <init-param>
              <!--springmvc的配置文件的位置的属性-->
              <param-name>contextConfigLocation</param-name>
              <!--指定自定义文件的位置-->
              <param-value>classpath:springmvc-servlet.xml</param-value>
          </init-param>
          <!--启动级别
              load-on-startup：表示tomcat启动后创建对象的顺序。它的值是整数，数值越小，tomcat创建对象的时间越早。（大于等于0的整数。
              1：表示在tomcat启动后，创建Servlet对象
          -->
          <load-on-startup>1</load-on-startup>
      </servlet>
  
      <!--/ 匹配所有的请求：（不包括.jsp）-->
      <!--/* 匹配所有的请求：（包括.jsp）-->
      <servlet-mapping>
          <servlet-name>springmvc</servlet-name>
          <!--
              url-pattern剋使用两种值
              1、使用扩展名方式，语法 *.xxx，xxx是自定义的扩展名。常用的方式 *.do，*.action，*.mvc等
                  http://localhost:8080/login.do
              2、使用斜杠"/"
          -->
          <url-pattern>/</url-pattern>
      </servlet-mapping>
  
  </web-app>

• 编写SpringMVC的配置文件，名称：springmvc-servlet.xml【[servlet-name]-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>

• 添加处理映射器

  <!--添加处理映射器-->
  <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>

• 添加处理器适配器

  <!--添加处理适配器-->
  <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

• 添加视图解析器

  <!--添加视图解析器-->
  <!--视图解析器：DispatchServlet给它的ModelAndView
      1.获取了ModelAndView的数据
      2.解析ModelAndView的视图名字
      3.拼接视图名字，找到对应的视图 /WEB-INF/jsp/hello.jsp
      4.将数据渲染到这个视图上
      -->
  
  <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接口，要么增加注解。需要返回一个ModelAndView，装数据，封视图。

  package com.lskj.controller;
  
  import org.springframework.web.servlet.ModelAndView;
  import org.springframework.web.servlet.mvc.Controller;
  
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  //这里先实现Controller接口
  public class HelloController implements Controller {
      @Override
      public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
          //ModelAndView模型和视图
          ModelAndView mv = new ModelAndView();
  
          //封装对象，放在ModelAndView中。Model
          mv.addObject("msg","HelloSpringMVC!");
          //封装要跳转的视图，放在ModelAndView中
          mv.setViewName("hello"); //：/WEB-INF/jsp/hello.jsp
          return mv;
      }
  }
  

• 将自己的类交给SpringIOC容器，注册bean

  <!--Handler-->
  <bean id="/hello" class="com.lskj.controller.HelloController"/>

• 编写需要跳转的jsp页面，显示ModelAndView存放的数据，以及正常的页面

  <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  <html>
  <head>
      <title>Title</title>
  </head>
  <body>
  
      ${msg}
  
  </body>
  </html>

• 配置Tomact，启动测试

  可能遇到的问题：访问出现404
  1.查看控制台输出，看一下是否缺少了什么jar包。
  2.如果jar包存在，显示无法输出，就在IDEA的项目发布中，添加lib依赖。
  3.重启Tomact。

2、注解版

1、新建一个Moudle，添加web支持。建立包结构com.lskj.controller

2、由于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>

3、在pom.xml文件引入相关依赖：

主要有Spring框架核心库、SpringMVC、Servlet、JSTL等。（若父依赖中已经引入，则不需）

4、配置web.xml

• 注意web.xml版本问题
• 注册DispatcherServlet
• 关联SpringMVC的配置文件
• 启动级别为1
• 映射路径为/ 【不要用/*，会404】

/ 和 /* 的区别：
<url-pattern>/</url-pattern>不会匹配到.jsp，只针对编写的请求，即.jsp不会进入到spring的DispatchetServlet类。
<url-pattern>/*</url-pattern>会匹配*.jsp，会出现返回jsp视图 时再次进入spring的DispatcherServlet类，导致找不到对应的controller

<?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>
        <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>
</web-app>

5、添加SpringMVC配置文件

• 让IOC的注解生效
• 静态资源过滤：HTML、JS、CSS、图片、视频……
• MVC的注解驱动
• 配置视图解析器

在resource目录下添加springmvc-servlet.xml配置文件，配置的形式与Spring容器配置基本类似，为了支持基于注解的IOC，设置了自动扫描包的功能，具体配置信息如下：

<?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.lskj.controller"/>
    <!--让Spring MVC不处理静态资源-->
    <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>

</beans>

在视图解析器中把所有的视图都存放在/WEB-INF/目录下，这样可以保证视图安全，因为这个目录下的文件，客户端不能直接访问。

6、创建Controller

编写一个Java控制类：com.lskj.controller.HelloController.java

package com.lskj.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class HelloController {
    @RequestMapping("/hello")
    public String hello(Model model){
        //封装数据
        model.addAttribute("msg","Hello,SpringMVC Annotation!");
        return "hello";  //会被视图解析器处理
    }
}

/*
@Controller
@RequestMapping("/hello")
public class HelloController {
    //localhost:8080/hello/test
    @RequestMapping("/test")
    public String hello(Model model){
        //封装数据
        model.addAttribute("msg","Hello,SpringMVC Annotation!");
        return "hello";  //会被视图解析器处理
    }
}
*/

• @Controller是为了让Spring IOC容器初始化时自动扫描到；
• @RequestMapping是为了映射请求路径，因为类与方法上都有映射所以访问时应该是/hello/test；
• 方法中声明Model类型的参数是为了把Action中的数据带到视图中；
• 方法返回的结果是视图的名称hello，加上配置文件中的前后缀变成WEB-INF/jsp/hello.jsp

7、创建视图层

在WEB-INF/jsp目录中创建hello.jsp，视图可以直接取出并展示从Controller带回的信息；

可以通过EL表示取出Model中存放的值，或者对象。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Spring MVC</title>
</head>
<body>
    ${msg}
</body>
</html>

8、配置Tomact运行

配置Tomact，开启服务器，访问对应的请求路径。

使用SpringMVC必须配置的 三大件：处理器映射器、处理器适配器、视图解析器

通常，只需要手动配置视图解析器，而处理器映射器和处理器适配器只需要开启注解驱动即可。

3、静态资源访问

注册DispatchServlet时，将<url-pattern>/</url-pattern>配置为/时，静态资源无法进行访问，此时，需要进行一些配置，才能对静态资源进行访问。

第一种处理静态资源方式：

需要在springmvc配置文件中加入<mvc:default-servlet-handler/>

原理：加入这个标签后，框架会创建控制器对象DefaultServletHttpRequestHandler（类似创建的Conroller）。

DefaultServletHttpRequestHandler这个对象可以把接收的请求转发给tomcat的default这个servlet。

default-servlet-handler和@RequestMapping注解有冲突，需要加入<mvc:annotation-driven/>注解驱动解决问题。

第二种处理静态资源方式：

在springmvc配置文件中加入<mvc:resources mapping="" location=""/>

mvc:resources加入后框架会创建ResourceHttpRequestHandler这个处理器对象。让这个对象处理静态资源的访问，不依赖tomcat服务器。

mapping：访问静态资源的url地址，使用通配符**

location：静态资源在项目中的目录位置。

mvc:resources和@RequestMapping有一定的冲突，需加入注解驱动<mvc:annotation-driven/>。

例如：

<mvc:resources mapping="/images/**" location="/images/"/>
<mvc:resources mapping="/html/**" location="/html/"/>
<mvc:resources mapping="/js/**" location="/js/"/>

四、Controller和RequestMapping

1、控制器Controller

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

2、实现Controller接口

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

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

1、新建一个Moudle，步骤与第一个MVC程序配置版相同（mvc的配置文件中只有视图解析器）。

2、编写一个Controller类

package com.lskj.controller;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

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

//只要实现了Controller接口的类，说明这就是一个控制器了
public class ControllerDemoTest01 implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        ModelAndView mv = new ModelAndView();

        mv.addObject("msg","ControllerDemoTest01");
        mv.setViewName("test");

        return mv;
    }
}

3、Spring配置文件中注册请求的bean，name对应请求路径，class对应处理请求的类

<bean name="/t1" class="com.lskj.controller.ControllerDemoTest01"/>

4、编写前端test.jsp，注意在WEB-INF/jsp目录下编写，对应视图解析器

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>ControllerDemoTest01</title>
</head>
<body>
    ${msg}
</body>
</html>

5、配置Tomact运行测试

• 实现接口Controller定义控制器是较老的方法

• 缺点：

  一个控制器中只有一个方法，如果多个方法则需要定义多个Controller；

  定义的方式比较麻烦。

3、使用注解@Controller

• @Controller注解类型用于声明Spring类的实例是一个控制器；

• Spring可以使用扫描机制来找到应用程序中所有基于注解的控制器类，为了保证Spring能找到控制器，需要在配置文件中声明组件扫描。

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

• 增加一个Controller类，使用注解实现

  package com.lskj.controller;
  
  import org.springframework.stereotype.Controller;
  import org.springframework.ui.Model;
  import org.springframework.web.bind.annotation.RequestMapping;
  
  //@Controller注解的类会自动添加到Spring上下文中
  /*
      代表这个类会被Spring接管
      被这个注解的类中所有方法，如果返回值是String，并且有具体的页面可以跳转，那么就会被视图解析器解析
   */
  @Controller
  public class ControllerDemoTest02 {
      //映射访问路径
      @RequestMapping("/t2")
      public String test01(Model model){
          //Spring MVC会自动实例化一个Model对象用于向视图中传值
          model.addAttribute("msg","ControllerDemoTest02");
          //返回视图位置
          return "test";
      }
  
      @RequestMapping("/t3")
      public String test02(Model model){
          model.addAttribute("msg","test02");
          return "test";
      }
  }

• 运行Tomact测试

两个请求都可以指向一个视图，但是页面显示的结果是不一样的，从这里可以看出视图是被复用的，而控制器与视图之间是弱耦合关系。

4、RequestMapping

通过@RequestMapping注解可以定义处理器对于请求的映射规则。@RequestMapping注解用于映射url到控制器类或一个特定的处理程序方法。可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。value属性值常以/开始。

• 只注解在方法上面

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

  访问路径：http://localhost:8080/项目名/t1

• 同时注解类和方法

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

  访问路径：http://localhost:8080/项目名/test/t1，需要先指定类的路径，再指定方法的路径。

  建议：

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

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

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

5、RestFul风格

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

功能：

资源：互联网所有的事物都可以抽象为资源

资源操作：使用POST、DELTTE、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

测试：

1、新建一个类RestFulController

2、在Spring MVC中可以使用 @PathVariable 注解，让方法参数的值对应绑定到一个URI模板变量上。

@Controller
public class RestFulController {
    //原来：http://localhost:8080/add?a=2&b=3
    //RestFul：http://localhost:8080/add/2/3
    @RequestMapping("/add/{a}/{b}")
    public String test01(@PathVariable int a,@PathVariable int b, Model model){
        int result = a + b;
        model.addAttribute("msg","结果为"+result);
        return "test";
    }
}

3、使用路径变量的好处：

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

使用method属性指定请求类型

用于约束请求的类型，可以收窄请求范围。指定请求谓词的类型如GET、POST、HEAD、OPTIONS、PUT

PATCH、DELETE、TRACE等。

• 增加一个方法

  //映射访问路径,必须是POST请求
  @RequestMapping(value = "/hello",method = {RequestMethod.POST})
  public String test02(Model model){
     model.addAttribute("msg", "hello!");
     return "test";
  }

• 使用浏览器地址栏进行访问默认是get请求，会报错405

• 将POST修改为GET则正常

  //映射访问路径,必须是Get请求
  @RequestMapping(value = "/hello",method = {RequestMethod.GET})
  public String test02(Model model){
     model.addAttribute("msg", "hello!");
     return "test";
  }

Spring MVC的@RequestMapping注解能够处理HTTP请求的方法，比如GET、PUT、POST、DELETE以及PATCH。

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

方法级别的注解变体有如下几个：组合注解

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping

@GetMapping 是一个组合注解，平时使用的会比较多！

它所扮演的是 @RequestMapping(method =RequestMethod.GET) 的一个快捷方式。

五、结果跳转

1、请求转发

• 处理器返回ModelAndView时，需在setViewName()指定的视图前添加forward:，且此时的视图不再与视图解析器一同工作，这样可以在配置了解析器时指定不同位置的视图。视图页面必须写出相对于项目根的路径。forward操作不需要视图解析器。
• 处理器方法返回String，在视图路径前加入forward:视图路径。

ModelAndView

设置ModelAndView对象，根据view的名称，和视图解析器跳转到指定的页面。

页面：{视图解析器前缀}+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 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;
 }
}

2、请求重定向

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

3、ServletAPI

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

1. 通过设置HttpServletResponse进行输出
2. 通过HttpServletResponse实现重定向
3. 通过HttpServletResponse实现转发

4、测试

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

【测试前，需要将视图解析器注释掉】

@Controller
public class ResultSpringMVC {
   @RequestMapping("/test01")
   public String test01(){
       //转发
       return "/index.jsp";
  }

   @RequestMapping("/test02")
   public String test02(){
       //转发
       return "forward:/index.jsp";
  }

   @RequestMapping("/test03")
   public String test03(){
       //重定向
       return "redirect:/index.jsp";
  }
}

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

重定向，不需要视图解析器，本质就是重新请求一个新地址，故要注意路径问题。

可以重定向到另外一个请求实现。

@Controller
public class ResultSpringMVC2 {
   @RequestMapping("test01")
   public String test01(){
       //转发
       return "test";
  }

   @RequestMapping("/test02")
   public String test02(){
       //重定向
       return "redirect:/index.jsp";
       //return "redirect:hello.do"; //hello.do为另一个请求/
  }
}

六、数据处理

1、参数

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

• HttpServletRequest
• HttpServletResponse
• HttpSession
• 请求中所携带的请求参数

1、请求参数名与该请求处理方法的参数名相同

提交数据：http://localhost:8080/t?name=lskj

处理方法：

@RequestMapping("/t")
public String test(String name,Model model){
   System.out.println(name);
   model.addAttribute("msg",name);
   return "test";
}

2、请求参数名与该请求处理方法的参数名不一致

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

提交数据：http://localhost:8080/t?username=lskj

处理方法：

/*
    @RequestParam("username")：username提交的域的名称
    @RequestParam：逐个接收请求参数中，解决请求中参数名形参名不一样的问题
        属性：1、value 请求中的参数名称
             2、required 是一个boolean，默认是true
*/
@RequestMapping("/t")
public String test(@RequestParam("username")String name,Model model){
   System.out.println(name);
   model.addAttribute("msg",name);
   return "test";
}

3、对象参数接收

提交的是一个对象。要求提交的表单域和对象的属性名一致，参数使用对象即可

• 实体类

  public class User {
     private int id;
     private String name;
     private int age;
     //构造
     //get/set
     //tostring()
  }

• 提交数据：http://localhost:8080/t?id=1&name=lskj&age=20

• 处理方法

  @RequestMapping("/t")
  public String test(User user,Model model){
     System.out.println(user);
     model.addAttribute("msg",user);
     return "test";
  }

  如果使用对象的话，前端传递的参数名和对象名必须一致，否则为NULL。

2、返回值

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

• ModelAndView
• String
• void
• 返回自定义类型对象

1、返回ModelAndView

若处理器方法处理完后，需要跳转到其它资源，且又要在跳转的资源间传递数据，此时处理器方法返回ModelAndView比较适合。若需要返回ModelAndView，则处理器方法中需定义ModelAndView对象。

在使用时，若该处理器方法只是进行跳转而不传递数据，或只是传递数据而并不向任何资源跳转（如对页面的ajax异步响应），此时若返回ModelAndView，则将总是有一部分多余：要么Model多余，要么View多余。所以此时返回ModelAndView将不合适。

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

2、返回String

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

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

ModelMap

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

Model

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

区别：

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

3、返回void

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

若处理器对请求成立后，无需跳转到其它任何资源，此时可以让处理器方法返回void。

4、返回对象Object

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

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

3、乱码问题

测试：

1. 编写一个提交表单

   <form action="/e/t" method="post">
       <input type="text" name="name">
       <input type="submit">
   </form>

2. 编写对应的处理类

   @Controller
   public class Encoding {
      @RequestMapping("/e/t")
      public String test(Model model,String name){
          model.addAttribute("msg",name); //获取表单提交的值
          return "test"; //跳转到test页面显示输入的值
     }
   }

3. 输入中文测试，出现乱码

以前乱码问题可通过过滤器解决，而SpringMVC提供了一个过滤器，可以在web.xml中配置。

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

有些情况下，这个过滤器对get的支持不是很好。

处理方法：

1. 修改Tomact配置文件【servlet.xml】：设置编码

   <Connector URIEncoding="utf-8" port="8080" protocol="HTTP/1.1"
             connectionTimeout="20000"
             redirectPort="8443" />

2. 自定义过滤器

   package com.lskj.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 {
   
      public void destroy() {
     }
   
      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;
     }
   
      // 对需要增强方法 进行覆盖
      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();
     }
   
      //取一个值
      public String getParameter(String name) {
          Map<String, String[]> parameterMap = getParameterMap();
          String[] values = parameterMap.get(name);
          if (values == null) {
              return null;
         }
          return values[0]; // 取回参数的第一个值
     }
   
      //取所有值
      public String[] getParameterValues(String name) {
          Map<String, String[]> parameterMap = getParameterMap();
          String[] values = parameterMap.get(name);
          return values;
     }
   }

3. 在web.xml中配置这个过滤器即可。

七、JSON

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

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

要求及语法格式：

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

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

{"name":"lskj"}

JSON是JavaScript对象的字符串表示法，它使用文本表示一个JS对象的信息，本质是一个字符串。

JSON与JavaScript对象互转

JSON字符串转换成JavaScript对象，使用JSON.parse()方法;

JavaScript对象转换成JSON字符串，使用JSON.stringify()方法。

<script type="text/javascript">
    //编写一个JavaScript对象
    var user = {
        name:"lskj",
        age:18,
        sex:"男"
    };

    //将js对象转换成json对象
    var json = JSON.stringify(user);
    console.log(json);

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

    //将JSON对象转换成JavaScript对象
    var obj = JSON.parse(json);
    console.log(obj)
</script>

1、Controller返回JSON数据

Jackson是json解析工具。【工具当然不止这一个，比如还有阿里巴巴的fastjson等】

使用Jackson需要导入它的jar包

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

配置SpringMVC需要配置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">

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

    <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-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.lskj.controller"/>

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

    <!--解决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>

</beans>

测试：

1. 编写一个实体类【用到注解，需要导入Lombok】

   <dependency>
       <groupId>org.projectlombok</groupId>
       <artifactId>lombok</artifactId>
       <version>1.18.12</version>
   </dependency>

   package com.lskj.pojo;
   
   import lombok.AllArgsConstructor;
   import lombok.Data;
   import lombok.NoArgsConstructor;
   
   @Data
   @AllArgsConstructor
   @NoArgsConstructor
   public class User {
       private int id;
       private String name;
       private int age;
   }

2. 编写Controller

   @Controller
   public class UserController {
      @RequestMapping("/j1")
      @ResponseBody  //不会走视图解析器,会直接返回一个字符串
      public String json01() throws JsonProcessingException {
          //创建一个jackson的对象映射器，用来解析数据
          ObjectMapper mapper = new ObjectMapper();
          //创建一个对象
          User user = new User(1,"张三",20);
          //将我们的对象解析成为json格式
          String str = mapper.writeValueAsString(user);
          //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
          return str;
     }
   }

2、乱码问题

启动Tomact测试，中文处出现乱码，需要设置一下它的编码格式以及返回的类型。

• 若在启动Tomact过程中，出现java.lang.ClassNotFoundException:org.springframework.web.filter.CharacterEncodingFilter异常，需在Project Structure中的Artifacts对应的项目中的WEB-INF下添加lib目录，然后添加Library Files（项目依赖）。

通过@RequestMapping的produces属性来实现，修改代码如下

@RequestMapping(value = "/j1",produces = "application/json;charset=utf-8") 

故使用JSON应处理乱码问题。

此方法比较麻烦，若项目中有很多请求则需要每一个都添加。

可以通过Spring配置统一指定，在springmvc的配置文件上添加StringHttpMessageConverter转换配置

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

<mvc:annotation-driven>注解驱动，注解驱动实现的功能是完成java对象到json、xml、text、二进制等数据格式的转换。其在加入到springmvc配置文件后，会自动创建HttpMessageConverter接口的7个实现类对象，包括MappingJackson2HttpMessageConverter（使用Jackson工具库中的ObjectMapper实现Java对象转换为json对象的）

HttpMessageConverter接口：消息转换器。其功能是定义了Java转换为json、xml等数据格式的方法。这个接口有很多的实现类。这些实现类完成Java对象到json，Java对象到xml，Java对象到二进制数据的转换。

HttpMessageConverter接口实现类	作用
ByteArrayHttpMessageConverter	负责读取二进制格式的数据和写出二进制格式的数据
StringHttpMessageConverter	负责读取字符串格式的数据和写出字符串格式的数据
ResourceHttpMessageConverter	负责读取资源文件和写出资源文件
SourceHttpMessageConverter	能够读/写来自Http的请求与响应的javax.xml.transform.Source，支持DOMSource，SAXSource，和StreamSource的xml格式
AllEncompassingFormHttpMessageConverter	负责处理表单（form）数据
Jaxb2RootElementHttpMessageConverter	使用JAXB负责读取和写入xml标签格式的数据
MappingJackson2HttpMessageConverter	负责读取和写入json格式的数据。利用Jackson和ObjectMapper读写json数据，操作Object类型数据，可读取application/json，响应媒体类型为application/json

3、统一解决JSON字符串返回

在类上直接使用@RestController，该类中所有的方法都只会返回json字符串，不需要在每一方法上添加@ResponseBody。

@RestController
public class UserController {
   @RequestMapping("/j1")
   //@ResponseBody  //不会走视图解析器,会直接返回一个字符串
   public String json01() throws JsonProcessingException {
       //创建一个jackson的对象映射器，用来解析数据
       ObjectMapper mapper = new ObjectMapper();
       //创建一个对象
       User user = new User(1,"张三",20);
       //将我们的对象解析成为json格式
       String str = mapper.writeValueAsString(user);
       //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
       return str;
  }
}

4、测试集合输出以及输出时间对象

集合输出：

@RequestMapping("/j2")
public String json02() throws JsonProcessingException {
    //ObjectMapper mapper = new ObjectMapper();

    List<User> userList = new ArrayList<>();

    User user1 = new User(1,"张三",18);
    User user2 = new User(2,"李四",19);
    User user3 = new User(3,"王五",18);
    User user4 = new User(4,"赵二",20);

    userList.add(user1);
    userList.add(user2);
    userList.add(user3);
    userList.add(user4);
    /*
        String str = mapper.writeValueAsString(userList);
        return str;
         */
    return new ObjectMapper().writeValueAsString(userList);
}

输出时间对象：

@RequestMapping("/j3")
public String json03() throws JsonProcessingException {
    /*
        ObjectMapper mapper = new ObjectMapper();

        Date date = new Date();
        //自定义日期格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        return  mapper.writeValueAsString(sdf.format(date));
        */
    ObjectMapper mapper = new ObjectMapper();
    //不使用时间戳的方式
    mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
    mapper.setDateFormat(sdf);

    Date date = new Date();
    return mapper.writeValueAsString(date);
}

• 默认日期格式会是一串数字，是从1970年1月1日到当前日期的毫秒数
• Jackson默认是会把时间转换成timestamps（时间戳）形式

5、抽象为工具类

经常使用的话，可以将一些代码封装到一个工具类中。

package com.lskj.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

import java.text.SimpleDateFormat;

public class JSONUtils {

    public static String getJSON(Object object){
        return getJSON(object,"yyyy年MM月dd日 HH时mm分ss秒");
    }

    public static String getJSON(Object object,String dataFormat){
        ObjectMapper mapper = new ObjectMapper();
        //不使用时间戳的方式
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
        SimpleDateFormat sdf = new SimpleDateFormat(dataFormat);
        mapper.setDateFormat(sdf);

        try {
            return mapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }
}

使用工具类，代码就更加简洁了。

@RequestMapping("/j4")
public String json04(){
    Date date = new Date();
    return JSONUtils.getJSON(date,"yyyy年MM月dd日 HH时mm分ss秒");
}

@RequestMapping("/j5")
public String json05(){
    List<User> userList = new ArrayList<>();

    User user1 = new User(1,"张三",18);
    User user2 = new User(2,"李四",19);
    User user3 = new User(3,"王五",18);
    User user4 = new User(4,"赵二",20);

    userList.add(user1);
    userList.add(user2);
    userList.add(user3);
    userList.add(user4);

    return JSONUtils.getJSON(userList);
}

6、FastJson

fastjson.jar是阿里巴巴开发的一款专门用于Java开发的包，可以方便地实现json对象与JavaBean对象的转换，实现JavaBean对象json字符串的转换，实现json对象与json字符串的转换。

fastjson三个主要的类：

JSONObject 代表 json 对象

• JSONObject实现了Map接口, 猜想 JSONObject底层操作是由Map实现的。
• JSONObject对应json对象，通过各种形式的get()方法可以获取json对象中的数据，也可利用诸如size()，isEmpty()等方法获取”键：值”对的个数和判断是否为空。其本质是通过实现Map接口并调用接口中的方法完成的。

JSONArray 代表 json 对象数组

• 内部是有List接口中的方法来完成操作的。

JSON代表 JSONObject和JSONArray的转化

• JSON类源码分析与使用
• 仔细观察这些方法，主要是实现json对象，json对象数组，javabean对象，json字符串之间的相互转化

测试：

首先导入依赖，然后需在项目结构中添加依赖。

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

@RequestMapping("/j6")
public String json06(){
    List<User> userList = new ArrayList<>();

    User user1 = new User(1,"张三",18);
    User user2 = new User(2,"李四",19);
    User user3 = new User(3,"王五",18);
    User user4 = new User(4,"赵二",20);

    userList.add(user1);
    userList.add(user2);
    userList.add(user3);
    userList.add(user4);

    System.out.println("*******Java对象 转 JSON字符串*******");
    String str1 = JSON.toJSONString(userList);
    System.out.println("JSON.toJSONString(list)==>"+str1);
    String str2 = JSON.toJSONString(user1);
    System.out.println("JSON.toJSONString(user1)==>"+str2);

    System.out.println("\n****** JSON字符串 转 Java对象*******");
    User jp_user1=JSON.parseObject(str2,User.class);
    System.out.println("JSON.parseObject(str2,User.class)==>"+jp_user1);

    System.out.println("\n****** Java对象 转 JSON对象 ******");
    JSONObject jsonObject1 = (JSONObject) JSON.toJSON(user2);
    System.out.println("(JSONObject) JSON.toJSON(user2)==>"+jsonObject1.getString("name"));

    System.out.println("\n****** JSON对象 转 Java对象 ******");
    User to_java_user = JSON.toJavaObject(jsonObject1, User.class);
    System.out.println("JSON.toJavaObject(jsonObject1, User.class)==>"+to_java_user);


    String str = JSON.toJSONString(userList);

    return str;
}

八、整合SSM框架

1、环境搭建

1-1、数据库环境

创建一个存放书籍数据的数据库表。

CREATE DATABASE `ssmbuild`;

USE `ssmbuild`;

DROP TABLE IF EXISTS `books`;

CREATE TABLE `books` (
`bookID` INT(10) NOT NULL AUTO_INCREMENT COMMENT '书id',
`bookName` VARCHAR(100) NOT NULL COMMENT '书名',
`bookCounts` INT(11) NOT NULL COMMENT '数量',
`detail` VARCHAR(200) NOT NULL COMMENT '描述',
KEY `bookID` (`bookID`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;

INSERT  INTO `books`(`bookID`,`bookName`,`bookCounts`,`detail`)VALUES
(1,'Java',1,'从入门到放弃'),
(2,'MySQL',10,'从删库到跑路'),
(3,'Linux',5,'从进门到进牢');

1-2、基本环境搭建

1. 新建一个Maven项目-ssmbuild，添加web支持。

2. 导入相关的pom依赖。

   <?xml version="1.0" encoding="UTF-8"?>
   <project xmlns="http://maven.apache.org/POM/4.0.0"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
       <modelVersion>4.0.0</modelVersion>
   
       <groupId>com.lskj</groupId>
       <artifactId>ssmbuild</artifactId>
       <version>1.0-SNAPSHOT</version>
   
       <!--依赖：junit，数据库驱动，连接池，Servlet，JSP，Mybatis，mybatis-spring，spring...-->
       <dependencies>
           <!--Junit-->
           <dependency>
               <groupId>junit</groupId>
               <artifactId>junit</artifactId>
               <version>4.12</version>
           </dependency>
           <!--数据库驱动-->
           <dependency>
               <groupId>mysql</groupId>
               <artifactId>mysql-connector-java</artifactId>
               <version>5.1.47</version>
           </dependency>
           <!-- 数据库连接池：c3p0 -->
           <dependency>
               <groupId>com.mchange</groupId>
               <artifactId>c3p0</artifactId>
               <version>0.9.5.2</version>
           </dependency>
   
           <!--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>
           <dependency>
               <groupId>javax.servlet</groupId>
               <artifactId>jstl</artifactId>
               <version>1.2</version>
           </dependency>
   
           <!--Mybatis-->
           <dependency>
               <groupId>org.mybatis</groupId>
               <artifactId>mybatis</artifactId>
               <version>3.5.2</version>
           </dependency>
           <dependency>
               <groupId>org.mybatis</groupId>
               <artifactId>mybatis-spring</artifactId>
               <version>2.0.2</version>
           </dependency>
   
           <!--Spring-->
           <dependency>
               <groupId>org.springframework</groupId>
               <artifactId>spring-webmvc</artifactId>
               <version>5.1.9.RELEASE</version>
           </dependency>
           <dependency>
               <groupId>org.springframework</groupId>
               <artifactId>spring-jdbc</artifactId>
               <version>5.1.9.RELEASE</version>
           </dependency>
   
           <dependency>
               <groupId>org.aspectj</groupId>
               <artifactId>aspectjweaver</artifactId>
               <version>1.9.6</version>
           </dependency>
   
           <!--lombok-->
           <dependency>
               <groupId>org.projectlombok</groupId>
               <artifactId>lombok</artifactId>
               <version>1.18.12</version>
           </dependency>
       </dependencies>
   
       <!--静态资源导出问题-->
       <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>
   </project>

3. 建立基本结构和配置框架

   • com.lskj.pojo

   • com.lskj.dao

   • com.lskj.service

   • com.lskj.controller

   • mybatis-config.xml

     <?xml version="1.0" encoding="UTF-8" ?>
     <!DOCTYPE configuration
            PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-config.dtd">
     <configuration>
     
     </configuration>

   • applicationContext.xml

     <?xml version="1.0" encoding="UTF-8"?>
     <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd">
     
     </beans>

2、Mybatis层编写

1、数据库配置文件database.properties

jdbc.driver=com.mysql.jdbc.Driver
# 如果使用的是MySQL8.0+，需增加一个时区配置：&serverTimezone=Asia/Shanghai
jdbc.url=jdbc:mysql://localhost:3306/ssmbuild?useSSL=false&useUnicode=true&characterEncoding=utf8
jdbc.username=root
jdbc.password=root

2、IDEA连接数据库

3、编写Mybatis的核心配置文件：mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!--标椎的日志工厂的实现-->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

    <!--配置数据源，交给Spring去做-->
    <typeAliases>
        <package name="com.lskj.pojo"/>
    </typeAliases>

    <mappers>
        <mapper class="com.lskj.dao.BookMapper"/>
    </mappers>

</configuration>

4、编写数据库对应的实体类com.lskj.pojo.Books

package com.lskj.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Books {
    private int bookID;
    private String bookName;
    private int bookCounts;
    private String detail;
}

5、编写Dao层的Mapper接口

package com.lskj.dao;

import com.lskj.pojo.Books;
import org.apache.ibatis.annotations.Param;
import org.springframework.web.bind.annotation.PathVariable;

import java.util.List;

public interface BookMapper {
    //增加一本书
    int addBook(Books books);

    //删除一本书
    int deleteBook(@Param("bookID") int id);

    //更新一本书
    int updateBook(Books books);

    //查询一本书
    Books queryBookById(@Param("bookID") int id);

    //查询全部的书
    List<Books> queryAllBook();

    //根据书名查询
    Books queryBookByName(@Param("bookName") String bookName);
}

6、编写接口对应的Mapper.xml文件。【需要导入Mybatis的包】

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.lskj.dao.BookMapper">
    <insert id="addBook" parameterType="Books">
        insert into ssmbuild.books (bookName,bookCounts,detail)
        values (#{bookName},#{bookCounts},#{detail});
    </insert>

    <delete id="deleteBook" parameterType="int">
        delete from ssmbuild.books where bookID = #{bookID};
    </delete>

    <update id="updateBook" parameterType="Books">
        update ssmbuild.books
        set bookName = #{bookName},bookCount = #{bookCounts},detail = #{detail}
        where bookId = #{bookID};
    </update>

    <select id="queryBookById" resultType="Books">
        select * from ssmbuild.books
        where bookID = #{bookID};
    </select>

    <select id="queryAllBook" resultType="Books">
        select * from ssmbuild.books;
    </select>

    <select id="queryBookByName" resultType="Books">
        select * from ssmbuild.books where bookName = #{bookName};
    </select>
</mapper>

7、编写Service层的接口和实现类

接口：

package com.lskj.service;

import com.lskj.pojo.Books;
import org.apache.ibatis.annotations.Param;

import java.util.List;

public interface BookService {
    //增加一本书
    int addBook(Books books);

    //删除一本书
    int deleteBook(int id);

    //更新一本书
    int updateBook(Books books);

    //查询一本书
    Books queryBookById(int id);

    //查询全部的书
    List<Books> queryAllBook();

    Books queryBookByName(String bookName);
}

实现类：

package com.lskj.service;

import com.lskj.dao.BookMapper;
import com.lskj.pojo.Books;

import java.util.List;

public class BookServiceImpl implements BookService{
    //service调dao层：组合Dao
    private BookMapper bookMapper;
    public void setBookMapper(BookMapper bookMapper){
        this.bookMapper = bookMapper;
    }

    @Override
    public int addBook(Books books) {
        return bookMapper.addBook(books);
    }

    @Override
    public int deleteBook(int id) {
        return bookMapper.deleteBook(id);
    }

    @Override
    public int updateBook(Books books) {
        System.out.println("BookServiceImpl:updateBook=>"+books);
        return bookMapper.updateBook(books);
    }

    @Override
    public Books queryBookById(int id) {
        return bookMapper.queryBookById(id);
    }

    @Override
    public List<Books> queryAllBook() {
        return bookMapper.queryAllBook();
    }

    @Override
    public Books queryBookByName(String bookName) {
        return bookMapper.queryBookByName(bookName);
    }
}

3、Spring层

1. 配置Spring整合Mybatis，数据源使用c3p0连接池

2. 编写Spring整合Mybatis的相关配置文件：spring-dao.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"
          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">
   
       <!--关联数据库配置文件-->
       <context:property-placeholder location="classpath:database.properties"/>
   
       <!--连接池
       dbcp：半自动化操作，不能自动连接
       c3p0：自动化操作（自动化的加载配置文件，并且可以自动设置到对象中！）
       druid：
       hikari：
       -->
       <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
           <property name="driverClass" value="${jdbc.driver}"/>
           <property name="jdbcUrl" value="${jdbc.url}"/>
           <property name="user" value="${jdbc.username}"/>
           <property name="password" value="${jdbc.password}"/>
   
           <!--c3p0连接池的私有属性-->
           <property name="maxPoolSize" value="30"/>
           <property name="minPoolSize" value="10"/>
           <!--关闭连接后不自动commit-->
           <property name="autoCommitOnClose" value="false"/>
           <!--获取连接超时时间-->
           <property name="checkoutTimeout" value="10000"/>
           <!--当获取连接失败重试次数-->
           <property name="acquireRetryAttempts" value="2"/>
       </bean>
   
       <!--sqlSessionFactory-->
       <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
           <property name="dataSource" ref="dataSource"/>
           <!--绑定Mybatis的配置文件-->
           <property name="configLocation" value="classpath:mybatis-config.xml"/>
       </bean>
   
       <!--配置dao接口扫描包，动态的实现Dao接口可以注入到Spring容器中-->
       <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
           <!--注入sqlSessionFactory-->
           <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
           <!--要扫描的dao包-->
           <property name="basePackage" value="com.lskj.dao"/>
       </bean>
   </beans>

3. Spring整合service层：spring-service.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:aop="http://www.springframework.org/schema/aop"
          xmlns:tx="http://www.springframework.org/schema/tx"
          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/aop
          https://www.springframework.org/schema/aop/spring-aop.xsd
          http://www.springframework.org/schema/tx
          http://www.springframework.org/schema/tx/spring-tx.xsd">
   
       <!--1、扫描service下的包-->
       <context:component-scan base-package="com.lskj.service"/>
   
       <!--2、将所有业务类注入到Spring，可以通过配置，或者注解实现-->
       <bean id="BookServiceImpl" class="com.lskj.service.BookServiceImpl">
           <property name="bookMapper" ref="bookMapper"/>
       </bean>
   
       <!--3、声明式事务配置-->
       <bean id="transactionManger" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
           <!--注入数据源-->
           <property name="dataSource" ref="dataSource"/>
       </bean>
   
       <!--4、aop事务支持-->
       <!--结合AOP实现事务的织入-->
       <!--配置事务通知：-->
       <tx:advice id="txAdvice" transaction-manager="transactionManger">
           <!--给那些方法配置事务-->
           <!--配置事务的传播特性：new propagation=  -->
           <tx:attributes>
               <tx:method name="*" propagation="REQUIRED"/>
           </tx:attributes>
       </tx:advice>
   
       <!--配置事务切入-->
       <aop:config>
           <aop:pointcut id="txPointCut" expression="execution(* com.lskj.dao.*.*(..))"/>
           <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
       </aop:config>
   </beans>

4、SpringMVC层

1、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>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <!--注意:这里加载的是总的配置文件，若不是后续会报错：bean不存在！-->
            <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>

    <!--乱码过滤-->
    <filter>
        <filter-name>encodingFilter</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>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

</web-app>

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

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

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

    <!--3、扫描包：Controller-->
    <context:component-scan base-package="com.lskj.controller"/>

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


</beans>

3、Spring配置整合文件：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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <import resource="classpath:spring-dao.xml"/>
    <import resource="classpath:spring-service.xml"/>
    <import resource="classpath:spring-mvc.xml"/>

</beans>

5、Controller、视图层编写

1、BookController类编写，方法一：查询全部书籍

package com.lskj.controller;

import com.lskj.pojo.Books;
import com.lskj.service.BookService;
import com.lskj.service.BookServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.List;

@Controller
@RequestMapping("/book")
public class BookController {
    //controller调service
    @Autowired
    @Qualifier("BookServiceImpl")
    private BookService bookService;// = new BookServiceImpl();

    //查询全部的书籍，并且返回到一个书籍展示页面
    @RequestMapping("/allBook")
    public String list(Model model){
        List<Books> list = bookService.queryAllBook();
        model.addAttribute("list",list);
        return "allBook";
    }
}

2、编写首页index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>首页</title>
    <style>
      a{
        text-decoration: none;
        color: black;
        font-size: 18px;
      }
      h3{
        width: 180px;
        height: 38px;
        margin: 100px auto;
        text-align: center;
        line-height: 38px;
        background: deepskyblue;
        border-radius: 5px;
      }
    </style>
  </head>
  <body>
  <h3>
    <a href="${pageContext.request.contextPath}/book/allBook">进入书籍页面</a>
  </h3>
  </body>
</html>

3、书籍列表页面allBook.jsp

Bootstrap中文网：https://www.bootcss.com/

Bootstrap可视化布局：https://www.bootcss.com/p/layoutit/

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>书籍展示</title>

    <%--BootStrap美化界面--%>
    <link href="https://cdn.staticfile.org/twitter-bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
 <div class="container">
     <div class="row clearfix">
         <div class="col-md-12 column">
             <div class="page-header">
                 <h1>
                     <small>书籍列表————显示所有书籍</small>
                 </h1>
             </div>
         </div>

         <div class="row">
             <div class="col-md-4 column">
                 <%--toAddBook--%>
                 <a  class="btn btn-primary" href="${pageContext.request.contextPath}/book/toAddBook">新增书籍</a>
                 <a  class="btn btn-primary" href="${pageContext.request.contextPath}/book/allBook">显示全部书籍</a>
             </div>
             <div class="col-md-4 column">
                 <%--查询书籍--%>
                 <form class="form-inline" action="${pageContext.request.contextPath}/book/queryBook" method="post" style="float: right">
                     <span style="color: red;font-weight: bold">${error}</span>
                     <input type="text" name="queryBookName" class="form-control" placeholder="请输入要查询的书籍名称">
                     <input type="submit" value="查询" class="btn btn-primary">
                 </form>
             </div>
         </div>
     </div>

     <div class="row clearfix">
         <div class="col-md-12 column">
             <table class="table table-hover table-striped">
                 <thead>
                     <tr>
                         <th>书籍编号</th>
                         <th>书籍名称</th>
                         <th>书籍数量</th>
                         <th>书籍详情</th>
                         <th>操作</th>
                     </tr>
                 </thead>

                 <%--书籍从数据库中查询出来，从list中遍历出来：foreach--%>
                 <tbody>
                     <c:forEach var="book" items="${list}">
                         <tr>
                             <td>${book.bookID}</td>
                             <td>${book.bookName}</td>
                             <td>${book.bookCounts}</td>
                             <td>${book.detail}</td>
                             <td>
                                 <a href="${pageContext.request.contextPath}/book/toUpdate?id=${book.bookID}">修改</a>
                                 &nbsp;|&nbsp;
                                 <a href="${pageContext.request.contextPath}/book/deleteBook/${book.bookID}">删除</a>
                             </td>
                         </tr>
                     </c:forEach>
                 </tbody>
             </table>
         </div>
     </div>
 </div>
</body>
</html> 

4、BookController类编写，方法二：添加书籍

//跳转到增加书籍页面
@RequestMapping("/toAddBook")
public String toAddPage(){
    return "addBook";
}
//添加书籍的请求
@RequestMapping("/addBook")
public String addBook(Books books){
    System.out.println("addBook=>"+books);
    bookService.addBook(books);
    return "redirect:/book/allBook"; //重定向到 @RequestMapping("/allBook")请求
}

5、添加书籍页面：addBook.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>新增书籍</title>
    <%--BootStrap美化界面--%>
    <link href="https://cdn.staticfile.org/twitter-bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
    <div class="container">
        <div class="row clearfix">
            <div class="col-md-12 column">
                <div class="page-header">
                    <h1>
                        <small>新增书籍</small>
                    </h1>
                </div>
            </div>
        </div>

        <form action="${pageContext.request.contextPath}/book/addBook" method="post">
            <div class="form-group">
                <label>书籍名称：</label>
                <input type="text" name="bookName" class="form-control" required>
            </div>
            <div class="form-group">
                <label>书籍数量：</label>
                <input type="text" name="bookCounts" class="form-control" required>
            </div>
            <div class="form-group">
                <label>书籍描述：</label>
                <input type="text" name="detail" class="form-control" required>
            </div>
            <div class="form-group">
                <input type="submit" class="form-control" value="添加">
            </div>
        </form>
    </div>
</body>
</html>

6、BookController类编写，方法三：修改书籍

//跳转到修改页面
@RequestMapping("/toUpdate")
public String toUpdatePage(int id,Model model){
    Books books = bookService.queryBookById(id);
    model.addAttribute("QBook",books);
    return "updateBook";
}

//修改书籍
@RequestMapping("/updateBook")
public String updateBook(Books books){
    System.out.println("updateBook=>"+books);
    bookService.updateBook(books);
    return "redirect:/book/allBook";
}

7、修改书籍页面：updateBook.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>修改书籍</title>
    <%--BootStrap美化界面--%>
    <link href="https://cdn.staticfile.org/twitter-bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<div class="container">
    <div class="row clearfix">
        <div class="col-md-12 column">
            <div class="page-header">
                <h1>
                    <small>修改书籍</small>
                </h1>
            </div>
        </div>
    </div>

    <form action="${pageContext.request.contextPath}/book/addBook" method="post">
        <%--出现的问题：提交了修改的SQL请求，但是修改失败--%>
        <%--看SQL语句，能否执行成功：SQL执行失败，修改未完成--%>
        <%--前端传递隐藏域--%>
        <input type="hidden" name="bookID" value="${QBook.bookID}">
        <div class="form-group">
            <label>书籍名称：</label>
            <input type="text" name="bookName" class="form-control" value="${QBook.bookName}" required>
        </div>
        <div class="form-group">
            <label>书籍数量：</label>
            <input type="text" name="bookCounts" class="form-control" value="${QBook.bookCounts}" required>
        </div>
        <div class="form-group">
            <label>书籍描述：</label>
            <input type="text" name="detail" class="form-control" value="${QBook.detail}" required>
        </div>
        <div class="form-group">
            <input type="submit" class="form-control" value="修改">
        </div>
    </form>
</div>
</body>
</html>

8、BookController类编写，方法四：删除书籍

//删除书籍
@RequestMapping("/deleteBook/{bookID}")
public String deleteBook(@PathVariable("bookID") int id){
    bookService.deleteBook(id);
    return "redirect:/book/allBook";
}

9、BookController类编写，方法四：根据书名查询书籍（搜索）

//根据书名查询书籍
@RequestMapping("/queryBook")
public String queryBook(String queryBookName,Model model){
    Books books = bookService.queryBookByName(queryBookName);

    List<Books> list = new ArrayList<Books>();
    list.add(books);

    if(books == null){
        list = bookService.queryAllBook();
        model.addAttribute("error","未查到");
    }

    model.addAttribute("list",list);
    return "allBook";
}

九、AJAX

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

1、jQuery.ajax

Ajax的核心是XMLHTTPRequest对象（XHR）。XHR为向服务器发送请求和解析服务器响应提供了接口。能够以异步方式从服务器获取新数据。

jQuery提供多个与Ajax有关的方法。

通过jQuery Ajax方法，能够使用HTTP GET和HTTP POST从远程服务器上请求文本、HTML、XML或JSON，同时能够把这些外部数据直接载入网页的被选元素中。

jQuery不是生产者，而是大自然的搬运工。

jQuery Ajax本质就是XMLHTTPRequest，对它进行了封装，方便调用。

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 将自动替换 ? 为正确的函数名，以执行回调函数

2、测试

使用原始的HttpServletResponse处理

1、配置web.xml和springmvc的配置文件[applicationContext.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: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>

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

<?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.lskj.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>

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

</beans>

2、编写一个AjaxController类

@RestController
public class AjaxController {

    @RequestMapping("/t1")
    public String test(){
        return "hello";
    }

    @RequestMapping("/a1")
    public void a1(String name, HttpServletResponse response) throws IOException {
        System.out.println("a1:param=>"+name);
        if ("lskj".equals(name)){
            response.getWriter().print("true");
        }else {
            response.getWriter().print("false");
        }
    }
}

3、导入jQuery（可使用在线CDN，也可下载导入）

<script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.5.1/jquery.js"></script>
<script src="${pageContext.request.contextPath}/statics/js/jquery-3.5.1.js"></script>

4、编写index.jsp测试

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>

    <script src="${pageContext.request.contextPath}/statics/js/jquery-3.5.1.js"></script>
    <script>
      function a(){
        $.post({
          url:"${pageContext.request.contextPath}/a1",
          data:{"name":$("#username").val()},
          success:function (data) {
            alert(data);
          }
        })
      }
    </script>
  </head>
  <body>
  <%--失去焦点时，发起一个请求到后台--%>
  用户名：<input type="text" id="username" onblur="a()">
  </body>
</html>

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

SpringMVC实现

实体类User

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

获取一个集合对象，展示到前端页面

@RequestMapping("/a2")
public List<User> a2(){
    List<User> userList = new ArrayList<>();
    //添加数据
    userList.add(new User("张三",18,"男"));
    userList.add(new User("李四",19,"男"));
    userList.add(new User("王五",20,"男"));

    return userList;
}

前端页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <script src="${pageContext.request.contextPath}/statics/js/jquery-3.5.1.js"></script>

    <script>
        $(function () {
            $("#btn").click(function () {
                /*
                $.post(url,param[可以省略],success)
                 */
                $.post("${pageContext.request.contextPath}/a2",function (data) {
                    //console.log(data);
                    var 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>
</head>
<body>
<input type="button" value="加载数据" id="btn">
<table>
    <tr>
        <td>姓名</td>
        <td>年龄</td>
        <td>性别</td>
    </tr>
    <tbody id="content">
        <%--数据：后台--%>
    </tbody>
</table>
</body>
</html>

注册提示效果

编写AjaxController类

@RequestMapping("/a3")
public String a3(String name,String pwd){
    String msg = "";
    if(name != null){
        if ("admin".equals(name)){
            msg = "ok";
        }else{
            msg = "用户名有误！";
        }
    }
    if(pwd != null){
        if ("admin".equals(pwd)){
            msg = "ok";
        }else{
            msg = "密码有误！";
        }
    }
    return msg;
}

前端页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <script src="${pageContext.request.contextPath}/statics/js/jquery-3.5.1.js"></script>
    <script>
        function a1() {
            $.post({
                url: "${pageContext.request.contextPath}/a3",
                data:  {"name":$("#name").val()},
                success: function (data) {
                    //console.log(data);
                    if (data.toString() == 'ok'){
                        $("#userInfo").css("color","green");
                    }else {
                        $("#userInfo").css("color","red");
                    }
                    $("#userInfo").html(data);
                }
            })
        }
        function a2() {
            $.post({
                url: "${pageContext.request.contextPath}/a3",
                data:  {"pwd":$("#pwd").val()},
                success: function (data) {
                    //console.log(data);
                    if (data.toString() == 'ok'){
                        $("#pwdInfo").css("color","green");
                    }else {
                        $("#pwdInfo").css("color","red");
                    }
                    $("#pwdInfo").html(data);
                }
            })
        }
    </script>
</head>
<body>

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

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

</body>
</html>

获取百度接口

<!DOCTYPE HTML>
<html>
<head>
   <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
   <title>JSONP百度搜索</title>
   <style>
       #q{
           width: 500px;
           height: 30px;
           border:1px solid #ddd;
           line-height: 30px;
           display: block;
           margin: 0 auto;
           padding: 0 10px;
           font-size: 14px;
      }
       #ul{
           width: 520px;
           list-style: none;
           margin: 0 auto;
           padding: 0;
           border:1px solid #ddd;
           margin-top: -1px;
           display: none;
      }
       #ul li{
           line-height: 30px;
           padding: 0 10px;
      }
       #ul li:hover{
           background-color: #f60;
           color: #fff;
      }
   </style>
   <script>

       // 2.步骤二
       // 定义demo函数 (分析接口、数据)
       function demo(data){
           var Ul = document.getElementById('ul');
           var html = '';
           // 如果搜索数据存在 把内容添加进去
           if (data.s.length) {
               // 隐藏掉的ul显示出来
               Ul.style.display = 'block';
               // 搜索到的数据循环追加到li里
               for(var i = 0;i<data.s.length;i++){
                   html += '<li>'+data.s[i]+'</li>';
              }
               // 循环的li写入ul
               Ul.innerHTML = html;
          }
      }

       // 1.步骤一
       window.onload = function(){
           // 获取输入框和ul
           var Q = document.getElementById('q');
           var Ul = document.getElementById('ul');

           // 事件鼠标抬起时候
           Q.onkeyup = function(){
               // 如果输入框不等于空
               if (this.value != '') {
                   // ☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆JSONPz重点☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆
                   // 创建标签
                   var script = document.createElement('script');
                   //给定要跨域的地址 赋值给src
                   //这里是要请求的跨域的地址 我写的是百度搜索的跨域地址
                   script.src = 'https://sp0.baidu.com/5a1Fazu8AA54nxGko9WTAnF6hhy/su?wd='+this.value+'&cb=demo';
                   // 将组合好的带src的script标签追加到body里
                   document.body.appendChild(script);
              }
          }
      }
   </script>
</head>

<body>
<input type="text" id="q" />
<ul id="ul">

</ul>
</body>
</html>

十、异常处理

SpringMVC框架处理异常的常用方式：

• 使用系统定义好的异常处理器SimpleMappingExceptionResolver

• 使用自定义异常处理器

• 使用注解处理异常

springmvc框架采用的是统一、全局的异常处理。把controller中的所有异常处理都集中到一个地方。采用的是aop的思想。把业务逻辑和异常处理代码分开，解耦合。

使用两个注解：

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

• @ControllerAdvice，是给控制器对象增强功能的。使用该注解修饰的类可以使用@ExceptionHandler。当使用@RequestMapping注解修饰的方法抛出异常时，会执行@ControllerAdvice修饰类中的异常处理方法。

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

异常处理步骤：

1、新建maven web项目

2、加入依赖

3、新建一个自定义异常类（可再定义它的子类）

4、在controller抛出异常

5、创建一个普通类，作用是全局异常处理类

• 在类上面加入@ControllerAdvice
• 在类中定义方法，方法的上面加入@ExceptionHandler

6、创建处理异常的视图页面

7、创建springmvc的配置文件

• 组件扫描器，扫描@Controller
• 组件扫描器，扫描@ControllerAdvic所在的包名
• 声明注解驱动

十一、拦截器

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

过滤器与拦截器的区别：拦截器是AOP思想的具体应用。

• 过滤器
  • Servlet规范中的一部分，任何java web工程都可以使用
  • 由tomcat服务器创建的对象
  • 在url-pattern中配置了/*之后，可以对所有要访问的资源进行拦截
  • 用来过滤请求参数，设置编码字符集等
• 拦截器
  • 拦截器是SpringMVC框架自已的，只有使用了SpringMVC框架的工程才能使用
  • 拦截器只会拦截访问控制器方法，如果访问的是jsp/html/css/image/js等资源文件是不会进行拦截的
  • 拦截用户的请求，对请求做判断处理

1、自定义拦截器

自定义拦截器，必须实现HandlerInterceptor接口。

1. 新建一个Moudle，并添加web支持

2. 配置web.xml和springmvc-servlet.xml文件

3. 编写一个拦截器

   package com.lskj.config;
   
   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 {
           System.out.println("=========处理前==========");
           return true;
       }
   
       //在请求处理方法执行后执行
       @Override
       public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
           System.out.println("=========处理后==========");
       }
   
       //DispatcherServlet处理后执行：做清理工作
       @Override
       public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
           System.out.println("=========清理==========");
       }
   }
   

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

   <!--拦截器配置-->
   <mvc:interceptors>
       <mvc:interceptor>
           <!--
           指定拦截的请求uri地址
               /*包括当前路径下的请求
               /**包括这个请求下面的所有请求（包括路径及其子路径）
           -->
           <mvc:mapping path="/**"/>
           <!--bean配置的就是拦截器-->
           <bean class="com.lskj.config.MyInterceptor"/>
       </mvc:interceptor>
   </mvc:interceptors>

5. 编写一个Controller接收请求

   package com.lskj.controller;
   
   import org.springframework.web.bind.annotation.GetMapping;
   import org.springframework.web.bind.annotation.RestController;
   
   @RestController
   public class TestController {
       @GetMapping("/t1")
       public String test(){
           System.out.println("TestController中的test方法执行了！");
           return "test";
       }
   }

6. 前端

   <a href="${pageContext.request.contextPath}/t1">拦截器测试</a>

7. 启动Tomact测试

2、验证用户是否登录

实现思路

• 有一个登录页面，需要写一个controller访问页面
• 登录页面有一个提交表单的动作，需要在controller中处理。判断用户名、密码是否正确，如果正确，往session中写入用户信息
• 拦截用户请求，判断用户是否登录，如果用户已经登录，放行；若未登录，跳转到登录页面。

1. 编写登录页面login.jsp

   <%@ page contentType="text/html;charset=UTF-8" language="java" %>
   <html>
   <head>
       <title>Title</title>
   </head>
   <body>
   <%--在web-inf下的所有页面或者资源，只能通过controller，或者Servlet进行访问--%>
   <h1>登录页面</h1>
   
   <form action="${pageContext.request.contextPath}/user/login" method="post">
       用户名：<input type="text" name="username">
       密码：<input type="text" name="password">
       <input type="submit" value="提交">
   </form>
   
   </body>
   </html>

2. 编写Controller处理请求

   package com.lskj.controller;
   
   import org.springframework.stereotype.Controller;
   import org.springframework.ui.Model;
   import org.springframework.web.bind.annotation.RequestMapping;
   import org.springframework.web.bind.annotation.RestController;
   
   import javax.servlet.http.HttpSession;
   
   @Controller
   @RequestMapping("/user")
   public class LoginController {
   
       @RequestMapping("/main")
       public String main(){
           return "main";
       }
   
       //跳转到登录页面
       @RequestMapping("/goLogin")
       public String goLogin(){
           return "login";
       }
   
       //登录提交
       @RequestMapping("/login")
       public String login(HttpSession session, String username, String password, Model model){
           System.out.println("login=>username="+username);
           //把用户信息存在session中
           session.setAttribute("userLoginInfo",username);
           model.addAttribute("username",username);
           return "main";
       }
   
       //注销，退出登录
       @RequestMapping("/goOut")
       public String goOut(HttpSession session, String username, String password, Model model){
           //session.invalidate();
           session.removeAttribute("userLoginInfo");
           return "login";
       }
   }

3. 编写一个登录成功的页面main.jsp，即主页

   <%@ page contentType="text/html;charset=UTF-8" language="java" %>
   <html>
   <head>
       <title>Title</title>
   </head>
   <body>
   <h1>首页</h1>
   
   <span>${username}</span>
   <p>
       <a href="${pageContext.request.contextPath}/user/goOut">注销</a>
   </p>
   </body>
   </html>

4. 在index页面上测试跳转，启动Tomact测试，未登录也可以进入主页。

   <%@ page contentType="text/html;charset=UTF-8" language="java" %>
   <html>
     <head>
       <title>$Title$</title>
     </head>
     <body>
   
     <h1>
       <a href="${pageContext.request.contextPath}/user/goLogin">登录页面</a>
     </h1>
     <h1>
       <a href="${pageContext.request.contextPath}/user/main">首页</a>
     </h1>
   
     </body>
   </html>

5. 编写用户登录拦截器

   package com.lskj.config;
   
   import org.springframework.web.servlet.HandlerInterceptor;
   
   import javax.servlet.http.HttpServletRequest;
   import javax.servlet.http.HttpServletResponse;
   import javax.servlet.http.HttpSession;
   
   public class LoginInterceptor implements HandlerInterceptor {
       @Override
       public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
           HttpSession session = request.getSession();
           //放行：判断什么情况下登录
           //登录页面=>放行
           if (request.getRequestURI().contains("goLogin")){
               return true;
           }
   
           //
           if (request.getRequestURI().contains("login")){
               return true;
           }
   
           //第一次登录，也是没有session
           if (session.getAttribute("userLoginInfo") != null){
               return true;
           }
           //判断什么情况下没有登录
           request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request,response);
           return false;
       }
   }
   

6. 在SpringMVC的配置文件中注册拦截器

   <mvc:interceptor>
       <mvc:mapping path="/**"/>
       <bean class="com.lskj.config.LoginInterceptor"/>
   </mvc:interceptor>

7. 再次启动Tomact测试

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

多个拦截器中方法与处理器方法的执行顺序：

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

换一种表现方式，也可以像如下理解。

十二、文件上传和下载

文件上传是项目开发中最常见的功能之一 ,springMVC 可以很好的支持文件上传，但是SpringMVC上下文中默认没有装配MultipartResolver，因此默认情况下其不能处理文件上传工作。如果想使用Spring的文件上传功能，则需要在上下文中配置MultipartResolver。

前端表单要求：为了能上传文件，必须将表单的method设置为post，并将enctype设置为multipart/form-data。只有这样，浏览器才会百用户选择的文件以二进制形式发送给服务器。

表单enctype属性：

• application/x-www=from-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实现类：
• CommonsMultipartResolver。因此，SpringMVC的文件上传还需要依赖Apache Commons FileUpload的组件。

1、文件上传

1. 导入文件上传的jar包，commons-fileupload，maven会自动导入它的依赖包commons-io包

   <!--文件上传-->
   <dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.3.3</version>
   </dependency>
   <!--servlet-api导入高版本的-->
   <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>4.0.1</version>
   </dependency>

2. 配置bean：multipartResolver，这里bena的id必须为：multipartResolver ， 否则上传文件会报400的错误

   <!--文件上传配置-->
   <bean id="multipartResolver"  class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
      <!-- 请求的编码格式，必须和jSP的pageEncoding属性一致，以便正确读取表单的内容，默认为ISO-8859-1 -->
      <property name="defaultEncoding" value="utf-8"/>
      <!-- 上传文件大小上限，单位为字节（10485760=10M） -->
      <property name="maxUploadSize" value="10485760"/>
      <property name="maxInMemorySize" value="40960"/>
   </bean>

   CommonsMultipartFile 的 常用方法：

   • String getOriginalFilename()：获取上传文件的原名
   • InputStream getInputStream()：获取文件流
   • void transferTo(File dest)：将上传文件保存到一个目录文件中

3. 编写前端页面

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

4. Controller

   package com.lskj.controller;
   
   import org.springframework.web.bind.annotation.RequestMapping;
   import org.springframework.web.bind.annotation.RequestParam;
   import org.springframework.web.bind.annotation.RestController;
   import org.springframework.web.multipart.commons.CommonsMultipartFile;
   
   import javax.servlet.http.HttpServletRequest;
   import java.io.*;
   
   @RestController
   public class FileController {
       //@RequestParam("file") 将name=file控件得到的文件封装成CommonsMultipartFile 对象
       //批量上传CommonsMultipartFile则为数组即可
       @RequestMapping("/upload")
       public String fileUpload(@RequestParam("file") CommonsMultipartFile file , HttpServletRequest request) throws IOException {
   
           //获取文件名 : file.getOriginalFilename();
           String uploadFileName = file.getOriginalFilename();
   
           //如果文件名为空，直接回到首页！
           if ("".equals(uploadFileName)){
               return "redirect:/index.jsp";
           }
           System.out.println("上传文件名 : "+uploadFileName);
   
           //上传路径保存设置
           String path = request.getServletContext().getRealPath("/upload");
           //如果路径不存在，创建一个
           File realPath = new File(path);
           if (!realPath.exists()){
               realPath.mkdir();
           }
           System.out.println("上传文件保存地址："+realPath);
   
           InputStream is = file.getInputStream(); //文件输入流
           OutputStream os = new FileOutputStream(new File(realPath,uploadFileName)); //文件输出流
   
           //读取写出
           int len=0;
           byte[] buffer = new byte[1024];
           while ((len=is.read(buffer))!=-1){
               os.write(buffer,0,len);
               os.flush();
           }
           os.close();
           is.close();
           return "redirect:/index.jsp";
       }
   }

5. 测试上传文件

采用file.Transto来保存上传的文件

1. 编写Controller

   /*
        * 采用file.Transto 来保存上传的文件
        */
   @RequestMapping("/upload2")
   public String  fileUpload2(@RequestParam("file") CommonsMultipartFile file, HttpServletRequest request) throws IOException {
   
       //上传路径保存设置
       String path = request.getServletContext().getRealPath("/upload");
       File realPath = new File(path);
       if (!realPath.exists()){
           realPath.mkdir();
       }
       //上传文件地址
       System.out.println("上传文件保存地址："+realPath);
   
       //通过CommonsMultipartFile的方法直接写文件（注意这个时候）
       file.transferTo(new File(realPath +"/"+ file.getOriginalFilename()));
   
       return "redirect:/index.jsp";
   }

2. 修改前端表单提交地址

3. 测试

2、文件下载

文件下载步骤：

1、设置 response 响应头

2、读取文件 – InputStream

3、写出文件 – OutputStream

4、执行操作

5、关闭流 （先开后关）

代码实现：

@RequestMapping(value="/download")
public String downloads(HttpServletResponse response ,HttpServletRequest request) throws Exception{
   //要下载的文件地址
   String  path = request.getServletContext().getRealPath("/upload");
   String  fileName = "test.text";

   //1、设置response 响应头
   response.reset(); //设置页面不缓存,清空buffer
   response.setCharacterEncoding("UTF-8"); //字符编码
   response.setContentType("multipart/form-data"); //二进制传输数据
   //设置响应头
   response.setHeader("Content-Disposition",
           "attachment;fileName="+URLEncoder.encode(fileName, "UTF-8"));

   File file = new File(path,fileName);
   //2、 读取文件--输入流
   InputStream input=new FileInputStream(file);
   //3、 写出文件--输出流
   OutputStream out = response.getOutputStream();

   byte[] buff =new byte[1024];
   int index=0;
   //4、执行 写出操作
   while((index= input.read(buff))!= -1){
       out.write(buff, 0, index);
       out.flush();
  }
   out.close();
   input.close();
   return null;
}

前端：

<a href="/download">点击进行下载</a>