MyBatis-Plus

最新推荐文章于 2024-06-20 17:45:58 发布

悬浮海

最新推荐文章于 2024-06-20 17:45:58 发布

阅读量463

点赞数

CC 4.0 BY-SA版权

分类专栏： # Spring体系框架应用文章标签： java mybatisplus mybatis

本文链接：https://blog.youkuaiyun.com/wang_luwei/article/details/120264995

Spring体系框架应用专栏收录该内容

46 篇文章

订阅专栏

本文介绍了MyBatisPlus的概述，包括其简化开发、无侵入和损耗小的特点，以及如何通过步骤进行快速入门，涵盖了数据库配置、CRUD操作、配置日志、乐观锁和代码自动生成等内容。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、MyBatisPlus概述

学习MyBatis-Plus之前要先学MyBatis–>Spring—>SpringMVC

为什么要学它?MyBatisPlus可以节省我们大量的时间,所有CRUD代码都可以自动完成

JPA, tk-mapper ,MyBatisPlus（都是用来自动生成CRUD代码的）

偷懒用的!

1.1简介

是什么? MyBatis本来就是简化JDBC操作的!

官网:https://baomidou.com/ MyBatisPlus 简化MyBatis！

MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

1.2特性

无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求（简单的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 操作智能分析阻断，也可自定义拦截规则，预防误操作

二、快速入门

地址:https://baomidou.com/guide/quick-start.html#%E5%88%9D%E5%A7%8B%E5%8C%96%E5%B7%A5%E7%A8%8B

使用第三方插件步骤:

导入对应的依赖
研究依赖如何配置
代码如何编写
提高扩展技术能力

2.1步骤

1.创建数据库 mybatis_plus

2.创建数据库

创建表

DROP TABLE IF EXISTS user;

CREATE TABLE user
(
    id BIGINT(20) NOT NULL COMMENT '主键ID',
    name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
    age INT(11) NULL DEFAULT NULL COMMENT '年龄',
    email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
    PRIMARY KEY (id)
);

INSERT INTO user (id, name, age, email) VALUES
(1, 'Jone', 18, 'test1@baomidou.com'),
(2, 'Jack', 20, 'test2@baomidou.com'),
(3, 'Tom', 28, 'test3@baomidou.com'),
(4, 'Sandy', 21, 'test4@baomidou.com'),
(5, 'Billie', 24, 'test5@baomidou.com');

3.编写项目,初始化项目! 使用SpringBoot初始化!

4.导入依赖

<!--mysql驱动-->
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
</dependency>
<!--lombok-->
<dependency>
  <groupId>org.projectlombok</groupId>
  <artifactId>lombok</artifactId>
</dependency>
<!--mybatis-plus 是自己开发，并非官方的-->
<dependency>
  <groupId>com.baomidou</groupId>
  <artifactId>mybatis-plus-boot-starter</artifactId>
  <version>3.0.5</version>
</dependency>

说明:我们使用mybatis-plus 可以节省我们大量的代码,尽量不要同时导入mybatis和mybatis-plus因为版本有差异!

5.连接数据库!这一步和mybatis相同!

# mysql 5 驱动不同  com.mysql.jdbc.Driver

# mysql 8 驱动不同 com.mysql.cj.jdbc.Driver . 需要增加时区的配置 serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=12345678
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

6.传统的方式pojo-dao(连接mybatis,配置mapper.xml文件)-service-controller

6.使用了mybatis-plus之后

pojo

package com.wlw.pojo;

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

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {

    private Long id;
    private String name;
    private int age;
    private String email;
}

mapper接口

package com.wlw.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.wlw.pojo.User;
import org.springframework.stereotype.Repository;

//在对应的mapper 上面继承 基本的类BaseMapper<T> ，这个类是由mybatisplus提供的
@Repository //代表持久层
public interface UserMapper extends BaseMapper<User> {
    //所有CRUD操作都已经编写完成了，因为BaseMapper<T>中已经写好了，需要操作那个对象，传入对应的实体类就好（范型）
    //你不需要向以前一样配置一大堆文件了!

}

注意点:需要在主启动类MybatisPlusApplication上扫描我们Mapper包下的所有接口

@MapperScan("com.codeyuaiiao.mapper")

package com.wlw;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@MapperScan("com.wlw.mapper")//扫描mapper文件夹
@SpringBootApplication
public class MybatisPlusApplication {

    public static void main(String[] args) {
        SpringApplication.run(MybatisPlusApplication.class, args);
    }
}

测试类中测试

package com.wlw;

import com.wlw.mapper.UserMapper;
import com.wlw.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
class MybatisPlusApplicationTests {

    //继承了BaseMapper, 所有的方法都来自父类（即继承了BaseMapper）,我们也可以编写自己的扩展方法
    @Autowired
    private UserMapper userMapper;

    @Test
    void contextLoads() {
        //参数是一个Wrapper , 条件构造器,这里我们先不用 --null
        //查询全部用户
        List<User> users = userMapper.selectList(null);
        users.forEach(System.out::println);
    }

}

2.2 思考问题

sql谁帮我们写的? —mybatis-plus
方法谁帮我们写的? —mybatis-pluss

三、配置日志

我们所有的sql是不可见的,我们希望知道他是怎么执行的,所以我们必须看日志!

