一、 SpringBoot整合Mybatis说明

1、Mybatis介绍

MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。
概括: MyBatis 是一款优秀的持久层框架,并且在内部整合的了JDBC,简化了用户操作数据库的过程.
Mybatis是一个半自动化的ORM映射框架

2、ORM思想

对象关系映射（英语：Object Relational Mapping，简称ORM，或O/RM，或O/R mapping），是一种程序设计技术，用于实现面向对象编程语言里不同类型系统的数据之间的转换。从效果上说，它其实是创建了一个可在编程语言里使用的“虚拟对象数据库”。如今已有很多免费和付费的ORM产品，而有些程序员更倾向于创建自己的ORM工具。
核心知识:
宗旨：以对象的方式操作数据库
1. 要求查询的结果集可以自动的封装为对象 (读)
2. 利用对象封装数据，之后(自动)动态的生成Sql语句执行相关操作(更新)

3、SpringBoot整合Mybatis流程

1）导入依赖jar包 数据库驱动/JDBC包/Spring整合Mybatis包
2）编辑application.yml文件 配置数据源/配置Spring整合Mybatis
3）编辑Mybatis 接口文件/编辑xxx.xml映射文件
4）通过@MapperScan为接口创建代理对象

4、@SpringBootTest

说明：该注解是SpringBoot程序，为了简化后端代码测试，提供了专门的测试API.
关键点：测试时需要Spring容器管理对象，同时将测试的对象获取之后进行测试.
注意事项:：测试注解只能在测试包中运行

5、Mybatis调用流程

1）Spring容器为接口创建代理对象. Spring容器启动对象立即创建
2）根据 @Autowired 注解动态注入Mapper接口的代理对象
3）用户通过Mapper接口调用方法.(执行业务操作)
4）Mybatis根据接口方法动态匹配xml的映射文件
	4.1） 根据Mapper的接口路径匹配xml映射文件中的 com.jt.mapper.UserMapper
	4.2）根据接口的方法，匹配xml映射文件中的Sql ID，之后执行Sql语句
	4.3）Mybatis将结果集封装为对象，之后返回

6、关于Mybatis-statement异常说明

方法一：更换xml映射文件

方法二：更换YML文件

方法三：由于IDEA缓存导致Mybatis链接异常

二、MybatisPlus

1、MP介绍

1.1）MP简介

1.2）什么是MP

无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可*配置，完美解决主键问题
支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作
支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）
内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
内置性能分析插件：可输出 Sql 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作

2、MP入门案例

核心思想：利用对象操作数据库，单表查询几乎不写Sql
项目结构

2.1）导入jar包

说明：MybatisPlus对Mybatis的增强(包含)，所有jar包只需要导入MP的即可，原有的Mybatis需要删除
在pox表中添加

<?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.jt</groupId>
	<artifactId>springboot_demo3_mp</artifactId>
	<version>1.0-SNAPSHOT</version>

	<!--
	  定位: SpringBoot主要的作用整合SSM,使得框架的使用更加简化
	  原则: "开箱即用"
	  parent主要的作用:
			 1.SpringBoot在内部兼容了当下几乎所有的第三方框架
			 2.SpringBoot官网已经将所有兼容的版本进行了定义
			  (几乎解决了版本冲突问题)以后几乎不写版本号
	  概括: parent标签中管理其他的项目版本信息.
  -->
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.5.2</version>
		<relativePath/>
	</parent>

	<properties>
		<java.version>1.8</java.version>
		<!--跳过测试类打包-->
		<skipTests>true</skipTests>
	</properties>

	<!--原则: 按需导入  -->
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<!--springboot启动项(器)在包的内部SpringBoot
			已经完成了项目的"整合"(配置) 用户拿来就用
			web导入SpringMVC
			-->
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>

		<!--支持热部署 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
		</dependency>

		<!--添加lombok依赖-->
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
		</dependency>

		<!--引入数据库驱动 -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>

		<!--springBoot数据库连接  -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-jdbc</artifactId>
		</dependency>

		<!--spring整合mybatis  暂时
		   mapper接口/mapper.xml映射文件
		  -->

		<!--
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>2.2.0</version>
		</dependency>
		-->

		<!--导入MP包之后,删除原有的Mybatis的包 -->
		<dependency>
			<groupId>com.baomidou</groupId>
			<artifactId>mybatis-plus-boot-starter</artifactId>
			<version>3.4.3</version>
		</dependency>

	</dependencies>

	<!--SpringBoot项目与Maven整合的一个插件
		可以通过插件 执行项目打包/测试/文档生成等操作
		注意事项: 该插件不能省略
		项目发布时: java -jar xxxx.jar  报错:没有主清单信息!!!!
	-->
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<version>2.5.2</version>
			</plugin>
		</plugins>
	</build>


