springMVC笔记

2023-09-27 19:57:46

1、回顾什么是MVC

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

Model（模型）：

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

职责：

1、业务逻辑
2、保存数据的状态

View（视图）：

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

职责：

1、显示页面

Controller（控制器）：

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

职责：

1、取得表单数据
2、调用业务逻辑
3、转向指定的页面

最典型的MVC就是：jsp+servlet+javaBean的模式。

MVC框架要做哪些事？

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

-说明：
常见的服务器端MVC框架有：
Struts、SpringMVC、Aspect.net MVC、ZendFramework、JSF；

常见前端MVC框架：
vue、angularjs、react、backbone。

由MVC演化出了另外一些模式如：MVP、MVVM等。

2、初始SpringMVC

a、为什么要学习SpringMVC呢？

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

Spring的web框架围绕DispatcherServlet[调度servlet]设计。DispatcherServlet的作用是将请求分发到不同的处理器。从Spring2.5开始，使用Java5或者以上版本的用户可采用基于注解形式进行开发，十分简洁；正因为SpringMVC好。简单、便携，易学，天生和Spring无缝集成（使用SpringIOC和AOP），使用约定大于配置，能够进行简单的junit测试，支持Restful风格，异常处理，本地化，国际化，数据验证，类型转换，拦截器等等

3、第一个SpringMvc程序：

a、在pom.xml中配置相应的依赖：

<?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.liu</groupId>
    <artifactId>SPringMVC</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>springMvc-one</module>
    </modules>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>


    <dependencies>
        <!--单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        <!--springMvc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.13</version>
        </dependency>
        <!--servlet-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>
        <!--jsp-->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2.1-b03</version>
        </dependency>
        <!--jstl-->
        <dependency>
            <groupId>javax.servlet.jsp.jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
    </dependencies>
    
    <!--解决资源加载失败-->
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>
</project>