在application.properties配置文件中配置就好

#日志配置
#可选的有很多，要导入对应依赖就好，这里选择控制台输出
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

配置好，再测试，看输出结果：

Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@5d342959] was not registered for synchronization because synchronization is not active
JDBC Connection [HikariProxyConnection@1623287356 wrapping com.mysql.cj.jdbc.ConnectionImpl@f5cf29b] will not be managed by Spring
==>  Preparing: SELECT id,name,age,email FROM user 
==> Parameters: 
<==    Columns: id, name, age, email
<==        Row: 1, Jone, 18, test1@baomidou.com
<==        Row: 2, Jack, 20, test2@baomidou.com
<==        Row: 3, Tom, 28, test3@baomidou.com
<==        Row: 4, Sandy, 21, test4@baomidou.com
<==        Row: 5, Billie, 24, test5@baomidou.com
<==      Total: 5
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@5d342959]
User(id=1, name=Jone, age=18, email=test1@baomidou.com)
User(id=2, name=Jack, age=20, email=test2@baomidou.com)
User(id=3, name=Tom, age=28, email=test3@baomidou.com)
User(id=4, name=Sandy, age=21, email=test4@baomidou.com)
User(id=5, name=Billie, age=24, email=test5@baomidou.com)

配置完毕日志之后，之后的使用过程中就需要注意这个自动生成的SQL！

四、CRUD扩展

4.1 INSERT 插入测试

package com.wlw;

import com.wlw.mapper.UserMapper;
import com.wlw.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
class MybatisPlusApplicationTests {

    //继承了BaseMapper, 所有的方法都来自父类（即继承了BaseMapper）,我们也可以编写自己的扩展方法
    @Autowired
    private UserMapper userMapper;

    @Test
    public void testInsert(){
        User user = new User();
        //注意 并没设置id
        user.setName("wlw");
        user.setAge(3);
        user.setEmail("1903202403@qq.com");

        int reslut = userMapper.insert(user);//看结果输出会发现它会自动生成id
        System.out.println(reslut);//受影响行数
        System.out.println(user);//看user的属性值，发现id会自动回填
    }
}

输出日志：(注意看user 的id值)

Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@124d02b2] was not registered for synchronization because synchronization is not active
JDBC Connection [HikariProxyConnection@1942211849 wrapping com.mysql.cj.jdbc.ConnectionImpl@4a8a0099] will not be managed by Spring
==>  Preparing: INSERT INTO user ( id, name, age, email ) VALUES ( ?, ?, ?, ? ) 
==> Parameters: 1413764856826785794(Long), wlw(String), 3(Integer), 1903202403@qq.com(String)
<==    Updates: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@124d02b2]
1
User(id=1413764856826785794, name=wlw, age=3, email=1903202403@qq.com)

数据库插入的id默认值是为：全局唯一id （这就涉及到主键生成策略）

4.1.1主键生成策略

生成策略可分为：uuid，自增，雪花算法，redis生成，zookeeper生成等（可看一些资料：（分布式系统唯一ID生成方案汇总）https://www.cnblogs.com/haoxinyue/p/5208136.html）

而上面的插入测试中逐渐的生成策略是雪花算法。

雪花算法：snowflake是Twitter开源的分布式ID生成算法，结果是一个long型的ID。其核心思想是：使用41bit作为毫秒数，10bit作为机器的ID（5个bit是数据中心，5个bit的机器ID），12bit作为毫秒内的流水号（意味着每个节点在每毫秒可以产生 4096 个 ID），最后还有一个符号位，永远是0。具体实现的代码可以参看https://github.com/twitter

4.1.1.1设置主键自增

主键自增：

我们需要配置主键自增，步骤：

1.在实体类字段上增加@TableId(type = IdType.AUTO)

public class User {

    //对应数据库中的主键(uuid、自增id、雪花算法、redis、 zookeeper! )
    @TableId(type = IdType.AUTO)
    private Long id;
    private String name;
    private int age;
    private String email;
}

看一下IdType的源码：

package com.baomidou.mybatisplus.annotation;

public enum IdType {
    AUTO(0), //数据库ID自增  
    NONE(1), //该类型为未设置主键类型  
    INPUT(2), //用户输入ID，（必须要手动输入id，不然为null）该类型可以通过自己注册自动填充插件进行填充
  
    //以下3种类型、只有当插入对象ID 为空，才自动填充。
    ID_WORKER(3),//mybatisplus 默认的全局唯一ID (idWorker) 
    UUID(4),//全局唯一ID (UUID)  
    ID_WORKER_STR(5);//字符串全局唯一ID (idWorker 的字符串表示)

    private int key;

    private IdType(int key) {
        this.key = key;
    }

    public int getKey() {
        return this.key;
    }
}

2.数据库字段一定要设置为自增（Auto Increment）！

3.再次执行4.1节中的插入测试，会发现id自增+1了。

输出结果日志：

Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@53e76c11] was not registered for synchronization because synchronization is not active
JDBC Connection [HikariProxyConnection@166022233 wrapping com.mysql.cj.jdbc.ConnectionImpl@5dbb50f3] will not be managed by Spring
==>  Preparing: INSERT INTO user ( name, age, email ) VALUES ( ?, ?, ? ) 
==> Parameters: wlw(String), 3(Integer), 1903202403@qq.com(String)
<==    Updates: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@53e76c11]
1
User(id=1413764856826785795, name=wlw, age=3, email=1903202403@qq.com)