</project>

2.2）配置对象关系映射，User.java

package com.jt.pojo;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import org.springframework.stereotype.Component;

import java.io.Serializable;

/**
 * 对象关系映射配置:
 *      1.User对象需要与demo_user表绑定
 *      2.User对象中的属性与表中的字段一一绑定
 */
@Data
@Accessors(chain = true)
@TableName("demo_user")
//实体对象的作用 就是用来实现参数传递
//@Component //不需要将实体对象交给Spring容器管理
public class User implements Serializable {
    //主键自增
    @TableId(type= IdType.AUTO)
    //序列化:保证数据传输完整性
    private Integer id;

    //@TableField( "name")
    //如果属性与字段同名(包括驼峰规则)注解可以省略
    private String name;
    private Integer age;
    private String sex;
}

2.3）继承公共API接口 ，UserMapper

package com.jt.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jt.pojo.User;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;
//Mybatis接口如何交给Spring容器管理!!!!!
//@Mapper//Mybatis为接口创建代理对象 JDK动态代理对象 Spring容器管理
@Mapper
public interface UserMapper extends BaseMapper<User> {

    //查询所有demo_user表的数据
    List<User> getAll();
    Integer getId(String name);

}

2.4）编辑YML配置文件

server:
  port: 8090

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/jt?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
    username: root
    password: root
    #如果数据库密码以数字0开头 则必须使用""号包裹
    #password: "01234"

#SpringBoot整合MP配置
mybatis-plus:
  #定义别名包: 实现对象映射
  type-aliases-package: com.jt.pojo
  #加载映射文件一个接口对应一个映射文件
  mapper-locations: classpath:/mybatis/*.xml
  #开启驼峰映射
  configuration:
    map-underscore-to-camel-case: true

#不打印日志
debug: false

#Mapper接口执行 打印Sql日志
logging:
  level:
    com.jt.mapper: debug

2.5）工具API测试

@SpringBootTest
public class TestSpringBoot {
    @Autowired
    private UserMapper userMapper;   //代理对象

    @Test
    public void testGetAll(){
        System.out.println(userMapper.getClass());
        List<User> userList = userMapper.getAll();
        System.out.println(userList);
    }

    /**
     * 新增用户
     *  Mybatis: 1.mapper接口 2.xml映射 Sql
     *  MP: 调用接口方法
     */
    @Test
    public void testInsert(){
        User user = new User();
        user.setName("呵呵").setAge(30).setSex("男");
        //单表操作几乎不写Sql
        userMapper.insert(user);
    }
}

2.6） 打印日志

server:
  port: 8090

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/jt?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
    username: root
    password: root

#SpringBoot整合MP
mybatis-plus:
  type-aliases-package: com.jt.pojo
  mapper-locations: classpath:/mybatis/*.xml
  configuration:
    map-underscore-to-camel-case: true


# Mapper接口执行  打印Sql日志
logging:
  level:
    com.jt.mapper: debug

3、MP实现原理

1）用户执行User对象入库操作 userMapper.insert(user);
2）由于接口方法中需要传递泛型对象，则根据用户配置查找对应的泛型对象
3）根据用户的接口获取Mapper接口的父级接口BaseMapper，根据BaseMapper中的泛型对象，获取信息User.class类型
4）根据User.class 动态获取@TableName(“demo_user”) 获取对象对应的表名，之后通过@TableField(“name”)绑定与之对应的字段.，至此对象与表完成了映射.
5）根据上述的映射关系,动态的拼接Sql语句.
例子: userMapper.insert(user对象) 如何转化Sql?
		insert into 表名(字段名…) values (属性值…)
		insert into demo_user(id,name,age,sex) values (“和xx”,xx,xx,xx)
MP将动态生成的Sql交给Mybatis执行最终实现数据入库操作!!!

4、MP用法

4.1 根据ID查询数据

/**
     * MP: 用对象操作数据库.
     * 学习: 代码结构
     * 案例1: 根据Id=1查询数据. ID=主键
     * Sql: SELECT id,name,age,sex FROM demo_user WHERE id=?
     */
    @Test
    public void getUserById(){
        User user = userMapper.selectById(1);
        System.out.println(user);
    }

4.2）条件构造器-对象封装