b、在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：这个是SpringMVC的核心；请求分发器，前端控制器-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--关联一个springmvc的配置文件：【servlet-name】-servlet.xml
			也就是加载spring配置文件
		-->
        <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>
    
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    
    <!--
	注意：在springMVC中：‘/’ 和‘/*’的区别：
	‘/’：表示只匹配所有的请求，不会去匹配jsp页面。
	‘/*’：表示 匹配所有的请求，包括jsp页面。

	-->
    
</web-app>

c、在controller包中建一个HelloController

//注意：这里我们先导入Controller接口
public class HelloController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        //ModelAndView 模型和视图
        ModelAndView mv=new ModelAndView();
        //业务代码
        String res="HelloSpringMVC!";
        //封装对象，放在ModelAndView中
        mv.addObject("msg",res);
        //封装要跳转的视图，放在ModelANdView中
        //视图跳转
        mv.setViewName("hello");//指向 ：/WEB-INF/jsp/hello.jsp
        return mv;
    }
}

d、在resources包下建一个springmvc-servlet.xml文件

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

    <!--处理器映射器-->
    <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 id="InternalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>


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

e、在WEB-INF下建一个jsp包，在其中建一个hello.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>hello</title>
</head>
<body>
<h1>我是 hello jsp</h1>
渠道的信息：${msg}
</body>
</html>

f、测试

g、注意的问题，若提示找不到（报404）：

- 99%是相关依赖没有在lib中，解决在项目中找到lib（或新建）将相关依赖添加进去，就OK了。

h、说明

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

4、SpringMvc执行流程

1、上图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-saj3e4f5-1640609084627)(C:\Users\24344\AppData\Roaming\Typora\typora-user-images\image-20211216154306449.png)]

2、简要分析执行流程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BraLkdNC-1640609084628)(C:\Users\24344\AppData\Roaming\Typora\typora-user-images\image-20211216154400900.png)]

5、使用注解写第一个springMvc

a、web.xml配置

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <servlet>
        <servlet-name>springmvc1</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-coller.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc1</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

b、springmvc-coller.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
        https://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.liu.controller"/>
    <!--让springMVC不处理静态资源，ru：css、js、html、mp3-->
    <mvc:default-servlet-handler/>

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

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

c、在controller包下建一个NanController.java

package com.liu.controller;

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

@Controller//代表这个类会被Spring接管
//被这个注解的类中的所有方法，若返回值是String，且有具体页面可跳转，那么就会被视图解析器解析；
public class NanController {

    //真是访问地址：
    @RequestMapping("/liu")
    public String toLiu(Model model){
        //向模型中添加属性msg与值，可以在jsp页面中取出并渲染
        model.addAttribute("msg","楠小弟来了");
        //WEB-INF/jsp/liu.jsp
        return "liu";
    }
}

d、在WEB-INF下建个jsp包，在其中间隔liu.jsp

<%--
  Created by IntelliJ IDEA.
  User: 24344
  Date: 2021/12/16
  Time: 20:42
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>jkd</title>
</head>
<body>
<h1>显示内容：${msg}</h1>
</body>
</html>

e、测试

服务启动后访问：http://localhost:8080/springMvc_two_again_war_exploded/liu

6、RestFul风格：

a、概念：

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

b、功能：

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

c、传统方式操作资源：

通过不同的参数来实现不同的效果！方法单一，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】

d、使用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方式】

e、小测试

使用上面的例子，只需改变LiuController.java

@Controller
public class LiuController {
    @RequestMapping(value = "/hah/{a}/{b}",method = RequestMethod.GET )
//    @GetMapping("/ha/{a}/{b}")
    public String returnString(@PathVariable int a,@PathVariable int b, Model m){
        //@PathVariable：指明变量地址，此注解必须写上
        m.addAttribute("msg","即可随地可见.结果："+(a+b));
        return "nan";
    }
}

注意：声明请求方式有两种：
- @RequestMapping(value = “/hah/{a}/{b}”,method = RequestMethod.GET )
- @GetMapping("/ha/{a}/{b}")
@PathVariable 传参时必须指明。

f、运行结果：

在地址栏中：http://localhost:8080/springMvc_three_again_war_exploded/hah/1/8
会跳转页面并显示信息：输出相互内容：即可随地可见.结果：9

7、重定向和转发

a、SpringMvc：结果跳转方式

设置ModelAndView对象，根据view的名称，和视图解析器跳到指定的页面。
页面：{视图解析器前缀} + viewName + {视图解析器后缀}

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

对应的controller类：

//注意：这里我们先导入Controller接口
public class HelloController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        //ModelAndView 模型和视图
        ModelAndView mv=new ModelAndView();
        //业务代码
        String res="HelloSpringMVC!";
        //封装对象，放在ModelAndView中
        mv.addObject("msg",res);
        //封装要跳转的视图，放在ModelANdView中
        //视图跳转
        mv.setViewName("hello");//指向 ：/WEB-INF/jsp/hello.jsp
        return mv;
    }
}

b、通过SpringMvc实现转发和重定向-【无需视图解析器】：

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

写个测试类：

@Controller
public class TestController {
    @RequestMapping("/liu/t1")
    public String test1(){
        //转发
        return "/buH.jsp";
    }

    @RequestMapping("/liu/t2")
    public String test2(){
        //转发二
        return "forward:/buH.jsp";
    }

    @RequestMapping("/liu/t3")
    public String test3(){
        //重定向
        return "redirect:/buH.jsp";
    }
}

结果：

里面的 方法一：http://localhost:8080/springMvc_three_again_war_exploded/liu/t1
	直接跳转相应的页面，但地址栏不变化
里面的 方法二：http://localhost:8080/springMvc_three_again_war_exploded/liu/t2
	直接跳转相应的页面，但地址栏不变化。
里面的 方法三：http://localhost:8080/springMvc_three_again_war_exploded/liu/t3
	回车后，跳到相应的页面，但【地址栏发生变化】

c、springMvc实现转发和重定向-【有视图解析器】：

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

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

打开视图解析器
写测试类：

@Controller
public class Test2Controller {

    @RequestMapping("/tes/t1")
    public String test1(){
        //转发
        return "nan";
    }

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

结果:

里面的方发一：会和视图解析器 进行拼接，然后跳到目标页面，且地址栏不改变
里面的方法二：直接重定向到指定页面。

注意：

上面的例子提到的 “hello.do”，也是自定义的，和“/tes/t2”一样。

8、springMvc：数据处理

a、处理提交数据

提交的域名称和处理方法的参数名一致
- 提交数据：http://localhost:8080/hello?name=liu
- 处理方法：
```
@RequestMapping("/hello")
public Strng hello(String name){
	System.out.println(name);
	return "hello";
}
```
- 后台输出：liu

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

提交数据：http://localhost:8080/hello?username=liu

处理方法：

@RequestMapping("/hello")
public Strng hello(@RequestParam("username") String name){
	//@RequestParam("username")提交的域的名称
	System.out.println(name);
	return "hello";
}

后台输出：liu

提交的是一个对象：
- 要求提交的表单域和对象的属性名一致，参数使用对象即可
- 1、实体类：
```
public class User{
    private int id;
    private String name;
    private int age;
    //构造、setter、getter方法、tostring
}
```
- 2、提交数据：http://localhost:8080/mvc04/user?name=liu&id=1&age=10
- 3、处理方法：
```
@RequestMapping("/user")
public Strng user(User user){
	System.out.println(user);
	return "hello";
}
```
- 4、后台输出：User{id=1，name=liu，age=10}
- 说明：若使用对象，前端传递的参数名和对象名必须一致，否则就是null。

b、数据回显到前端：

第一种：通过ModelAndView

//注意：这里我们先导入Controller接口
public class HelloController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        //ModelAndView 模型和视图
        ModelAndView mv=new ModelAndView();
        //业务代码
        String res="HelloSpringMVC!";
        //封装对象，放在ModelAndView中
        mv.addObject("msg",res);
        //封装要跳转的视图，放在ModelANdView中
        //视图跳转
        mv.setViewName("hello");//指向 ：/WEB-INF/jsp/hello.jsp
        return mv;
    }
}

第二种：通过ModelMap：

@RequestMapping("/hello")
public String hello(@RequestParam("username") String name,ModelMap model){
    //封装要显示到视图中的数据
    //相当于req.setAttribute（“name”，name）；
    model.addAttribute("name",name);
    System.out.ptingln(name);
    return "hello";
}

第三种：通过Model：

@RequestMapping("/liu/hello")
public String hello(@RequestParam("username") String name,Model model){
    //封装要显示到视图中的数据
    //相当于req.setAttribute（“name”，name）；
    model.addAttribute("name",name);
    System.out.ptingln(name);
    return "hello";
}

三种的对比：

Model:只有寥寥几个方法，只适用于储存数据，简化了新手对于Model对象的操作和理解；

ModelMap：继承了 LinkedMap ，除了实现了自身一些方法同样继承了 LinkedMap 的方法和特性；
    
ModelAndView：可在储存数据的同时，可进行设置返回的逻辑视图，进行控制展示层的跳转。

以后开发考虑的更多的是性能和优化，就不能单单仅限于此的了解。

请使用80%的时间打好扎实的基础，剩下18%的时间研究框架，2%的时间去学英文，框架的官方文档才是最好的教程。

9、乱码问题：

a、编写一个表单：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>tijiao</title>
</head>
<body>
<form action="${pageContext.request.contextPath}/f/t1" method="post">
    <input name="inp">
    <input type="submit" value="提交">
</form>
</body>
</html>

b、后代对应的类：

@Controller
public class FormController {
    @RequestMapping("/f/t1")
    public String formTest1(String inp, Model m){
        System.out.println(inp);
        m.addAttribute("msg",inp);
        return "nan";
    }
}

c、输入中文测试，发现乱码

在：http://localhost:8080/springMvc_three_again_war_exploded/formLiu.jsp
页面下的输入框：输入中文：“楠小弟”点击提交跳到：
    http://localhost:8080/springMvc_three_again_war_exploded/f/t1
显示输入的内容为乱码：æ¥ å°å¼Ÿ

d、解决乱码：在web.xml配置官方写的：

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

e、再次输入测试：

操作和上步一样，结果显示正常。

10、SpringMVC：JSON讲解

1、什么是JSON？

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

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

要求和语法格式：

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

{"name","nan"}
{"age","3"}
{"sex","男"}

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

2、JSON和JavaScript对象互转：

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

var obj=JSON.parse('{"a":"hello","b":"nan"}');
结果是：{a:'hello',b:'nan'}

2、JavaScript对象转换为JSON字符串，使用 JSON.stringify()方法

var json=JSON.stringify({a:'hello',b:'nan'});
结果是：'{"a":"hello","b":""}'

3、[Jackson解析工具]Controller返回JSON数据

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

1、这里使用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.13.0</version>
</dependency>

2、配置springMvc需要的配置：web.xml、springmvc-servlet.xml和上面的一样。

3、编写实体类User：

public class User {
    private String name;
    private int age;
    private String sex;
}

4、创建UserController.java类：

@Controller
public class UserController {
    @RequestMapping(value = "/json01")
    @ResponseBody//不会走视图解析器，会返回一个字符串
    public String json01() throws JsonProcessingException {
        //创建json对象
        ObjectMapper mapper=new ObjectMapper();
        User user=new User("楠小弟",10,"男");
        //把对象变为json格式
        String s = mapper.writeValueAsString(user);
        return s;
    }
}

注意：

 @ResponseBody:不会走视图解析器，会返回一个字符串,配合@Controller使用
还有一个
@RestController：不走视图解析器，且是安放在类上面（@Controller的位置那里），
表示整个类中的方法都不会走视图。

5、运行发现“中文乱码了”，此处使用官方提供的json乱码同一解决：在springmvc配置文件中添加：

 <!--加载驱动-->
    <mvc:annotation-driven>
        <!--解决JSON乱码问题配置-->
        <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>

6、再次测试，正常显示。

3.1、使用json返回时间：

1、环境配置和上步一样

2、新建一个JsonDateController.java

第一种：返回时间戳（Java方式）

@RestController//不走视图，返回字符串
public class JsonDateController {
    @RequestMapping("/date01")
    public String jsonDate01() throws JsonProcessingException {
        //使用json提供的对象
        ObjectMapper mapper=new ObjectMapper();
        Date date=new Date();
        //会返回 时间戳
        return mapper.writeValueAsString(date);
    }
}

第二种：自定义时间格式（Java方式）

@RestController//不走视图，返回字符串
public class JsonDateController {
    @RequestMapping("/date01")
    public String jsonDate01() throws JsonProcessingException {
        //使用json提供的对象
        ObjectMapper mapper=new ObjectMapper();
        //自定义时间格式
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //会返回 自定义的时间格式
        return mapper.writeValueAsString(sdf.format(new Date()));
    }
}

第三种：自定义时间格式（json提供的方式）

@RestController//不走视图，返回字符串
public class JsonDateController {
    @RequestMapping("/date01")
    public String jsonDate01() throws JsonProcessingException {
        //使用json提供的对象
        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);
        //会返回 自定义的时间格式
        return mapper.writeValueAsString(new Date());
    }
}

注意：这三种都可提出公共类，在utils建个JsonUtils.java

public class JsonUtils {
    public static String getJson(Object object){
        return getJson(object,"yyyy-MM-dd HH:mm:ss");
    }
    /**
     * 此方法提取出公共部分
     * @param object
     * @param dateFormat
     * @return
     */
    public static String getJson(Object object,String dateFormat){
        //使用json提供的对象
        ObjectMapper mapper=new ObjectMapper();
        //不使用时间戳的格式
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
        //自定义时间格式
        SimpleDateFormat sdf=new SimpleDateFormat(dateFormat);
        //指定日期格式
        mapper.setDateFormat(sdf);
        //会返回 自定义的时间格式
        try {
            return mapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }
}