4.2UPDATE更新测试

@SpringBootTest
class MybatisPlusApplicationTests {

    //更新测试
    @Test
    public void testUpdate(){
        User user = new User();
        // 通过条件自动拼接动态sql（很强大）
        //从数据库中拿到的id
        user.setId(5L);
        user.setName("wlw1");
        user.setAge(18);

        //注意：updateById（）方法的参数是一个对象。
        int i = userMapper.updateById(user);
        System.out.println(i);
    }
}

输出结果日志：

Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@3e4e8fdf] was not registered for synchronization because synchronization is not active
JDBC Connection [HikariProxyConnection@1250558105 wrapping com.mysql.cj.jdbc.ConnectionImpl@7c1447b5] will not be managed by Spring
==>  Preparing: UPDATE user SET name=?, age=? WHERE id=? 
==> Parameters: wlw1(String), 18(Integer), 5(Long)
<==    Updates: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@3e4e8fdf]
1

所有的sql都是自动帮我们动态配置的！

4.2.1自动填充

创建时间，修改时间! 这些个操作都是自动化完成的，不要手动更新!

阿里巴巴开发手册:所有的数据库表:gmt_create .gmt_modified几乎所有的表都要配置上!而且需要自动化!

4.2.1.1 方式一数据库级别

1.在表中新增字段 create_time （默认是为当前时间：CURRENT_TIMESTAMP）, update_time（勾选自动更新）

2.再次测试插入方法,我们需要先把实体类同步

private Date createTime;
private Date updateTime;

3.再次更新查看结果即可

4.2.1.2 方式二代码级别

1.删除数据库默认值、更新操作（上一步操作的）

2.实体类字段属性上添加注解

//字段添加填充内容
@TableField(fill = FieldFill.INSERT)
private Date createTime;

@TableField(fill = FieldFill.INSERT_UPDATE)
private Date updateTime;

3.编写处理器来处理这个注解

package com.wlw.handler;

import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;

import java.util.Date;

@Slf4j
@Component //声明bean，把处理器加到IOC容器中
public class MyMetaObjectHandler implements MetaObjectHandler {
    // 插入时的填充策略
    @Override
    public void insertFill(MetaObject metaObject) {
        log.info("Start insert fill.... ");
        this.setFieldValByName("createTime",new Date(),metaObject);
        this.setFieldValByName("updateTime",new Date(),metaObject);
    }

    // 更新时的填充策略
    @Override
    public void updateFill(MetaObject metaObject) {
        log.info("Start update fill.... ");
        this.setFieldValByName("updateTime",new Date(),metaObject);
    }
}

4.测试插入

5测试更新,观察时间即可!

4.2.2乐观锁

乐观锁: 顾名思义十分乐观,他总是认为不会出现问题,无论干什么都不去上锁!如果出现了问题,再次更新值测试

悲观锁;顾名思义十分悲观,他总是认为出现问题,无论干什么都会上锁!再去操作!

乐观锁实现方式:

取出记录时,获取当前version
更新时,带上这个version
执行更新时,set version = newVersion where version = oldVersion
如果version不对,就更新失败

乐观锁：第一步，先查询，获得版本号 version = 1

--A线程
update user set name = "wlwnew",version = version + 1
where id = 2 and version = 1

--B线程 抢先执行，这个时候version = 2，会导致A线程修改失败
update user set name = "wlwnew",version = version + 1
where id = 2 and version = 1

测试一下MyBatisPlus乐观锁插件：

1.给数据库增加version字段，默认值是为1

2.实体类加对应字段

@Version //乐观锁注解
private Integer version;

3.注册组件

package com.wlw.config;

import com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

//@MapperScan("按需修改")
@Configuration //配置类
public class MyBatisPlusConfig {
  
   //注册乐观锁插件
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }
}

4.测试一下

//测试乐观锁成功
@Test
public void testOptimisticLocker1(){
  //1.查询用户
  User user = userMapper.selectById(1L);
  //2.修改用户信息
  user.setName("wlw-version");
  user.setEmail("11111000@qq.com");
  //3.执行更新
  userMapper.updateById(user);
}

Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@49a6f486] was not registered for synchronization because synchronization is not active
JDBC Connection [HikariProxyConnection@1244560331 wrapping com.mysql.cj.jdbc.ConnectionImpl@575c3e9b] will not be managed by Spring
==>  Preparing: SELECT id,name,age,email,version,create_time,update_time FROM user WHERE id=? 
==> Parameters: 1(Long)
<==    Columns: id, name, age, email, version, create_time, update_time
<==        Row: 1, Jone, 18, test1@baomidou.com, 1, 2021-07-10 17:34:37, null
<==      Total: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@49a6f486]

Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@273a5a8a] was not registered for synchronization because synchronization is not active
2021-07-10 18:48:36.257  INFO 36141 --- [           main] com.wlw.handler.MyMetaObjectHandler      : Start update fill.... 
JDBC Connection [HikariProxyConnection@298862004 wrapping com.mysql.cj.jdbc.ConnectionImpl@575c3e9b] will not be managed by Spring
==>  Preparing: UPDATE user SET name=?, age=?, email=?, version=?, create_time=?, update_time=? WHERE id=? AND version=? 
==> Parameters: wlw-version(String), 18(Integer), 11111000@qq.com(String), 2(Integer), 2021-07-10 17:34:37.0(Timestamp), 2021-07-10 18:48:36.257(Timestamp), 1(Long), 1(Integer)
<==    Updates: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@273a5a8a]

