SpringMVC 基础

2022-04-09 本文已影响0人 yjtuuige

一、回顾 MVC

1.1 什么是 MVC

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

Model（模型）

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

View（视图）

负责进行模型的展示，一般指用户界面，客户想看到的东西；

Controller（控制器）

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

1.2 Model 1 时代

在 web 早期的开发中，通常采用的都是 Model1；
Model1 中，主要分为两层，视图层和模型层；
Model1 优点：架构简单，比较适合小型项目开发；
Model1 缺点：JSP 职责不单一，职责过重，不便于维护；

1.3 Model 2 时代

Model 2 ：把一个项目分成三部分，包括视图、控制、模型；

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

职责分析

Controller：控制器
- 取得表单数据；
- 调用业务逻辑；
- 转向指定的页面；
Model：模型
- 业务逻辑；
- 保存数据的状态；
View：视图
- 显示页面；

小结：

Model 2：不仅提高代码的复用率与项目的扩展性，且大大降低了项目的维护成本；
Model 1：实现比较简单，适用于快速开发小规模项目；
Model 1 中 JSP 页面，身兼 View 和 Controller 两种角色，将控制逻辑和表现逻辑混杂在一起，从而导致代码的重用性非常低，增加了应用的扩展性和维护的难度；
Model 2 消除了 Model 1 的缺点；

1.4 回顾 Servlet

运行环境：
- JDK 17；
- Tomcat 10.0.16；
新建一个 Maven 工程当做父工程，并添加相关依赖：
- JSP 标签及相关 Tomcat 配置：查看链接

<!--Servlet 依赖-->
<dependency>
    <groupId>jakarta.servlet</groupId>
    <artifactId>jakarta.servlet-api</artifactId>
    <version>5.0.0</version>
</dependency>
<!--JSP 依赖-->
<dependency>
    <groupId>com.guicedee.services</groupId>
    <artifactId>jakarta.servlet.jsp-api</artifactId>
    <version>62</version>
</dependency>
<!--jstl 表达式依赖-->
<dependency>
    <groupId>org.glassfish.web</groupId>
    <artifactId>jakarta.servlet.jsp.jstl</artifactId>
    <version>2.0.0</version>
</dependency>
<!--标签库依赖-->
<dependency>
    <groupId>org.apache.taglibs</groupId>
    <artifactId>taglibs-standard-spec</artifactId>
    <version>1.2.5</version>
</dependency>
<!--单元测试-->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
</dependency>
<!--spring-webmvc-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.17</version>
</dependency>

创建 Maven 子模块，并添加 Web app 的支持；
查看是否导入了父模块的所有依赖；
创建 Servlet，用来处理用户的请求：

@WebServlet("/hello")
public class HelloServlet 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/hello.jsp").forward(req, resp);
    }

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

跳转页面：
- 在 WEB-INF 目录下新建 jsp 目录，新建 hello.jsp；

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

<servlet>
    <servlet-name>HelloServlet</servlet-name>
    <servlet-class>com.study.springmvc.servlet.HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>HelloServlet</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>

IDEA 中配置 Tomcat：查看链接
启动测试：
- localhost:8080/映射地址/hello?method=add；
- localhost:8080/映射地址/hello?method=delete；

MVC 框架要做哪些事情

将 url 映射到 Java 类或 Java 类的方法；
封装用户提交的数据；
处理请求 --> 调用相关的业务处理 --> 封装响应数据；
将响应的数据进行渲染，.jsp/html 表示层数据；

小结：

常见的 服务器端 MVC 框架：Struts、Spring MVC、ASP.NET MVC、Zend Framework、JSF；
常见 前端 MVC 框架：vue、angularjs、react、backbone；
由 MVC 演化出了另外一些模式，如：MVP、MVVM 等等；

二、什么是 Spring MVC

2.1 概述

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

Spring MVC 的特点

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

Spring 的 web 框架，围绕 DispatcherServlet 调度 Servlet 设计；
DispatcherServlet 作用：
- 将请求分发到不同的处理器；
- 从 Spring 2.5 开始，Java 5 及以上版本，可采用注解形式开发，十分简洁；

小结：

Spring MVC 简单、便捷、易学，和 Spring 无缝集成（使用 Spring IOC 和 Aop）, 使用约定优于配置；
能够进行简单的 junit 测试，支持 Restful 风格、异常处理、本地化、国际化、数据验证、类型转换、拦截器等；

2.2 中心控制器

Spring 的 web 框架围绕 DispatcherServlet 设计；
DispatcherServlet 作用：将请求分发到不同的处理器；
从 Spring 2.5 开始，Java 5 及以上版本，可以采用基于注解的controller 声明方式；
Spring MVC 框架像许多其他 MVC 框架一样，以请求为驱动，围绕一个中心 Servlet，分派请求及提供其他功能，DispatcherServlet 是一个实际的 Servlet（它继承自 HttpServlet 基类）；

Spring MVC 原理

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

2.3 Spring MVC 执行原理

Spring MVC 的流程图：
- 实线表示 Spring MVC 框架提供的技术，不需要开发者实现；
- 虚线表示需要开发者实现；

简要分析执行流程

DispatcherServlet：前置控制器，是整个 Spring MVC 的控制中心，用户发出请求，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；
Handler：让具体的 Controller 执行；
Controller：将具体的执行信息，返回给 HandlerAdapter，如：ModelAndView；
HandlerAdapter：将视图逻辑名，或模型传递给 DispatcherServlet；
DispatcherServlet：调用视图解析器（ViewResolver），来解析 HandlerAdapter 传递的逻辑视图名；
视图解析器，将解析的逻辑视图名，传给 DispatcherServlet；
DispatcherServlet：根据视图解析器，解析的视图结果，调用具体的视图；
最终视图呈现给用户；

三、Spring MVC 实例

3.1 配置版

运行环境：
- JDK 17；
- Tomcat 9.0.60（Tomcat 10 与 Spring MVC 5不兼容）；

创建模块，并添加 web 的支持；
导入 Spring MVC 及相关依赖；

<!--单元测试-->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
</dependency>
<!--spring-webmvc-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.17</version>
</dependency>
<!--servlet-->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
</dependency>
<!--jsp-->
<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>javax.servlet.jsp-api</artifactId>
    <version>2.3.3</version>