有了此公共类可直接调用(输出时间时)：

@RestController
public class JsonDateController {
    @RequestMapping("/date01")
    public String jsonDate01() throws JsonProcessingException {
        //获取当前时间
        return JsonUtils.getJson(new Date());
    }
}

输出对象时：

 @RequestMapping(value = "/json02")
    @ResponseBody//不会走视图解析器，会返回一个字符串
    public String json02() throws JsonProcessingException {
        User user=new User("楠小弟",10,"男");
        return JsonUtils.getJson(user);
    }

4、[fastJson解析工具]

1、介绍：

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

2、fastjson的pom依赖：

<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.78</version>
</dependency>

3、fastjson的三个主要的类：

1、JSONObject 代表 json 对象：
- JSONObject实现了Map接口，猜想JSONObject底层操作是由Map实现的。
- JSONObject对应的json对象，通过各种形式的get（）方法可以获取json对象中的数据，也可以利用诸如size()。isEmpty()等方法获取“键：值”对的个数和判断是否为空。其本质是通过实现Map接口并调用接口中的方法完成的。
2、JSONArray 代表json对象数组
- 内部是有List接口中的方法来完成操作的。
3、JSON 代表JSONObject和JSONArray的转化：
- JSON类源码分析与使用。
- 仔细观察这些方法，主要是实现json对象，json对象数组，javabean对象，json字符串之间的相互转化。
实例：

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