//测试乐观锁失败
@Test
public void testOptimisticLocker2(){
  //线程1
  User user = userMapper.selectById(1L);
  user.setName("wlw-version11");
  user.setEmail("11111000@qq.com");

  //模仿线程2执行插队操作
  User user2 = userMapper.selectById(1L);
  user2.setName("wlw-version22");
  user2.setEmail("11111000@qq.com");
  userMapper.updateById(user2);//线程2更新

  //3.执行更新 线程1
  //如果没有乐观锁就会覆盖线程2 的值
  userMapper.updateById(user);
}

Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@19a20bb2] was not registered for synchronization because synchronization is not active
JDBC Connection [HikariProxyConnection@1555928242 wrapping com.mysql.cj.jdbc.ConnectionImpl@6824b913] will not be managed by Spring
==>  Preparing: SELECT id,name,age,email,version,create_time,update_time FROM user WHERE id=? 
==> Parameters: 1(Long)
<==    Columns: id, name, age, email, version, create_time, update_time
<==        Row: 1, wlw-version, 18, 11111000@qq.com, 2, 2021-07-10 17:34:37, 2021-07-10 18:48:36
<==      Total: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@19a20bb2]

Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@630390b9] was not registered for synchronization because synchronization is not active
JDBC Connection [HikariProxyConnection@1720760826 wrapping com.mysql.cj.jdbc.ConnectionImpl@6824b913] will not be managed by Spring
==>  Preparing: SELECT id,name,age,email,version,create_time,update_time FROM user WHERE id=? 
==> Parameters: 1(Long)
<==    Columns: id, name, age, email, version, create_time, update_time
<==        Row: 1, wlw-version, 18, 11111000@qq.com, 2, 2021-07-10 17:34:37, 2021-07-10 18:48:36
<==      Total: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@630390b9]

Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@45adc393] was not registered for synchronization because synchronization is not active
2021-07-10 18:54:12.467  INFO 36209 --- [           main] com.wlw.handler.MyMetaObjectHandler      : Start update fill.... 
JDBC Connection [HikariProxyConnection@1387556178 wrapping com.mysql.cj.jdbc.ConnectionImpl@6824b913] will not be managed by Spring
==>  Preparing: UPDATE user SET name=?, age=?, email=?, version=?, create_time=?, update_time=? WHERE id=? AND version=? 
==> Parameters: wlw-version22(String), 18(Integer), 11111000@qq.com(String), 3(Integer), 2021-07-10 17:34:37.0(Timestamp), 2021-07-10 18:54:12.467(Timestamp), 1(Long), 2(Integer)
<==    Updates: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@45adc393]

Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@58fbd02e] was not registered for synchronization because synchronization is not active
2021-07-10 18:54:12.478  INFO 36209 --- [           main] com.wlw.handler.MyMetaObjectHandler      : Start update fill.... 
JDBC Connection [HikariProxyConnection@372261610 wrapping com.mysql.cj.jdbc.ConnectionImpl@6824b913] will not be managed by Spring
==>  Preparing: UPDATE user SET name=?, age=?, email=?, version=?, create_time=?, update_time=? WHERE id=? AND version=? 
==> Parameters: wlw-version11(String), 18(Integer), 11111000@qq.com(String), 3(Integer), 2021-07-10 17:34:37.0(Timestamp), 2021-07-10 18:54:12.478(Timestamp), 1(Long), 2(Integer)
<==    Updates: 0
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@58fbd02e]

4.3 SELECT查询测试

//查询测试
@Test
public void testSelect(){
  User user = userMapper.selectById(1L);
  System.out.println(user);
}

输出结果日志：

Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@49a6f486] was not registered for synchronization because synchronization is not active
JDBC Connection [HikariProxyConnection@1244560331 wrapping com.mysql.cj.jdbc.ConnectionImpl@575c3e9b] will not be managed by Spring
==>  Preparing: SELECT id,name,age,email,version,create_time,update_time FROM user WHERE id=? 
==> Parameters: 1(Long)
<==    Columns: id, name, age, email, version, create_time, update_time
<==        Row: 1, wlw-version22, 18, 11111000@qq.com, 3, 2021-07-10 17:34:37, 2021-07-10 18:54:12
<==      Total: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@49a6f486]
User(id=1, name=wlw-version22, age=18, email=11111000@qq.com, version=3, createTime=Sat Jul 10 17:34:37 CST 2021, updateTime=Sat Jul 10 18:54:12 CST 2021)