</dependency>
<!--jstl-->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</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.注册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-->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--/ 只匹配所有的请求，不包含jsp页面；-->
    <!--/* 匹配所有的请求+jsp的页面；-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

创建 SpringMVC 的配置文件：springmvc-servlet.xml
- [servletname]-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>

添加处理映射器：

<!--添加处理映射器：根据请求查找对应的处理器（如：/hello请求，对应 bean id="/hello"）-->
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>

添加处理器适配器：

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

添加视图解析器：

<!--
    视图解析器：DispatcherServlet传递过来的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，装数据，封视图；

// 注意：导入Controller接口
public class HelloController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        // ModelAndView 模型和视图
        ModelAndView mv = new ModelAndView();

        // 封装对象，放在ModelAndView中, Model
        mv.addObject("msg", "HelloSpringMVC!");
        // 封装要跳转的视图，放在ModelAndView中
        // 通过springmvc-servlet.xml文件，自动拼接成 /WEB-INF/jsp/hello.jsp
        mv.setViewName("hello");
        return mv;
    }
}

把 Controller 类交给 Spring IOC 容器，注册 bean：

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

创建跳转的 jsp 页面：
- 显示 ModelandView 存放的数据，以及正常页面；

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

配置 Tomcat，启动测试：

可能遇到的问题：

访问出现 404：
排查步骤：
- 查看控制台输出，看一下是不是缺少了什么 jar 包；
- 如果 jar 包存在，显示无法输出，在 IDEA 的项目发布中，添加 lib 依赖：
- 重启 Tomcat，即可解决；

3.2 注解版

创建一个模块，并添加 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>

在 pom.xml 文件引入相关的依赖：参照上面配置版
- Spring 框架核心库、Spring MVC、servlet、JSTL等；
配置 web.xml：
- 注意点：
  - 注意 web.xml 版本问题，要最新版；
  - 注册 DispatcherServlet；
  - 关联 SpringMVC 的配置文件；
  - 启动级别为 1；
  - 映射路径为 /（不要用 /* ，会报 404）；

<?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拦截，不包含.jsp -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

创建 Spring MVC 配置文件：springmvc-servlet.xml
- 设置自动扫描包，让 IOC 的注解生效；
- 静态资源过滤：HTML、JS、CSS、图片、视频等；
- MVC 的注解驱动；
- 配置视图解析器；

<?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.study.controller"/>
    <!-- 让Spring MVC不处理静态资源 -->
    <mvc:default-servlet-handler/>
    <!--
        支持mvc注解驱动
        在spring中一般采用@RequestMapping注解来完成映射关系
        要想使@RequestMapping注解生效
        必须向上下文中注册DefaultAnnotationHandlerMapping
        和一个AnnotationMethodHandlerAdapter实例
        这两个实例分别在类级别和方法级别处理。
        而annotation-driven配置，会自动完成上述两个实例的注入。
    -->
    <mvc:annotation-driven/>

    <!--视图解析器：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>
</beans>

在视图解析器中，把所有的视图都存放在 /WEB-INF/ 目录下，这样可以保证视图安全，因为这个目录下的文件，客户端不能直接访问；
创建 Controller：
- @Controller：Spring IOC 容器初始化时，自动扫描到；
- @RequestMapping：映射请求路径，这里因为类与方法上都有映射，所以访问时应该是 /HelloController/hello ；
- 方法中声明 Model 类型的参数，是为了把 Action 中的数据带到视图中；
- 方法返回的结果，是视图的名称 hello，加上配置文件中的前后缀，变成 WEB-INF/jsp/hello.jsp ；

@Controller
@RequestMapping("/HelloController")
public class HelloController {
    // 真实访问地址：项目名/HelloController/hello
    @RequestMapping("/hello")
    public String hello(Model model) {
        // 向模型中添加属性msg与值，可以在JSP页面中取出并渲染
        model.addAttribute("msg", "Hello SpringMVC Annotation");
        // WEB-INF/jsp/hello.jsp
        return "hello";
    }
}

创建视图层：
- 在 WEB-INF/jsp 目录中，创建 hello.jsp；
- 视图可以直接取出，并展示从 Controller 带回的信息；
- 可以通过 EL 表达式，取出 Model 中存放的值，或者对象；

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

配置 Tomcat 运行：

小结：

注解实现步骤：
- 新建一个 web 项目；
- 导入相关 jar 包或依赖；
- 编写 web.xml ，注册 DispatcherServlet；
- 编写 springmvc 配置文件；
- 创建对应的控制类，controller；
- 完善前端视图和 controller 之间的对应：@RequestMapping；
- 测试运行调试；
使用 Spring MVC 必须配置的三大件：
- 处理器映射器；
- 处理器适配器；
- 视图解析器；
通常，只需要 手动配置视图解析器，而 处理器映射器 和 处理器适配器 只需要 开启注解驱动 即可，这样，省去了大段的 xml 配置；

四、Controller 及 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;
}

测试

新建模块，并做好相关配置；
springmvc 的配置文件，只需要配置视图解析器：

<!--视图解析器-->
<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 ControllerTest01 implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        // 返回一个模型视图对象
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg", "ControllerTest01");
        mv.setViewName("test");
        return mv;
    }
}

在 Spring 配置文件中，注册请求的 bean：
- name：对应请求路径；
- class：对应处理请求的类；

<bean name="/t1" class="com.study.controller.ControllerTest01"/>

编写前端页面，注意在 WEB-INF/jsp 目录下编写，对应视图解析器：

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

配置 Tomcat，运行测试：
- 注意请求路径，s4为项目名；

小结：

实现 Controller 接口，定义控制器，是较老的办法，不推荐使用；
缺点：
- 一个控制器中，只有一个方法，如果需要多个方法，则需要定义多个 Controller；
- 定义的方式比较麻烦；

4.3 使用注解 @Controller

@Controller 注解类型，用于声明 Spring 类的实例，是一个控制器；
- 注册组件的四个注解：功能相同
  - @Component：组件；
  - @Service：Service；
  - @Controller：Controller；
  - @Repository：dao；
Spring 可以使用扫描机制，找到应用程序中，所有基于注解的控制器类，需要在配置文件中，声明组件扫描：

<!--设置扫描包-->
<context:component-scan base-package="com.study.controller"/>

创建 Controller 控制类，通过注解方式实现：

// @Controller注解的类,会自动添加到Spring上下文中
// 该类中的所有方法，如果返回值是String，且有对应的页面跳，就会被视图解析器解析
@Controller
public class ControllerTest02 {
    // 映射访问路径
    @RequestMapping("/t2")
    public String test(Model model) {
        // Spring MVC会自动实例化一个Model对象,用于向视图中传值
        model.addAttribute("msg", "ControllerTest02");
        // 返回视图位置 WEB-INF/jsp/test.jsp
        return "test";
    }
}

运行测试：
两个请求都指向同一个视图，但是页面的结果不同，从这里可以看出，视图是被复用的，而控制器与视图之间，是 弱偶合关系；

4.4 RequestMapping

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

测试

只注解在方法上面：

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

运行测试：
- 访问路径：http://localhost:8080/项目名/t3；
同时注解类与方法：不推荐

@Controller
// 不推荐
@RequestMapping("/admin")
public class ControllerTest03 {
    @RequestMapping("/t3")
    public String test(Model model) {
        model.addAttribute("msg", "ControllerTest03");
        return "test";
    }
}

访问路径：http://localhost:8080/项目名/admin/t3；
- 需要先指定类的路径，再指定方法的路径；
推荐用法：

@Controller
public class ControllerTest03 {
    // 推荐：在方法上加完整路径
    @RequestMapping("/admin/t3")
    public String test(Model model) {
        model.addAttribute("msg", "ControllerTest03");
        // 视图位置 WEB-INF/jsp/admin/test.jsp
        return "admin/test";
    }
}

4.5 RestFul 风格

概念：Restful 就是一个资源定位，及资源操作的风格；
- 不是标准也不是协议，只是一种风格；
- 基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制；
功能：
- 资源：互联网所有的事物，都可以被抽象为资源；
- 使用不同的方法，对资源操作：
  - POST：添加；
  - DELETE：删除；
  - PUT：修改；
  - GET：查询；
传统方式操作资源：通过不同的参数，实现不同的效果，方法单一（post 和 get）；
- http://localhost/item/queryItem.action?id=1 查询，GET；
- http://localhost/item/saveItem.action 新增，POST；
- http://localhost/item/updateItem.action 更新，POST；
- http://localhost/item/deleteItem.action?id=1 删除， GET 或 POST；
使用 RESTful 操作资源：可以通过 不同的请求方式，实现不同的效果，请求地址一样，但功能可以不同；
- http://localhost/item/1 查询，GET；
- http://localhost/item 新增，POST；
- http://localhost/item 更新，PUT；
- http://localhost/item/1 删除，DELETE；

测试

创建测试类： RestFulController

@Controller
public class RestFulController {
}

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

@Controller
public class RestFulController {
    // 传统方式：@RequestMapping("/add")，访问：http://localhost:8080/项目名/add?a=1&b=2
    // RestFul：http://localhost:8080/项目名/a/b
    // 映射访问路径
    @RequestMapping("/add/{a}/{b}")
    public String test(@PathVariable int a, @PathVariable int b, Model model) {
        int result = a + b;
        // Spring MVC会自动实例化一个Model对象,用于向视图中传值
        model.addAttribute("msg", "结果：" + result);
        // 返回视图位置
        return "test";
    }
}

运行测试：

使用路径变量的好处：

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

@Controller
public class RestFulController {    
    @RequestMapping("/add/{a}/{b}")
    public String test(@PathVariable int a, @PathVariable String b, Model model) {
        String result = a + b;        
        model.addAttribute("msg", "结果：" + result);       
        return "test";
    }
}

再次测试：

使用 method 属性，指定请求类型：

用于约束请求的类型，可以收窄请求范围；
指定请求的类型，如：GET、POST、HEAD、OPTIONS、PUT、PATCH、DELETE、TRACE 等；
测试：增加一个方法

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

使用浏览器地址栏，进行访问，默认是 Get 请求，报错 405：
将 POST 修改为 GET：

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

运行测试：正常

POST 提交方式测试：

增加方法：

// 映射访问路径,必须是POST请求
// @RequestMapping(value = "/add/{a}/{b}", method = {RequestMethod.POST})
// @RequestMapping(path = "/add/{a}/{b}", method = {RequestMethod.POST})
// 简化方式
@PostMapping("/add/{a}/{b}")
public String test3(@PathVariable int a, @PathVariable String b, Model model) {
    String result = a + b;
    model.addAttribute("msg", "POST 结果：" + result);
    return "test";
}

创建 POST 提交页面：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<form action="${pageContext.request.contextPath }/add/1/a" method="post">
    <input type="submit">
</form>
</body>
</html>

访问测试：

小结：

Spring MVC 的 @RequestMapping 注解，能够处理 HTTP 请求的方法, 如：GET、PUT、POST、DELETE、PATCH；
所有的地址栏请求，默认都会是 HTTP GET 类型的；
方法级别的注解变体（推荐使用）：组合注解
- @GetMapping：GET；
- @PostMapping：POST；
- @PutMapping：PUT；
- @DeleteMapping：DELETE；
- @PatchMapping：PATCH；
@GetMapping：等同于 @RequestMapping(method = {RequestMethod.GET})；

4.6 小黄鸭调试法

场景一：我们都有过向别人（甚至可能向完全不会编程的人）提问及解释编程问题的经历，但是很多时候，就在我们解释的过程中，自己却想到了问题的解决方案，然后对方却一脸茫然；
场景二：你的同行跑来问你一个问题，但是当他自己把问题说完，或说到一半的时候，就想出答案走了，留下一脸茫然的你；
其实上面两种场景，就是所谓的小黄鸭调试法（Rubber Duck Debuging），又称橡皮鸭调试法，它是我们软件工程中，最常使用调试方法之一；
此概念，据说来自《程序员修炼之道》书中的一个故事，传说程序大师，随身携带一只小黄鸭，在调试代码的时候，会在桌上放上这只小黄鸭，然后详细地向鸭子解释每行代码，然后很快就将问题定位修复了；

五、SpringMVC 结果跳转方式

5.1 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 ControllerTest01 implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) 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 ModelServlet {
    @RequestMapping("/result/s1")
    public void test1(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        resp.getWriter().println("s1");
    }

    @RequestMapping("/result/s2")
    public String test2(HttpServletRequest req, HttpServletResponse resp) {
        System.out.println(req.getSession().getId());
        return "test";
    }

    @RequestMapping("/result/s3")
    public void test3(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        // 重定向
        resp.sendRedirect(req.getContextPath() + "/index.jsp");
    }

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

5.3 SpringMVC 实现转发和重定向

方式 1：不配置视图解析器

测试前，将视图解析器注释掉；
创建测试类：

@Controller
public class ModelSpringMVC {
    @RequestMapping("/result/m1")
    public String test1(Model model) {
        model.addAttribute("msg", "ModelSpringMVC1");
        // 转发方式1：未配置视图解析器，需要完整的路径名
        return "/WEB-INF/jsp/test.jsp";
    }

    @RequestMapping("/result/m2")
    public String test2(Model model) {
        model.addAttribute("msg", "ModelSpringMVC2");
        // 转发方式2：
        return "forward:/WEB-INF/jsp/test.jsp";
    }

    @RequestMapping("/result/m3")
    public String test3(Model model) {
        model.addAttribute("msg", "ModelSpringMVC3");
        // 重定向：
        return "redirect:/index.jsp";
    }
}

方式 2：配置视图解析器

配置好视图解析器；
创建测试类：

@Controller
public class ModelSpringMVC02 {
    @RequestMapping("/result/t1")
    public String test01() {
        // 配置视图解析器，转发
        return "test";
    }

    @RequestMapping("/result/t2")
    public String test02() {
        // 重定向：无需配置视图解析器
        return "redirect:/index.jsp";
        // 重定向到另一个请求
        // return "redirect:/result/t1";
    }
}

重定向，不需要视图解析器，本质就是重新请求一个新地址，需要注意路径问题；
可以重定向到另外一个请求；

六、数据处理

6.1 处理提交数据

提交的域名称，和处理方法的参数名一致

提交数据：http://localhost:8080/s4/user/t1?name=t1；
处理方法：

@GetMapping("user/t1")
public String test1(String name, Model model) {
    // 1.接收前端参数
    System.out.println("接收到的前端参数：" + name);
    // 2.将返回的结果，返回给前端
    model.addAttribute("msg", name);
    // 3.视图跳转
    return "test";
}

运行测试：

提交的域名称，和处理方法的参数名不一致

提交数据：http://localhost:8080/s4/user/t2?username=t2；
处理方法：

// @RequestParam("username")：username提交的域的名称
@GetMapping("/user/t2")
// 需要从前端接收的参数，建议都加上@RequestParam 注解
public String test2(@RequestParam("username") String name, Model model) {
    model.addAttribute("msg", name);
    return "test";
}

运行测试：
@RequestParam 注解，可以过滤无效的请求：
- 需要从前端接收的参数，建议都加上@RequestParam 注解；

提交的请求是一个对象

提交的表单域和对象的属性名一致时，可以使用对象做为参数；
创建实体类：

public class User {
    private int id;
    private String name;
    private int age;
    // 有参、无参构造
    // get、set
    // toString()
}

提交数据：http://localhost:8080/s4/user/t3?id=1&name=t3&age=20 ；
处理方法：

@GetMapping("/user/t3")
public String test3(User user, Model model) {
    model.addAttribute("msg", user);
    return "test";
}

运行测试：

小结：

接收前端用户传递的参数，如果与方法中的参数名一致，可直接使用；
如果使用对象做为参数，前端传递的参数名和对象属性名必须一致，否则为 null；

6.2 数据显示到前端

通过 ModelAndView：

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

通过 ModelMap：

@GetMapping("/user/t4")
public String test4(@RequestParam("username") String name, ModelMap modelMap) {
    // 封装要显示到视图中的数据
    // 相当于req.setAttribute("msg",name);
    modelMap.addAttribute("msg", name);
    return "test";
}

通过 Model：

@GetMapping("/user/t2")
// 需要从前端接收的参数，建议都加上@RequestParam 注解
public String test2(@RequestParam("username") String name, Model model) {
    model.addAttribute("msg", name);
    return "test";
}

6.3 对比

简单来说，使用区别就是：
- Model：只有几个方法，只适合用于储存数据，简化了新手对于 Model 对象的操作和理解；
- ModelMap：继承了 LinkedMap，除了实现了自身的一些方法，同样继承 LinkedMap 的方法和特性；
- ModelAndView：可以在储存数据的同时，设置返回的逻辑视图，进行控制展示层的跳转；
以后开发时，需要考虑更多的是，性能和优化；
80% 的时间，打好基础，18% 的时间研究框架，2% 的时间去学点英文，框架的官方文档永远是最好的教程；

6.4 乱码问题

测试

创建表单：post 方式提交

<form action="user/t5" method="post">
    <input type="text" name="name">
    <input type="submit">
</form>

创建对应的处理类：

@PostMapping("/user/t5")
public String test5(@RequestParam("name") String name, Model model) {
    // 1.接收前端参数
    System.out.println("接收到的前端参数：" + name);
    // 2.将返回的结果，返回给前端
    model.addAttribute("msg", name);
    // 3.视图跳转
    return "test";
}

运行，输入中文测试：乱码
查看控制台：乱码

解决方法：

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

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

有些极端情况下，这个过滤器对 get 的支持不好；
- 修改 Tomcat 配置文件 server.xml：设置编码

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

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

七、JSON

7.1 什么是 JSON？

JSON（JavaScript Object Notation，JS 对象标记）：
- 是一种轻量级的数据交换格式，目前使用特别广泛；
- 采用完全独立于编程语言的 文本格式，来存储和表示数据；
- 简洁和清晰的层次结构，使得 JSON 成为理想的数据交换语言；
- 易于阅读和编写，同时也易于机器解析和生成，并有效的提升网络传输效率；
在 JavaScript 语言中，一切都是对象：
- 任何 JavaScript 支持的类型，都可以通过 JSON 来表示，例如字符串、数字、对象、数组等；
- JSON 的要求和语法格式：
  - 对象表示为 键值对，数据由逗号分隔；
  - 花括号保存对象；
  - 方括号保存数组；
JSON 键值对 是保存 JavaScript 对象的一种方式，和 JavaScript 对象的写法也大同小异，键值对组合中的键名，写在前面，并用双引号 "" 包裹，使用冒号 : 分隔，然后紧接着是值：

{"name":"ZhangSan"}
{"age":"18"}
{"sex":"男"}

JSON 和 JavaScript 对象的关系

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

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

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

测试：

创建新模块，并添加 web 支持；
在 web 目录，创建测试页面：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>jsonTest</title>
    <!--注意：script不能单标签闭合-->
    <script type="text/javascript">
        // 编写一个js的对象
        let user = {
            id: "1",
            name: "张三",
            age: 20
        };
        console.log(user)

        // 将js对象转换成json字符串
        let str = JSON.stringify(user);
        console.log(str)

        // 将json字符串转换为js对象
        let obj = JSON.parse(str);
        console.log(obj.id, obj.name, obj.age);
    </script>
</head>
<body>

</body>
</html>

在 IDEA 中使用浏览器打开，查看控制台输出：

7.2 Controller 返回 JSON 数据

JSON 解析工具：
- Jackson；
- fastjson；

Jackson 测试

导入 Jackson 依赖：

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.13.2.2</version>
</dependency>

配置 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拦截，不包含.jsp -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!--2. 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-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"
       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:component-scan base-package="com.study.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>

创建实体类：User

// 需要导入lombok
@Data
// 有参构造
@AllArgsConstructor
// 无参构造
@NoArgsConstructor
public class User {
    private String name;
    private int age;
    private String sex;
}

创建 Controller 类：
- @ResponseBody：不去执行视图解析器，直接返回字符串，需要配合 @Controller 使用；
- ObjectMapper：Jackson 的对象映射器，用来解析数据；

@Controller
public class UserController {
    @RequestMapping("/j1")
    // @ResponseBody：不去执行视图解析器，直接返回字符串
    @ResponseBody
    public String json1() throws JsonProcessingException {
        // 创建一个jackson的对象映射器，用来解析数据
        ObjectMapper mapper = new ObjectMapper();
        // 创建一个对象
        User user = new User("张三", 20, "男");
        // 将User对象解析成为json格式
        String json = mapper.writeValueAsString(user);
        // 使用@ResponseBody注解后，将str转成JSON格式返回
        return json;
    }
}

配置 Tomcat，运行测试：

解决 JSON 乱码（了解）

通过 @RequestMaping 的 produces 属性，设置编码格式为 utf-8，以及返回类型：

// produces:指定响应体返回类型和编码
@RequestMapping(value = "/j1",produces = "application/json;charset=utf-8")

再次运行测试：

7.3 代码优化

JSON 乱码统一解决（推荐）：
- 在 springmvc 的配置文件中，统一配置，不需要单独处理；

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

返回 JSON 字符串统一解决：
- @RestController：在类上添加，所有的方法都只返回 JSON 字符串，不用在每个方法中添加 @ResponseBody；
- 前后端分离开发中，一般都使用 @RestController；

// @Controller：执行视图解析器
// @RestController：直接返回字符串
@RestController
public class UserController {
    @RequestMapping("/j1")    
    // @ResponseBody：需要配合@Controller一起使用
    public String json1() throws JsonProcessingException {
        // 创建一个jackson的对象映射器，用来解析数据
        ObjectMapper mapper = new ObjectMapper();
        // 创建一个对象
        User user = new User("张三", 20, "男");
        // 将User对象解析成为json格式
        String json = mapper.writeValueAsString(user);
        // 使用@ResponseBody注解后，将str转成JSON格式返回
        return json;
    }
}

7.4 测试集合输出

新增方法：

@RequestMapping("/j2")
public String json2() throws JsonProcessingException {
    ObjectMapper mapper = new ObjectMapper();
    User user1 = new User("test01", 20, "男");
    User user2 = new User("test02", 20, "男");
    User user3 = new User("test03", 20, "男");
    User user4 = new User("test04", 20, "男");

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

    String json = mapper.writeValueAsString(list);
    return json;
    // return new ObjectMapper().writeValueAsString(list);
}

运行测试：

7.5 输出时间对象

新增方法：

@RequestMapping("/j3")
public String json3() throws JsonProcessingException {
    // 创建时间一个对象，java.util.Date
    Date date = new Date();
    // 返回json格式
    return new ObjectMapper().writeValueAsString(date);
}

运行测试：

默认日期格式会变成一个数字，是1970年1月1日到当前日期的毫秒数；
Jackson 默认：把时间转成 timestamps 形式；

解决方案：

取消 timestamps 形式，自定义时间格式：

@RequestMapping("/j4")
public String json4() throws JsonProcessingException {
    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);
    // 创建时间一个对象，java.util.Date
    Date date = new Date();
    String json = mapper.writeValueAsString(date);
    // 返回json格式
    return json;
}

运行测试：

7.6 抽取为工具类

将代码封装到工具类中：

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 dateFormat) {
        // 创建一个jackson的对象映射器，用来解析数据
        ObjectMapper mapper = new ObjectMapper();
        // 不使用时间戳的方式
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        // 自定义日期格式对象
        SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
        // 指定日期格式
        mapper.setDateFormat(sdf);
        try {
            // 返回json字符串
            return mapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }
}

使用工具类测试：

@RequestMapping("/j5")
public String json5(){
    Date date = new Date();
    String json = JsonUtils.getJson(date);
    return json;
}

7.7 FastJson

Fastjson 是阿里开发的一款专门用于 Java 开发的包，可实现：
- JSON 对象与 JavaBean 对象的转换；
- JavaBean 对象与 JSON 字符串的转换；
- JSON 对象与 JSON 字符串的转换；
Fastjson 依赖：

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

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 字符串，之间的相互转化；

Fastjson 测试

新增方法：

// FastJson
@RequestMapping("/j6")
public String json6() {
    User user1 = new User("FastJson01", 20, "男");
    User user2 = new User("FastJson02", 20, "男");
    User user3 = new User("FastJson03", 20, "男");
    User user4 = new User("FastJson04", 20, "男");

    List<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("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);

    return "FastJson 测试";
}

这种工具类，只需要掌握使用就可以，使用时再根据具体的业务，去找对应的实现；

八、整合 SSM

8.1 运行环境

JDK 17；
IDEA 2021.2；
MySQL 8.0.28；
Tomcat 9.0.60；
Maven 3.8.4；
需要熟练掌握 MySQL 数据库、Spring、JavaWeb、MyBatis，以及简单的前端知识；

8.2 数据库环境

创建数据库及数据表：

CREATE DATABASE `ssmbuild`;
USE `ssmbuild`;
DROP TABLE IF EXISTS `books`;
CREATE TABLE `books` (
    `bookID` INT NOT NULL AUTO_INCREMENT COMMENT '书id',
    `bookName` VARCHAR(100) NOT NULL COMMENT '书名',
    `bookCounts` INT NOT NULL COMMENT '数量',
    `detail` VARCHAR(200) NOT NULL COMMENT '描述',
    KEY `bookID` (`bookID`)
) ENGINE=INNODB DEFAULT CHARSET=utf8mb4;

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

8.3 基本环境搭建

新建 Maven 项目：ssmbuild，添加 web 的支持；
导入相关依赖：

<dependencies>
    <!--Junit-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
    </dependency>
    <!--数据库驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.28</version>
    </dependency>
    <!--数据库连接池 c3p0-->
    <dependency>
        <groupId>com.mchange</groupId>
        <artifactId>c3p0</artifactId>
        <version>0.9.5.5</version>
    </dependency>
    <!--Servlet-JSP-->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>4.0.1</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>javax.servlet.jsp-api</artifactId>
        <version>2.3.3</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.9</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.7</version>
    </dependency>
    <!--Spring-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.18</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.3.18</version>
    </dependency>
    <!--Spring Java 注解：JDK11 以上需要-->
    <dependency>
        <groupId>javax.annotation</groupId>
        <artifactId>javax.annotation-api</artifactId>
        <version>1.3.2</version>
    </dependency>
    <!--AOP 织入-->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.8</version>
    </dependency>
</dependencies>

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>

建立项目基本结构和配置框架：
- pojo；
- dao；
- service；
- controller；
创建 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>

</configuration>

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

</beans>

8.4 Mybatis 层编写

创建数据库配置文件：database.properties

# mysql8 驱动
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/数据库名?useUnicode=true&characterEncoding=utf8&useSSL=true
jdbc.username=用户名
jdbc.password=密码

IDEA 连接数据库；
配置 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>
    <!--1. 标准日志-->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
    <!--2. 设置别名：扫描包的方式-->
    <typeAliases>
        <package name="com.study.pojo"/>
    </typeAliases>
    <!--3. 注册 Mapper.xml-->
    <mappers>
        <!--1. 接口类方式-->
        <mapper class="com.study.dao.BookMapper"/>
        <!--2. 资源文件方式-->
        <!--<mapper resource="com/study/dao/BookMapper.xml"/>-->
        <!--3. 扫描包方式-->
        <!--<package name="com.study.dao"/>-->
    </mappers>
</configuration>

创建数据库对应的实体类：Books
- 使用 lombok 插件，需要导入相关依赖；

@Data
// 有参构造
@AllArgsConstructor
// 无参构造
@NoArgsConstructor
public class Books {
    private String detail;
    private int bookCounts;
    private String bookName;
    private int bookID;
}

dao 层

创建 Dao 层的 Mapper 接口：BookMapper

public interface BookMapper {
    // 增加一个Book
    int addBook(Books books);

    // 根据id删除一个Book
    int deleteBookById(@Param("bookID") int id);

    // 更新Book
    int updateBook(Books books);

    // 根据id查询,返回一个Book
    Books queryBookById(@Param("bookID") int id);

    // 查询全部Book,返回list集合
    List<Books> queryAllBook();
}

创建接口对应的 Mapper.xml 文件：BookMapper.xml
- 需要导入 MyBatis 的包或依赖；

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--对应接口类：每一个mapper对应一个接口文件-->
<mapper namespace="com.study.dao.BookMapper">
    <!--1. 增加一个Book-->
    <insert id="addBook" parameterType="Books">
        insert into `books` (`bookName`, `bookCounts`, `detail`)
        values (#{bookName}, #{bookCounts}, #{detail});
    </insert>

    <!--2. 根据id删除一个Book-->
    <delete id="deleteBookById" parameterType="int">
        delete
        from `books`
        where `bookID` = #{bookID};
    </delete>

    <!--3. 更新Book-->
    <update id="updateBook" parameterType="Books">
        update `books`
        set `bookName`=#{bookName},
            `bookCounts`=#{bookCounts},
            `detail`=#{detail}
        where `bookID` = #{bookID};
    </update>

    <!--4. 根据id查询,返回一个Book-->
    <select id="queryBookById" resultType="Books">
        select *
        from `books`
        where `bookID` = #{bookID};
    </select>

    <!--5. 查询全部Book-->
    <select id="queryAllBook" resultType="Books">
        select *
        from `books`;
    </select>
</mapper>

service 层

创建 Service 层的接口：BookService

public interface BookService {
    // 增加一个Book
    int addBook(Books books);

    // 根据id删除一个Book
    int deleteBookById(int id);

    // 更新Book
    int updateBook(Books books);

    // 根据id查询,返回一个Book
    Books queryBookById(int id);

    // 查询全部Book,返回list集合
    List<Books> queryAllBook();
}

创建 Service 层的实现类：BookServiceImpl

public class BookServiceImpl implements BookService {
    // service层调用dao层：组合dao
    private BookMapper bookMapper;

    // 设置set接口，方便Spring管理
    public void setBookMapper(BookMapper bookMapper) {
        this.bookMapper = bookMapper;
    }

    @Override
    public int addBook(Books books) {
        // 调用dao层的方法
        return bookMapper.addBook(books);
    }

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

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

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

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

注意：在 mybatis-config.xml 中注册 Mapper.xml；
到此，底层需求操作编写完毕；

8.5 Spring 层

Spring 整合 MyBatis 层

配置 Spring 整合 MyBatis，数据源使用 c3p0；
创建 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">
    <!--配置整合mybatis-->
    <!--1. 关联数据库文件：通过spring读取-->
    <context:property-placeholder location="classpath:database.properties"/>

    <!--2. 数据库连接池
        dbcp：半自动化操作，不能自动连接
        c3p0：自动化操作（自动的加载配置文件，并且设置到对象里面）
        druid、hikari
    -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!-- 配置c3p0连接池属性 -->
        <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>

    <!--3. 配置SqlSessionFactory对象-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--数据源-->
        <property name="dataSource" ref="dataSource"/>
        <!--绑定Mybatis配置文件(spring整合Mybatis) 注意 value后面加classpath:-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    </bean>

    <!--4. 配置扫描Dao接口包，动态实现Dao接口注入到spring容器中（不需要创建dao接口的实现类）-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--注入sqlSessionFactory-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!--要扫描Dao接口包-->
        <property name="basePackage" value="com.study.dao"/>
    </bean>
</beans>

Spring 整合 service 层

创建 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:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd
       http://www.springframework.org/schema/aop
       https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--1. 扫描service下的包-->
    <context:component-scan base-package="com.study.service"/>

    <!--2. 将所有的service业务类，注入到spring：通过配置或注解实现-->
    <bean id="BookServiceImpl" class="com.study.service.BookServiceImpl">
        <property name="bookMapper" ref="bookMapper"/>
    </bean>

    <!--3. 配置声明式事务 JDBC 事务-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--注入数据库连接池-->
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--4. AOP 配置事务切入，需导入AOP织入包及导入头文件-->
    <!--结合AOP实现事务的织入-->
    <!--配置事务通知-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!--给哪些方法配置事务-->
        <!--配置事务的传播特性,propagation：传播-->
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>
    <!--配置事务切入-->
    <aop:config>
        <aop:pointcut id="txPointCut" expression="execution(* com.study.dao.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
    </aop:config>
</beans>

Spring 层编写完毕，再次理解下，Spring 就是一个容器，整合 dao 层和 service 层；

8.6 SpringMVC 层

把模块添加 web 框架支持：
配置 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. DispatcherServlet-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <!--注意：这里加载的是总的配置文件，总配置文件中，通过import引入其它配置文件-->
            <param-value>classpath:applicationContext.xml</param-value>
        </init-param>
        <!--启动级别-1-->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <!--所有请求都会被springmvc拦截，不包含.jsp -->
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!--2. 乱码过滤-->
    <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>

    <!--3. 设置Session过期时间-->
    <session-config>
        <session-timeout>15</session-timeout>
    </session-config>
</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: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
       https://www.springframework.org/schema/mvc/spring-mvc.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd">
    <!--配置SpringMVC-->
    <!-- 1. 开启SpringMVC注解驱动，注意导入mvc的头文件-->
    <mvc:annotation-driven/>
    <!--2. 静态资源过滤-->
    <mvc:default-servlet-handler/>
    <!--3. 扫描包：Controller-->
    <context:component-scan base-package="com.study.controller"/>
    <!--4. 视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

创建对应的 jsp 目录：
整合 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="spring-dao.xml"/>
    <import resource="spring-service.xml"/>
    <import resource="springmvc-servlet.xml"/>
    
</beans>

框架及配置文件设置完毕；

8.7 Controller 和视图层编写

创建 Controller 类：BookController
- 方法一：查询全部书籍；

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

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

修改首页：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: 4px;
        }
    </style>
</head>
<body>
<h3>
    <a href="${pageContext.request.contextPath}/book/allBook">进入书籍页面</a>
</h3>
</body>
</html>

在 jsp 目录下，创建书籍列表页面 allbook.jsp：

<%@ 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.bootcss.com/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>
    <div class="row">
        <div class="col-md-4 column">
            <a class="btn btn-primary"
               href="${pageContext.request.contextPath}/book/toAddBook">新增</a>
        </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>
                <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/toUpdateBook?id=${book.bookID}">更改</a>
                            |
                                <%--RestFul风格--%>
                            <a href="${pageContext.request.contextPath}/book/delBook/${book.bookID}">删除</a>
                        </td>
                    </tr>
                </c:forEach>
                </tbody>
            </table>
        </div>
    </div>
</div>
</body>
</html>

配置 Tomcat，进行测试：
- 注意：测试前，需要在 IDEA 的项目发布中，添加 lib 依赖，否则报错；
- 首页：
- 书籍列表页：

添加其它方法，配置对应的前端页面：

在 BookController 类中，添加其它方法：

@Controller
@RequestMapping("/book")
public class BookController {
    // controller调service层
    // 自动装配Bean
    @Autowired
    @Qualifier("BookServiceImpl")
    private BookService bookService;

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

    // 2. 跳转到添加书籍
    @RequestMapping("/toAddBook")
    public String toAddBook() {
        return "addBook";
    }

    // 3. 添加书籍
    @RequestMapping("/addBook")
    public String addBook(Books books) {
        bookService.addBook(books);
        // 重定向
        return "redirect:/book/allBook";
    }

    // 4. 跳转到修改书籍
    @RequestMapping("/toUpdateBook")
    public String toUpdateBook(int id, Model model) {
        Books books = bookService.queryBookById(id);
        // System.out.println(books);
        model.addAttribute("books", books);
        return "updateBook";
    }

    // 5. 修改书籍
    @RequestMapping("/updateBook")
    public String updateBook(Books books) {
        int i = bookService.updateBook(books);
        if (i > 0) {
            System.out.println("修改成功：" + books);
        }
        return "redirect:/book/allBook";
    }

    // 6. 删除书籍
    // 设置RestFul风格
    @RequestMapping("/delBook/{bookID}")
    public String delBook(@PathVariable("bookID") int id) {
        bookService.deleteBookById(id);
        return "redirect:/book/allBook";
    }
}

新增书籍页面：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>新增书籍</title>
    <!-- 引入 Bootstrap -->
    <link href="https://cdn.bootcss.com/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 for="name">书籍名称：</label>
            <input type="text" class="form-control" name="bookName" id="name" placeholder="书籍名称" required>
        </div>
        <div class="form-group">
            <label for="counts">书籍数量：</label>
            <input type="text" class="form-control" name="bookCounts" id="counts" placeholder="书籍数量" required>
        </div>
        <div class="form-group">
            <label for="detail">书籍详情：</label>
            <input type="text" class="form-control" name="detail" id="detail" placeholder="书籍详情" required>
        </div>
        <button type="submit" class="btn btn-primary">添加</button>
    </form>
</div>
</body>
</html>

修改书籍页面：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>修改书籍</title>
    <!-- 引入 Bootstrap -->
    <link href="https://cdn.bootcss.com/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/updateBook" method="post">
        <%--设置隐藏文本，存储bookID的值--%>
        <input type="hidden" name="bookID" value="${books.bookID}">
        <div class="form-group">
            <label for="name">书籍名称：</label>
            <input type="text" class="form-control" name="bookName" id="name" value="${books.bookName}" required>
        </div>
        <div class="form-group">
            <label for="counts">书籍数量：</label>
            <input type="text" class="form-control" name="bookCounts" id="counts" value="${books.bookCounts}" required>
        </div>
        <div class="form-group">
            <label for="detail">书籍详情：</label>
            <input type="text" class="form-control" name="detail" id="detail" value="${books.detail}" required>
        </div>
        <button type="submit" class="btn btn-primary">修改</button>
    </form>
</div>
</body>
</html>

项目结构图

8.8 增加查询书籍功能

在前端页面 allBook.jsp 增加输入框和查询按钮：

<%@ 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.bootcss.com/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>
    <div class="row">
        <div class="col-md-4 column">
            <a class="btn btn-primary"
               href="${pageContext.request.contextPath}/book/toAddBook">新增</a>
        </div>
        <%--添加书籍查询功能--%>
        <div class="col-md-8 column">
            <form class="form-inline" action="${pageContext.request.contextPath}/book/queryBook" method="post"
                  style="float: right">
                <input type="text" name="queryBookName" class="form-control" placeholder="输入查询书名" required>
                <input type="submit" value="查询" class="btn btn-primary">
            </form>
        </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>
                <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/toUpdateBook?id=${book.bookID}">更改</a>
                            |
                                <%--RestFul风格--%>
                            <a href="${pageContext.request.contextPath}/book/delBook/${book.bookID}">删除</a>
                        </td>
                    </tr>
                </c:forEach>
                </tbody>
            </table>
        </div>
    </div>
</div>
</body>
</html>

完整页面：
在 BookController 中，增加查询书籍的方法：

// 7. 按书籍名称查询
@RequestMapping("/queryBook")
public String queryBook(String queryBookName, Model model) {
    System.out.println("要查询的书籍：" + queryBookName);
    // 业务代码
    return "allBook";
}

由于底层没有实现，所以需要将底层代码完善；
修改 Mapper 接口文件，添加查询接口：

// 根据书名查询,返回一个Book
Books queryBookByName(String bookName);

配置 Mapper.xml，添加对应的查询 sql：

<!--6. 根据书名查询,返回一个Book-->
<select id="queryBookByName" resultType="Books">
    select *
    from `books`
    where `bookName` = #{bookName};
</select>

修改 Service 业务层接口，添加查询接口：

// 根据书名查询,返回一个Book
Books queryBookByName(String bookName);

在 Service 业务层实现类中，实现接口对应的方法：

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

完善 Controller：

// 7. 按书籍名称查询
@RequestMapping("/queryBook")
public String queryBook(String queryBookName, Model model) {
    System.out.println("要查询的书籍：" + queryBookName);
    Books books = bookService.queryBookByName(queryBookName);
    List<Books> list = new ArrayList<>();
    list.add(books);
    model.addAttribute("list", list);
    return "allBook";
}

测试查询功能：

简单优化：

在前端添加显示全部书籍的按钮：
后端增加查询结果的判断：

// 7. 按书籍名称查询
    @RequestMapping("/queryBook")
    public String queryBook(String queryBookName, Model model) {
        System.out.println("要查询的书籍：" + queryBookName);
        //如果查询的数据存在空格，则优化
        Books books = bookService.queryBookByName(queryBookName.trim());
        List<Books> list = new ArrayList<>();
        list.add(books);
        // 如果没有查出来书籍，则返回全部书籍列表
        if (books == null) {
            list = bookService.queryAllBook();
            // 将错误信息返回前端
            model.addAttribute("error", "未查到结果");
        }
        model.addAttribute("list", list);
        return "allBook";
    }

将错误信息展示在前台页面：
前端页面 allBook.jsp 完整代码：

<%@ 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.bootcss.com/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>
    <div class="row">
        <div class="col-md-4 column">
            <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-8 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="输入查询书名" required>
                <input type="submit" value="查询" class="btn btn-primary">
            </form>
        </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>
                <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/toUpdateBook?id=${book.bookID}">更改</a>
                            |
                                <%--RestFul风格--%>
                            <a href="${pageContext.request.contextPath}/book/delBook/${book.bookID}">删除</a>
                        </td>
                    </tr>
                </c:forEach>
                </tbody>
            </table>
        </div>
    </div>
</div>
</body>
</html>

运行测试：

SpringMVC 基础

一、回顾 MVC

1.1 什么是 MVC

1.2 Model 1 时代

1.3 Model 2 时代

1.4 回顾 Servlet

二、什么是 Spring MVC

2.1 概述

2.2 中心控制器

2.3 Spring MVC 执行原理

三、Spring MVC 实例

3.1 配置版

3.2 注解版

四、Controller 及 RestFul

4.1 控制器 Controller

4.2 实现 Controller 接口

4.3 使用注解 @Controller

4.4 RequestMapping

4.5 RestFul 风格

4.6 小黄鸭调试法

五、SpringMVC 结果跳转方式

5.1 ModelAndView（不推荐）

5.2 ServletAPI（原生方式）

5.3 SpringMVC 实现转发和重定向

六、数据处理

6.1 处理提交数据

6.2 数据显示到前端

6.3 对比

6.4 乱码问题

七、JSON

7.1 什么是 JSON？

7.2 Controller 返回 JSON 数据

7.3 代码优化

7.4 测试集合输出

7.5 输出时间对象

7.6 抽取为工具类

7.7 FastJson

八、整合 SSM

8.1 运行环境

8.2 数据库环境

8.3 基本环境搭建

8.4 Mybatis 层编写

8.5 Spring 层

8.6 SpringMVC 层

8.7 Controller 和视图层编写

8.8 增加查询书籍功能

猜你喜欢

热点阅读