System.out.println("*******JSON字符串 转 Java对象 ");
User Juser1=JSON.parseObject(str2,User.class);

System.out.println("*******Java对象 转 JSON对象");
JSONObject jsonObject=(JSONObject)JSON.toJSON(user2);


System.out.println("******* JSON字符串 转  Java对象");
User user5=JSON.toJavaObject(jsonObject1,User.class);

11、SSM整合-【整合Mybatis】

a、数据库环境：

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

CREATE DATABASE `ssmbuild`;

USE `ssmbuild`;

DROP TABLE IF EXISTS `book`;

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,'从发现到留恋');

b、基本环境搭建pom.xml：

 <!--导入依赖-->
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        <!--数据库驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

        <!--数据库连接池-->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.5</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.1-b03</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp.jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>

        <!--mybatis-spring-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.6</version>
        </dependency>

        <!--spring-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.13</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.13</version>
        </dependency>
    </dependencies>

c、maven资源过滤：

<!--解决资源加载失败-->
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>

d、建立基本结构和配置框架！

com.liu.dao
com.liu.pojo
com.liu.service

com.liu.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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    
</beans>

e、Mybatis层编写

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

jdbc.driver=com.mysql.jdbc.Driver
#如果使用的是MySql8.0+，增加一个时区的配置；&serverTimezone=Asia/Shanghai
jdbc.url=jdbc:mysql://localhost:3306/ssmbuild?useSSL=true&useUnicode=true&characterEncoding=utf-8
jdbc.username=root
jdbc.password=123456