//批量查询测试
@Test
public void testSelect1(){
  List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
  users.forEach(System.out::println);
}

Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@40fa8766] was not registered for synchronization because synchronization is not active
JDBC Connection [HikariProxyConnection@752148842 wrapping com.mysql.cj.jdbc.ConnectionImpl@42505474] will not be managed by Spring
==>  Preparing: SELECT id,name,age,email,version,create_time,update_time FROM user WHERE id IN ( ? , ? , ? ) 
==> Parameters: 1(Integer), 2(Integer), 3(Integer)
<==    Columns: id, name, age, email, version, create_time, update_time
<==        Row: 1, wlw-version22, 18, 11111000@qq.com, 3, 2021-07-10 17:34:37, 2021-07-10 18:54:12
<==        Row: 2, Jack, 20, test2@baomidou.com, 1, 2021-07-10 17:34:37, null
<==        Row: 3, Tom, 28, test3@baomidou.com, 1, 2021-07-10 17:34:37, null
<==      Total: 3
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@40fa8766]
User(id=1, name=wlw-version22, age=18, email=11111000@qq.com, version=3, createTime=Sat Jul 10 17:34:37 CST 2021, updateTime=Sat Jul 10 18:54:12 CST 2021)
User(id=2, name=Jack, age=20, email=test2@baomidou.com, version=1, createTime=Sat Jul 10 17:34:37 CST 2021, updateTime=null)
User(id=3, name=Tom, age=28, email=test3@baomidou.com, version=1, createTime=Sat Jul 10 17:34:37 CST 2021, updateTime=null)

//条件查询测试 使用Map操作
@Test
public void testSelectBatchIds(){
  HashMap<String, Object> map = new HashMap<>();
  map.put("name","wlw");
  //map.put("age",18);

  List<User> users = userMapper.selectByMap(map);
  users.forEach(System.out::println);
}

Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@69cd1085] was not registered for synchronization because synchronization is not active
JDBC Connection [HikariProxyConnection@188647125 wrapping com.mysql.cj.jdbc.ConnectionImpl@72b43104] will not be managed by Spring
==>  Preparing: SELECT id,name,age,email,version,create_time,update_time FROM user WHERE name = ? 
==> Parameters: wlw(String)
<==    Columns: id, name, age, email, version, create_time, update_time
<==        Row: 5, wlw, 19, test5@baomidou.com, 1, 2021-07-10 17:34:37, 2021-07-10 17:41:57
<==        Row: 1413764856826785794, wlw, 18, 1903202403@qq.com, 1, 2021-07-10 17:34:37, null
<==        Row: 1413764856826785795, wlw, 3, 1903202403@qq.com, 1, 2021-07-10 17:34:37, null
<==      Total: 3
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@69cd1085]
User(id=5, name=wlw, age=19, email=test5@baomidou.com, version=1, createTime=Sat Jul 10 17:34:37 CST 2021, updateTime=Sat Jul 10 17:41:57 CST 2021)
User(id=1413764856826785794, name=wlw, age=18, email=1903202403@qq.com, version=1, createTime=Sat Jul 10 17:34:37 CST 2021, updateTime=null)
User(id=1413764856826785795, name=wlw, age=3, email=1903202403@qq.com, version=1, createTime=Sat Jul 10 17:34:37 CST 2021, updateTime=null)

4.3.1分页查询

分页在网站使用的十分之多!

1、原始的limit进行分页
2、pageHelper 第三方插件
3、MyBatisPlus其实也内置了分页插件!

使用步骤：

1.配置分页插件!

package com.wlw.config;

import com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

//@MapperScan("按需修改")
@Configuration //配置类
public class MyBatisPlusConfig {
    //分页插件
    @Bean
    public PaginationInterceptor paginationInterceptor() {
      PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
      //设置请求的页面大于最大页后操作，true 调回到首页，false继续请求，默认false
      // paginationInterceptor.setoverflow(false);
      //设置最大单页限制数量，默认500条，-1不受限制
      // paginationInterceptor. setLimit(500);
      //开启count的join优化,只针对部分left join
      return paginationInterceptor;
    }
}

2.直接使用Page对象即可！（测试）

//测试分页查询
@Test
public void testPage(){
  //参数一：当前页
  //参数二：页面大小
  //使用了分页插件之后，所有的分页操作也变得简单了！
  Page<User> page = new Page<>(1, 5);
  userMapper.selectPage(page, null);

  page.getRecords().forEach(System.out::println);
  System.out.println(page.getTotal());
}

Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@5eea5627] was not registered for synchronization because synchronization is not active
JDBC Connection [HikariProxyConnection@2063581529 wrapping com.mysql.cj.jdbc.ConnectionImpl@1682c08c] will not be managed by Spring
 JsqlParserCountOptimize sql=SELECT  id,name,age,email,version,create_time,update_time  FROM user