/**
     * 案例2: 根据age=18 sex="女" 查询数据
     * Sql: select * from demo_user where age=18 and sex="女"
     */
    @Test
    public void getUserByAS(){
        //构建条件构造器 动态的拼接where条件的
        User user = new User();
        user.setAge(18).setSex("女");
        //根据对象中不为null的属性生成where条件 默认都是and 连接
        QueryWrapper queryWrapper = new QueryWrapper(user);
        List<User> userList = userMapper.selectList(queryWrapper);
        System.out.println(userList);
    }

4.3）条件构造器-特殊字符查询

/**
     * 案例3: 根据age>18 sex="女" 查询数据
     * Sql: select * from demo_user where age>18 and sex="女"
     * 特殊字符(xml文件): > gt, < lt , = eq
     *          >= ge, <=le, != ne
     */
    @Test
    public void getUserGT(){
        QueryWrapper<User> queryWrapper = new QueryWrapper();
        queryWrapper.gt("age", 18)
                    .eq("sex","女");
        List userList = userMapper.selectList(queryWrapper);
        System.out.println(userList);
    }

4.4）条件构造器-like关键字

/**
     * 案例4: 查询name中包含"君"字的数据
     * Sql: select * from demo_user where name like"%君"
     * Sql2:SELECT id,name,age,sex FROM demo_user WHERE (name NOT LIKE ?)
     */
    @Test
    public void testLike(){
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //queryWrapper.like("name","君");
        //左右看%号的位置
        //queryWrapper.likeLeft("name","君" );
        queryWrapper.notLike("name","君" );
        List<User> userList = userMapper.selectList(queryWrapper);
        System.out.println(userList);
    }

4.5）条件构造器-orderBy

/**
     * 案例5: 查询age>18的用户,按照年龄降序排列,如果年龄相同按照sex排列
     */
    @Test
    public void testOrderBy(){
        QueryWrapper<User> queryWrapper = new QueryWrapper();
        queryWrapper.gt("age",18)
                    .orderByDesc("age", "sex");
        List<User> userList = userMapper.selectList(queryWrapper);
        System.out.println(userList);
    }

4.6）条件构造器-in关键字

/**
     * 案例6: 查询Id=1,3,5,6,7的数据
     * 关键字: 单表查询  in or 效率相差不大
     *        多表查询时  建议使用 or 性能更快
     * 可变参数类型:
     *      1.可变参数类型 数据结构实质是一个数组.
     *      2.定义可变参数类型时,必须位于方法参数的最后一位!
     *      void addUser(Integer age,Integer... ids);
     *      void addUser(Integer age,Integer[] ids);
     */
    @Test
    public void testIn(){
        //1.方法1 条件构造器
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //queryWrapper.in("age","1,3,5,6,7");
        queryWrapper.in("id",1,2,3,4,5,6);
        List<User> userList1 = userMapper.selectList(queryWrapper);
        //2.MP 特殊方法调用 以后尽可能使用对象类型(对象有方法)
        Integer[] ids = new Integer[]{1,2,3,4,5,6};
        List idList = Arrays.asList(ids);
        List<User> userList2 = userMapper.selectBatchIds(idList);
        System.out.println(userList1);
        System.out.println(userList2);
    }

4.7）条件构造器-动态Sql

 /**
     * 案例7: 根据 name/sex 动态查询数据库
     * 解析:  如果name/sex有值则动态拼接where条件.
     *       否则不写where条件.
     * 动态Sql实现: condition 参数
     *             布尔类型值  true:  拼接where条件
     *                        false: 不拼接where条件
     * 字符串判断API:
     *      StringUtils.hasLength(name);
     */
    @Test
    public void testSelectNS(){
        String name = null;
        String sex = "";
        QueryWrapper<User> queryWrapper = new QueryWrapper();
        //判断是否有值
        boolean nameFlag = StringUtils.hasLength(name);
        boolean sexFlag =  StringUtils.hasLength(sex);
        queryWrapper.eq(nameFlag,"name",name)
                    .eq(sexFlag,"sex",sex);
        List userList = userMapper.selectList(queryWrapper);
        System.out.println(userList);
    }

4.8）MP的更新操作

@Test
    public void testUpdate(){
        User user = new User();
        user.setName("祝君好运").setAge(100);
        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("name","呵呵");
        int row = userMapper.update(user,updateWrapper);
        System.out.println(row);
    }

    // name="云英" sex="男"  age="16"
    @Test
    public void testUpdateById(){
        User user = new User();
        user.setId(246).setName("云英").setSex("男").setAge(16);
        //where id=xxx, 其他不为null的属性当作set条件.
        userMapper.updateById(user);
    }