2、IDEA关联数据库

3、编写MyBatis的核心配置

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

        <!-- 配置别名-->
    <typeAliases>
        <package name="com.liu.pojo"/>
    </typeAliases>

    <mappers>
        <mapper resource="com/liu/dao/BookMapper.xml"/>
    </mappers>
</configuration>

11、SSM整合-【spring层】：

a、配置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
        https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!--1、关联数据库配置文件-->
    <context:property-placeholder location="classpath:dataBase.properties"/>

    <!--2、连接池
        dbcp:半自动化操作，不能自动连接（spring自带的是这个）
        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>

    <!--3、sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--绑定mybatis配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    </bean>


    <!--4、配置dao接口扫描包，动态的实现了Dao接口可以注入到Spring容器中-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--注入sqlSessionFactory-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!--要扫描的dao包-->
        <property name="basePackage" value="com.liu.dao"/>
    </bean>

</beans>

b、配置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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!--扫描service包-->
    <context:component-scan base-package="com.liu.service"/>

    <!--2、将我们的所有业务类，注入到Spring，可以通过配置，或者注解实现。此处使用配置-->
    <bean id="bookServiceImpl" class="com.liu.service.BookServiceImpl">
        <property name="bookMapper" ref="bookMapper"/>
    </bean>

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

    <!--4、aop事务支持-->
</beans>

12、SSM整合-【springMvc】

a、添加web的支持

把项目变成web工程

b、配置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">
    
    <!--配置springmvc-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
             <!--此处引用的应该是整合过的总的spring配置文件-->
            <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>
    <!--session设置-->
    <session-config>
        <!--15分钟后session失效-->
        <session-timeout>15</session-timeout>
    </session-config>
</web-app>