==>  Preparing: SELECT COUNT(1) FROM user 
==> Parameters: 
<==    Columns: COUNT(1)
<==        Row: 8
==>  Preparing: SELECT id,name,age,email,version,create_time,update_time FROM user LIMIT 0,5 
==> Parameters: 
<==    Columns: id, name, age, email, version, create_time, update_time
<==        Row: 1, wlw-version22, 18, 11111000@qq.com, 3, 2021-07-10 17:34:37, 2021-07-10 18:54:12
<==        Row: 2, Jack, 20, test2@baomidou.com, 1, 2021-07-10 17:34:37, null
<==        Row: 3, Tom, 28, test3@baomidou.com, 1, 2021-07-10 17:34:37, null
<==        Row: 4, Sandy, 21, test4@baomidou.com, 1, 2021-07-10 17:34:37, null
<==        Row: 5, wlw, 19, test5@baomidou.com, 1, 2021-07-10 17:34:37, 2021-07-10 17:41:57
<==      Total: 5
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@5eea5627]
User(id=1, name=wlw-version22, age=18, email=11111000@qq.com, version=3, createTime=Sat Jul 10 17:34:37 CST 2021, updateTime=Sat Jul 10 18:54:12 CST 2021)
User(id=2, name=Jack, age=20, email=test2@baomidou.com, version=1, createTime=Sat Jul 10 17:34:37 CST 2021, updateTime=null)
User(id=3, name=Tom, age=28, email=test3@baomidou.com, version=1, createTime=Sat Jul 10 17:34:37 CST 2021, updateTime=null)
User(id=4, name=Sandy, age=21, email=test4@baomidou.com, version=1, createTime=Sat Jul 10 17:34:37 CST 2021, updateTime=null)
User(id=5, name=wlw, age=19, email=test5@baomidou.com, version=1, createTime=Sat Jul 10 17:34:37 CST 2021, updateTime=Sat Jul 10 17:41:57 CST 2021)
8

4.4DELETE删除测试

//测试删除
@Test
public void testDeleteById(){
  userMapper.deleteById(1413764856826785796L);
}

Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@d535a3d] was not registered for synchronization because synchronization is not active
JDBC Connection [HikariProxyConnection@1846435308 wrapping com.mysql.cj.jdbc.ConnectionImpl@48a663e9] will not be managed by Spring
==>  Preparing: DELETE FROM user WHERE id=? 
==> Parameters: 1413764856826785796(Long)
<==    Updates: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@d535a3d]

//通过id批量删除
@Test
public void testDeleteBatchId(){
  userMapper.deleteBatchIds(Arrays.asList(5,6,7));
}

Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@5dbb50f3] was not registered for synchronization because synchronization is not active
JDBC Connection [HikariProxyConnection@855206842 wrapping com.mysql.cj.jdbc.ConnectionImpl@611640f0] will not be managed by Spring
==>  Preparing: DELETE FROM user WHERE id IN ( ? , ? , ? ) 
==> Parameters: 5(Integer), 6(Integer), 7(Integer)
<==    Updates: 3
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@5dbb50f3]

//通过map 条件删除
@Test
public void testDeleteMap(){
  HashMap<String, Object> map = new HashMap<>();
  map.put("name", "wlw5");
  userMapper.deleteByMap(map);
}

Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@2d760326] was not registered for synchronization because synchronization is not active
JDBC Connection [HikariProxyConnection@2098720336 wrapping com.mysql.cj.jdbc.ConnectionImpl@44fdce3c] will not be managed by Spring
==>  Preparing: DELETE FROM user WHERE name = ? 
==> Parameters: wlw5(String)
<==    Updates: 2
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@2d760326]

4.4.1 逻辑删除（很重要）

物理删除：从数据库中直接移除

逻辑删除：在数据库中没有被移除，而是通过一个变量来让他失效！deleted = 0 => deleted = 1

管理员可以查看被删除的记录！防止数据的丢失，类似于回收站!

测试一下：

1.在数据表中增加一个deleted字段，默认为0

2.实体类中增加属性

@TableLogic     //逻辑删除
private Integer deleted;

3.配置！

package com.wlw.config;

import com.baomidou.mybatisplus.core.injector.ISqlInjector;
import com.baomidou.mybatisplus.extension.injector.LogicSqlInjector;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

//@MapperScan("按需修改")
@Configuration //配置类
public class MyBatisPlusConfig {

    //逻辑删除组件
    @Bean
    public ISqlInjector sqlInjector(){
        return new LogicSqlInjector();
    }
}

还要在配置文件中添加配置

#逻辑删除
mybatis-plus.global-config.db-config.logic-not-delete-value=0
mybatis-plus.global-config.db-config.logic-delete-value=1

4.测试一下删除！

//测试删除
@Test
public void testDeleteById(){
  userMapper.deleteById(1L);
}

看输出日志：(走的是更新操作，而不是删除操作，看数据库会发现：记录依然在数据库中，但是对应的deleted的值是1)

Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@705a8dbc] was not registered for synchronization because synchronization is not active
JDBC Connection [HikariProxyConnection@1368251707 wrapping com.mysql.cj.jdbc.ConnectionImpl@939ff41] will not be managed by Spring
==>  Preparing: UPDATE user SET deleted=1 WHERE id=? AND deleted=0 
==> Parameters: 1(Long)
<==    Updates: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@705a8dbc]

5.现在再去测试一下查询，重点看输出日志：

//查询测试
@Test
public void testSelect(){
  User user = userMapper.selectById(1L);
  System.out.println(user);
}

Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@24a2e565] was not registered for synchronization because synchronization is not active
JDBC Connection [HikariProxyConnection@718130408 wrapping com.mysql.cj.jdbc.ConnectionImpl@7102ac3e] will not be managed by Spring
==>  Preparing: SELECT id,name,age,email,version,deleted,create_time,update_time FROM user WHERE id=? AND deleted=0 
==> Parameters: 1(Long)
<==      Total: 0
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@24a2e565]
null