c、配置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
        https://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">

    <!--1、注解驱动(此处设置json乱码的地方)-->
    <mvc:annotation-driven/>
    <!--2、静态资源过滤-->
    <mvc:default-servlet-handler/>
    <!--3、扫描包-->
    <context:component-scan base-package="com.liu.controller"/>
    <!--4、视图解析器-->
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

d、在WEB-INF下建个jsp包

13、SSM整合-【查询、增删改查功能】：

a、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.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">
                <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" style="float: right;text-align: center" action="${pageContext.request.contextPath}/book/queryBookByName" method="post">
                    <span style="color: red">${queryError}</span>
                    <input type="text" name="queryBookName" class="form-control"  placeholder="请输入要查询的书籍名称">
                    <input type="submit" class="btn btn-primary" value="查询">
                </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>
                <%--数据从数据库得到（跳到此页面的controller类中）--%>
                <tbody>
                <c:forEach var="book" items="${allBook}">
                    <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>

b、addBook.jsp添加书籍

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>增加图书</title>
    <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 for="bkname">书籍名称:</label>
            <input type="text" name="bookName" class="form-control" required id="bkname" placeholder="名字">
        </div>
        <div class="form-group">
            <label for="bknums">书籍数量:</label>
            <input type="text"  name="bookCounts" class="form-control" required id="bknums" placeholder="数量">
        </div>
        <div class="form-group">
            <label for="bkdes">书籍描述:</label>
            <input type="text" name="detail" class="form-control" id="bkdes" required placeholder="描述">
        </div>
        <div class="form-group">
            <input type="submit" class="form-control btn-primary" value="提交">
        </div>

    </form>

</div>
</body>
</html>

c、update Book.jsp修改页面

<%--
  Created by IntelliJ IDEA.
  User: 24344
  Date: 2021/12/19
  Time: 21:10
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>修改页面</title>
    <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/updateBook" method="post">
        <!--书的编号隐藏-->
        <input type="hidden" name="bookID" value="${QBook.bookID}">
        <div class="form-group">
            <label for="bkname">书籍名称:</label>
            <input type="text" name="bookName" value="${QBook.bookName}" class="form-control" required id="bkname" placeholder="名字">
        </div>
        <div class="form-group">
            <label for="bknums">书籍数量:</label>
            <input type="text"  name="bookCounts" value="${QBook.bookCounts}" class="form-control" required id="bknums" placeholder="数量">
        </div>
        <div class="form-group">
            <label for="bkdes">书籍描述:</label>
            <input type="text" name="detail" value="${QBook.detail}" class="form-control" id="bkdes" required placeholder="描述">
        </div>
        <div class="form-group">
            <input type="submit" class="form-control btn-primary" value="修改">
        </div>

    </form>

</div>

</body>
</html>

d、BookController.java类

package com.liu.controller;

import com.liu.pojo.Books;
import com.liu.service.BookService;
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.PathVariable;
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;

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

    //添加书籍的请求
    @RequestMapping("/addBook")
    public String addBook(Books books){
        System.out.println("addBook=>"+books);
        bookService.addBook(books);
        return "redirect:/book/allBook";
    }

    //跳转到修改页面
    @RequestMapping("/toUpdate")
    public String toUpdatePaper(int id,Model model){
        Books books = bookService.queryById(id);
        model.addAttribute("QBook",books);
        return "updateBook";
    }
    //修改书籍
    @RequestMapping("/updateBook")
    public String updateBook(Books books){
        int i = bookService.updateBook(books);
        return "redirect:/book/allBook";
    }

    @RequestMapping("/deleteBook/{bookId}")
    public String deleteBook(@PathVariable("bookId") int id){
        bookService.deleteBookById(id);
        return "redirect:/book/allBook";
    }

    //模糊查询
    @RequestMapping("/queryBookByName")
    public String queryBookByName(String queryBookName,Model model){
        List<Books> books = bookService.queryBookByName(queryBookName);

        if(books.size()==0){
            //当没搜到时
            model.addAttribute("queryError","未查到要搜索的书籍");
        }
        model.addAttribute("allBook",books);
        return "/allBook";
    }
}

e、dao包下的BookMapper.java接口

package com.liu.dao;

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