看到输出日志中，查询id为1的数据，是查不到的，这是因为添加了一个查询条件：where id=? and deleted=0

查询的时候会自动过滤被逻辑删除的字段。

第四节部分必须要精通掌握。

五、性能分析插件

PerformanceInterceptor在3.2.0被移除了，如果想进行性能分析，用第三方的，官方这样写的“该插件 3.2.0 以上版本移除推荐使用第三方扩展执行 SQL 分析打印功能。https://baomidou.com/guide/p6spy.html

在开发中，会遇到一些慢sql。

作用：性能分析拦截器，用于输出每条SQL语句及其执行时间

MybatisPlus也提供了性能分析插件，如果超过这个时间就停止运行。

步骤：

1.导入插件

//在配置类中 MyBatisPlusConfig
// SQL执行效率插件
@Bean
@Profile({"dev","test"})
public PerformanceInterceptor performanceInterceptor(){
    PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
    performanceInterceptor.setMaxTime(100); //ms 设置sql执行的最大时间，如果超过了则不执行
    performanceInterceptor.setFormat(true); // 是否格式化
    return performanceInterceptor;
}

记住，要在SpringBoot中配置环境为dev或者test环境！

# 开发环境
spring.profiles.active=dev

2.测试使用

 // 分页查询
 @Test
 void selectLimit() {
     Page<User> page = new Page<User>(1, 5);
     // 获取通过分页查询到的记录条数
     page.getRecords().forEach(System.out::println);
     // 查询
     userMapper.selectPage(page, null);
     // 查询总记录条数
     System.out.println("总计数条数：" + page.getTotal());
 }

只要超出时间就会抛出异常（可用来检测那条sql执行的太慢，然后进行优化）

六、条件构造器

十分重要：Wappper

我们写一些复杂的SQL就可以使用他来替代！

1、测试一（注意看输出的sql，进行分析）

@Test
void contextLoads() {
    //查询name不为空的用户，并且邮箱不为空的用户，年龄大于12
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.isNotNull("name")
            .isNotNull("email")
            .ge("age", 12);
    userMapper.selectList(wrapper).forEach(System.out::println); //和我们刚刚学习的map对比一下
}

Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@56dd6efa] was not registered for synchronization because synchronization is not active
JDBC Connection [HikariProxyConnection@1724736027 wrapping com.mysql.cj.jdbc.ConnectionImpl@d3f4505] will not be managed by Spring
==>  Preparing: SELECT id,name,age,email,version,deleted,create_time,update_time FROM user WHERE deleted=0 AND name IS NOT NULL AND email IS NOT NULL AND age >= ? 
==> Parameters: 12(Integer)
<==    Columns: id, name, age, email, version, deleted, create_time, update_time
<==        Row: 2, Jack, 20, test2@baomidou.com, 1, 0, 2021-07-10 17:34:37, null
<==        Row: 3, Tom, 28, test3@baomidou.com, 1, 0, 2021-07-10 17:34:37, null
<==        Row: 4, Sandy, 21, test4@baomidou.com, 1, 0, 2021-07-10 17:34:37, null
<==        Row: 1413764856826785794, wlw, 18, 1903202403@qq.com, 1, 0, 2021-07-10 17:34:37, null
<==      Total: 4
[org.apache.ibatis.session.defaults.DefaultSqlSession@56dd6efa]
User(id=2, name=Jack, age=20, email=test2@baomidou.com, version=1, deleted=0, createTime=Sat Jul 10 17:34:37 CST 2021, updateTime=null)
User(id=3, name=Tom, age=28, email=test3@baomidou.com, version=1, deleted=0, createTime=Sat Jul 10 17:34:37 CST 2021, updateTime=null)
User(id=4, name=Sandy, age=21, email=test4@baomidou.com, version=1, deleted=0, createTime=Sat Jul 10 17:34:37 CST 2021, updateTime=null)
User(id=1413764856826785794, name=wlw, age=18, email=1903202403@qq.com, version=1, deleted=0, createTime=Sat Jul 10 17:34:37 CST 2021, updateTime=null)

2、测试二

@Test
void test2(){
  //查询名字wlw1
  QueryWrapper<User> wrapper = new QueryWrapper<>();
  wrapper.eq("name", "wlw1");
  User user = userMapper.selectOne(wrapper);//查询一个数据，出现多个结果用List或者Map
  System.out.println(user);
}

3、测试三

@Test
void test3(){
  //查询年龄在19到30岁之间的用户
  QueryWrapper<User> wrapper = new QueryWrapper<>();
  wrapper.between("age", 19, 30); //区间
  Integer count = userMapper.selectCount(wrapper); //查询结果数
  System.out.println(count);
}

4、测试四

//模糊查询
@Test
void test4(){
  QueryWrapper<User> wrapper = new QueryWrapper<>();
  //名字中没有b的 %b%  左和右  t%
  wrapper.notLike("name", "b")
    .likeRight("email", "t");
  List<Map<String, Object>> maps = userMapper.selectMaps(wrapper);
  maps.forEach(System.out::println);
}

5、测试五

//连接查询
@Test
void test5(){
  QueryWrapper<User> wrapper = new QueryWrapper<>();
  //id 在子查询中查出来
  wrapper.inSql("id", "select id from user where id < 3");
  List<Object> objects = userMapper.selectObjs(wrapper);
  objects.forEach(System.out::println);
}

6、测试六

//排序 查询
@Test
void test6(){
  QueryWrapper<User> wrapper = new QueryWrapper<>();
  //通过id进行排序
  wrapper.orderByDesc("id");//降序
  List<User> users = userMapper.selectList(wrapper);
  users.forEach(System.out::println);
}

6.1、LambdaQueryWrapper

介绍：

上图绿色框为抽象类abstract
蓝色框为正常class类，可new对象
黄色箭头指向为父子类关系，箭头指向为父类

wapper介绍：

Wrapper ：条件构造抽象类，最顶端父类，抽象类中提供4个方法西面贴源码展示
AbstractWrapper ：用于查询条件封装，生成 sql 的 where 条件
AbstractLambdaWrapper ： Lambda 语法使用 Wrapper统一处理解析 lambda 获取 column。
LambdaQueryWrapper ：看名称也能明白就是用于Lambda语法使用的查询Wrapper
LambdaUpdateWrapper ： Lambda 更新封装Wrapper
QueryWrapper ： Entity 对象封装操作类，不是用lambda语法
UpdateWrapper ： Update 条件封装，用于Entity对象更新操作

1、 QueryWrapper使用方式

        QueryWrapper<User> wrapper = new QueryWrapper<User>()
                .eq(StringUtils.isNotBlank(user.getNickName()), "nick", user.getNickName())
                .eq(user.getId() != null,"id", user.getId());
        List<User> userList = userDao.selectList(wrapper);

2、 LambdaQueryWrapper 使用方式

 LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<User>()
                .eq(StringUtils.isNotBlank(user.getNickName()), User::getNickName, user.getNickName())
                .eq(user.getId() != null, User::getId, user.getId());
        List<User> userList = userDao.selectList(wrapper);

3、使用区别

QueryWrapper 的列名匹配使用的是 “数据库中的字段名(一般是下划线规则)”
LambdaQueryWrapper 的列名匹配使用的是“Lambda的语法，偏向于对象”

4 LambdaQueryWrapper的优势

不同写“列名”，而是使用纯java的方式，避免了拼写错误(LambdaQueryWrapper的写法如果有错，则在编译期就会报错，而QueryWrapper需要运行的时候调用该方法才会报错)

七、代码自动生成器

使用文档：https://baomidou.com/guide/generator.html#%E4%BD%BF%E7%94%A8%E6%95%99%E7%A8%8B

dao、pojo、service、controller都给我自己去编写完成！（当然还有数据库连接配置，依赖）

AutoGenerator 是 MyBatis-Plus 的代码生成器，通过 AutoGenerator 可以快速生成 Entity、Mapper、Mapper XML、Service、Controller 等各个模块的代码，极大的提升了开发效率。

测试：

public class Code {
    public static void main(String[] args) {
        //需要构建一个 代码自动生成器 对象
        // 代码生成器
        AutoGenerator mpg = new AutoGenerator();
        //配置策略

        //1、全局配置
        GlobalConfig gc = new GlobalConfig();
        String projectPath = System.getProperty("user.dir");//获取用户目录
        gc.setOutputDir(projectPath + "/src/main/java");//设置输出目录
        gc.setAuthor("wlw");//设置作者名
        gc.setOpen(false);
        gc.setFileOverride(false);  //是否覆盖原来生成的
        gc.setServiceName("%sService"); //去Service的I前缀
        gc.setIdType(IdType.ID_WORKER);//主键生成策略
        gc.setDateType(DateType.ONLY_DATE);
        gc.setSwagger2(true);
        mpg.setGlobalConfig(gc);

        //2、设置数据源
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://localhost:3306/mybatis-plus?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8");
        dsc.setDriverName("com.mysql.cj.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("12345678");
        dsc.setDbType(DbType.MYSQL);//数据库类型
        mpg.setDataSource(dsc);

        //3、包的配置
        PackageConfig pc = new PackageConfig();
        pc.setModuleName("blog"); //模块名
        pc.setParent("com.wlw");//这个包下面
        pc.setEntity("pojo");
        pc.setMapper("mapper");
        pc.setService("service");
        pc.setController("controller");
        mpg.setPackageInfo(pc);

        //4、策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setInclude("user");    //设置要映射的表名（自己数据库中的表）
        strategy.setNaming(NamingStrategy.underline_to_camel);
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
        strategy.setEntityLombokModel(true);    //自动lombok
        strategy.setLogicDeleteFieldName("deleted");//逻辑删除 字段名
        //自动填充配置
        TableFill createTime = new TableFill("create_time", FieldFill.INSERT);
        TableFill updateTime = new TableFill("update_time", FieldFill.UPDATE);
        ArrayList<TableFill> tableFills = new ArrayList<>();
        tableFills.add(createTime);
        tableFills.add(updateTime);
        strategy.setTableFillList(tableFills);
        //乐观锁
        strategy.setVersionFieldName("version");
        strategy.setRestControllerStyle(true);
        strategy.setControllerMappingHyphenStyle(true);     //localhost:8080/hello_id_2
        mpg.setStrategy(strategy);

        mpg.execute();  //执行代码构造器
    }
}