import java.util.List;

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

    //删除一本书
    int deleteBookById(@Param("bookId") int id);

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

    //查询一本书
    Books queryById(@Param("bookId") int id);

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

    //通过书名模糊查询书籍
    List<Books>queryBookByName(@Param("bookName") String bookName);
}

f、dao包下的BookMapper.xml文件

<?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.liu.dao.BookMapper">
    <insert id="addBook" parameterType="books">
        insert into ssmbuild.books( bookName, bookCounts, detail)
         VALUES(#{bookName},#{bookCounts},#{detail})
    </insert>

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

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

    <select id="queryById" parameterType="int" 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 like concat('%',#{bookName},'%')
    </select>
</mapper>

g、pojo包下的Books类

package com.liu.pojo;

public class Books {
    private int bookID;
    private String bookName;
    private int bookCounts;
    private String detail;

    public int getBookID() {
        return bookID;
    }

    public void setBookID(int bookID) {
        this.bookID = bookID;
    }

    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    public int getBookCounts() {
        return bookCounts;
    }

    public void setBookCounts(int bookCounts) {
        this.bookCounts = bookCounts;
    }

    public String getDetail() {
        return detail;
    }

    public void setDetail(String detail) {
        this.detail = detail;
    }

    public Books(int bookID, String bookName, int bookCounts, String detail) {
        this.bookID = bookID;
        this.bookName = bookName;
        this.bookCounts = bookCounts;
        this.detail = detail;
    }

    public Books() {
    }

    @Override
    public String toString() {
        return "Books{" +
                "bookID=" + bookID +
                ", bookName='" + bookName + '\'' +
                ", bookCounts=" + bookCounts +
                ", detail='" + detail + '\'' +
                '}';
    }
}

h、service包下的BookService.Java接口

package com.liu.service;

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

import java.util.List;

public interface BookService {

    //增加一本书
    int addBook(Books books);

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

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

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

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

    //通过书名模糊查询书籍
    List<Books>queryBookByName(String bookName);
}

i、BookService接口的实现类：BookServiceImpl

package com.liu.service;

import com.liu.dao.BookMapper;
import com.liu.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 deleteBookById(int id) {
        return bookMapper.deleteBookById(id);
    }

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

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

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

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

14、简单练习使用ajax验证用户名是否存在

配置application.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
        https://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">

    <context:component-scan base-package="com.liu.controller"/>
    <mvc:default-servlet-handler/>
    <!--加载驱动-->
    <mvc:annotation-driven>
        <!--解决JSON乱码问题配置-->
        <mvc:message-converters register-defaults="true">
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <constructor-arg value="utf-8"/>
            </bean>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
                <property name="objectMapper">
                    <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                        <property name="failOnEmptyBeans" value="false"/>
                    </bean>
                </property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>

    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>

新建一个jsp页面，里面包含输入框：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>登录操作</title>
    <script src="static/js/jquery-3.6.0.js"></script>
    <script>
            function onb1() {
                $.post({
                    url:"${pageContext.request.contextPath}/a2",
                    data:{"name":$("#zh").val()},
                    success:function (data) {
                        if(data.toString()=='ok'){
                            $("#zh-info").css("color","green");
                        }else{
                            $("#zh-info").css("color","red");
                        }
                        $("#zh-info").html(data);
                    }
                });
            }
            function onb2() {
                $.post({
                    url:"${pageContext.request.contextPath}/a2",
                    data:{"pwd":$("#pwd").val()},
                    success:function (data) {
                        if(data.toString()=='ok'){
                            $("#pwd-info").css("color","green");
                        }else{
                            $("#pwd-info").css("color","red");
                        }
                        $("#pwd-info").html(data);
                    }
                });
            }

    </script>
</head>
<body>
    <h1>登陆操作</h1>
账号：<input type="text"  οnblur="onb1()" id="zh">&nbsp;<span id="zh-info"></span><br/>
密码:<input id="pwd"  οnblur="onb2()" >&nbsp;<span id="pwd-info"></span>
</body>
</html>

在controller包下新建个AjaxController.java

@RestController//不会返回视图
public class AjaxController {
    @RequestMapping("/a2")
    public String ted(String name,String pwd){
        String msg="";
        System.out.println(name+"=="+pwd);
        if(name!=null){
            if("nan".equals(name)){
                msg="ok";
            }else {
                msg="失败";
            }
        }
        if(pwd!=null){
            if("123".equals(pwd)){
                msg="ok";
            }else {
                msg="密码有误！";
            }
        }
        return msg;
    }
}

注意：若中文乱码，请检查 ①：配置文件中是否添加了json处理编码②：web.xml是否配置官方的编码格式filter。

15、SpringMvc-拦截器

1、概述：

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

2、过滤器和拦截器的区别：

拦截器是AOP思想的具体应用。

3、过滤器：

servlet规范中的一部分，任何Java web工程师都可以使用。
在url-pattern中配置了“/*”之后，可以对所有要访问的资源进行拦截。

4、拦截器：

拦截器是SpringMvc框架自己的，只有使用了SpringMvc框架的工程才能使用。
拦截器只会拦截访问的控制器方法，若访问的是jsp/html/css/image/js是不会进行拦截的

5、自定义拦截器：

如何实现拦截器呢？

答：必须实现HandlerInterceptor接口。

1、编写自定义拦截器类：

public class InterceptorTest implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("----preHandle---");

        /*表示地址中是否包含“login”，若包含则放行。
        * if(request.getRequestURI().contains("login")){
        * return true;
        * }
        * */

        HttpSession session = request.getSession();
        String  name =(String) session.getAttribute("userName");
        String pwd =(String) session.getAttribute("pwd");
        if(name!=null && pwd!=null){
            return true;
        }else{
            response.sendRedirect("t2");
            return false;
        }
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("---postHandle----");
        HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
    }

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

2、controller类

import javax.servlet.http.HttpSession;
@Controller
@RequestMapping("/liu")
public class TestController {

    //进入成功页面
    @RequestMapping("/t1")
    public String testOne(){
        return "shou";
    }

    //跳到注册页面
    @RequestMapping("/t2")
    public String testTwo(){

        return "zhuCe";
    }
    //注册操作
    @RequestMapping("/zhuCe")
    public String toZh(String name,String pwd,HttpSession session){
        System.out.println(name+"==="+pwd);
        session.setAttribute("userName",name);
        session.setAttribute("pwd",pwd);
        return "shou";
    }

    //注销操作
    @RequestMapping("/zhuXiao")
    public String toZx(HttpSession session){
        session.removeAttribute("userName");
        session.removeAttribute("pwd");
        return "redirect:/liu/t1";
    }
}

3、applicationConfig.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
        https://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">
    <context:component-scan base-package="com.liu.controller"/>
    <mvc:default-servlet-handler/>
    <mvc:annotation-driven>
        <!--解决JSON乱码问题配置-->
        <mvc:message-converters register-defaults="true">
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <constructor-arg value="utf-8"/>
            </bean>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
                <property name="objectMapper">
                    <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                        <property name="failOnEmptyBeans" value="false"/>
                    </bean>
                </property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>


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

    <!--拦截器-->
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/liu/t1"/>
            <bean class="com.liu.interceptor.InterceptorTest"/>
        </mvc:interceptor>
    </mvc:interceptors>
</beans>

4、web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationConfig.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>

5、jsp页面：

启动页：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>首页测试</title>
  </head>
  <body>
  <h3><a href="${pageContext.request.contextPath}/liu/t1">进入首页</a></h3>
  <h3><a href="${pageContext.request.contextPath}/liu/t2">登录</a></h3>
  </body>
</html>

WEB-INF下的jsp包下的页面：

1、注册页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>注册操作</title>
</head>
<body>
    <form action="${pageContext.request.contextPath}/liu/zhuCe" method="post">
        <input name="name"><br/>
        <input name="pwd"><br/>
        <input type="submit" value="提交">
    </form>
</body>
</html>

2、登陆成功页面：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>首页</title>
</head>
<body>
<h1>欢迎你的到来：${userName}+++++${pwd}</h1>
<a href="${pageContext.request.contextPath}/liu/zhuXiao">注销</a>
</body>
</html>

注意：别忘记在项目工程中添加lib文件夹以及相关依赖文件。

aee/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:applicationConfig.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>

```

5、jsp页面：