这一篇从一个入门的基本体验介绍，再到对于 CRUD 的一个详细介绍，在介绍过程中将涉及到的一些问题，例如逐渐策略，自动填充，乐观锁等内容说了一下，只选了一些重要的内容，还有一些没提及到，具体可以参考官网，简单的看完，其实会发现，如果遇到单表的 CRUD ，直接用 MP 肯定舒服，如果写多表，还是用 Mybatis 多点，毕竟直接写 SQL 会直观一点，MP 给我的感觉，就是方法封装了很多，还有一些算比较是用的插件，但是可读性会稍微差一点，不过个人有个人的看法哇，祝大家国庆快乐 ~

1. 引言

最初的 JDBC，我们需要写大量的代码来完成与基本的 CRUD ，或许会在一定程度上使用 Spring 的 JdbcTemplate 或者 Apache 的 DBUtils ，这样一些对 JDBC 的简单封装的工具类。

再到后再使用 Mybatis 等一些优秀的持久层框架，大大的简化了开发，我们只需要使用一定的 XML 或者注解就可以完成原来的工作

JDBC —> Mybatis 无疑简化了开发者的工作，而今天我们所讲额 MyBatis-Plus 就是在 MyBatis 的基础上，更加的简化开发，来一起看看吧！

2. 初识 MyBatis-Plus

下列介绍来自官网：

2.1 概述

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

我们的愿景是成为 MyBatis 最好的搭档，就像魂斗罗中的 1P、2P，基友搭配，效率翻倍。

总之一句话：MyBatis-Plus —— 为简化开发而生！

2.2 特性

无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
损耗小：启动即会自动注入基本 CRUD，性能基本无损耗，直接面向对象操作
强大的 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.3 支持数据库

mysql 、mariadb 、oracle 、db2 、h2 、hsql 、sqlite 、postgresql 、sqlserver 、presto 、Gauss 、Firebird
Phoenix 、clickhouse 、Sybase ASE 、 OceanBase 、达梦数据库、虚谷数据库、人大金仓数据库、南大通用数据库

3. 入门初体验

按照官网的案例简单试一下，注：官网是基于 Springboot 的示例

@Repository
public interface UserMapper extends BaseMapper<User> {
}

3.1 创建入门案例表

@Repository
public interface UserMapper extends BaseMapper<User> {

}

自行创建一个数据库即可，然后导入官网给出的案例表，然后插入如下数据

-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user`  (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
  `name` varchar(30) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '姓名',
  `age` int(11) NULL DEFAULT NULL COMMENT '年龄',
  `email` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '邮箱',
  PRIMARY KEY (`id`) USING BTREE
);

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

3.2 初始化 SpringBoot 项目

如果没有接触过 SpringBoot，使用常规的 SSM 也是可以的，为了演示方便，这里还是使用了SpringBoot，如果想在 SSM 中使用，一个注意依赖的修改，还一个就需要修改 xml 中的一些配置

3.2.1 引入依赖

引入 MyBatis-Plus-boot-starter 肯定是没什么疑问的，同样我们还需要引入，数据库连接的驱动依赖，还可以看需要引入 lombok，这里为了简便所以使用了它，如果不想使用，手动生成构造方法和 get set 即可

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

<!-- MyBatis-Plus -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.0</version>
</dependency>

<!-- lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>

3.2.2 配置数据库信息

如何进行数据库相关的信息在以前的SpringBoot文章已经说过了，这里强调一下:

mysql 5 驱动：com.mysql.jdbc.Driver

mysql 8 驱动：com.mysql.cj.jdbc.Driver 、还需要增加时区的配置

serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=root99
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

3.2.3 创建实体类

根据数据库字段创建出对应实体属性就行了，还是提一下：上方三个注解，主要是使用了 lombok 自动的生成那些 get set 等方法，不想用的同学直接自己按原来的方法显式的写出来就可以了~

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

3.2.4 创建Mapper接口

代码如下，可以看到，我们额外的继承了 BaseMapper，同时指定了泛型为 User

@Repository
public interface UserMapper extends BaseMapper<User> {

}

其实点进去 BaseMapper 看一下，你会发现，在其中已经定义了关于 CRUD 一些基本方法还有一些涉及到配合条件实现更复杂的操作，同时泛型中指定的实体，会在增删改查的方法中被调用

照这样说的话，好像啥东西都被写好了，如果现在想要进行一个简单的增删改查，是不是直接使用就行了

3.2.5 测试

首先在测试类中注入 UserMapper，这里演示一个查询所有的方法，所以使用了 selectList ，其参数是一个条件，这里先置为空。

如果有哪些方法的使用不明确，我们可以先点到 BaseMapper 中去看一下，down 下源码以后，会有一些注释说明

/**
 * 根据 entity 条件，查询全部记录
 *
 * @param queryWrapper 实体对象封装操作类（可以为 null）
 */
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

下面是测试查询所有的全代码

@SpringBootTest
class MybatisPlusApplicationTests {

    @Autowired
    private UserMapper userMapper;

    @Test
    void contextLoads() {
        List<User> userList = userMapper.selectList(null);
        for (User user : userList) {
            System.out.println(user);
        }
    }
}

3.2.6 结果

控制台输出如下

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)

经过一个简单的测试，感觉还是很香的，而以前在 Mybatis 中我们执行sql语句时，是可以看到控制台打印的日志的，而这里显然没有，其实通过一行简单的配置就可以了

3.2.7 开启日志

其实只需要在配置文件中加入短短的一行就可以了

MyBatis-Plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

打印如下：

当然你还可以通过一些 MyBatis Log 的插件，来快速的查看自己所执行的 sql

4. CRUD

4.1 插入操作

4.1.1 可用方法

首先，先试试插入一个实体的操作，我们选择使用了 insert 这个方法，下面是其定义：

/**
 * 插入一条记录
 *
 * @param entity 实体对象
 */
int insert(T entity);

4.1.2 演示

@Test
public void testInsert() {
    // 拟一个对象
    User user = new User();
    user.setName("理想二旬不止");
    user.setAge(30);
    user.setEmail("ideal_bwh@163.com");
    // 插入操作
    int count = userMapper.insert(user); 
    System.out.println(count);
    System.out.println(user);
}

结果：

根据结果看到，插入确实成功了，但是一个发蒙的问题出现了，为啥 id 变成了一个 long 类型的值

4.1.3 主键生成策略

对于主键的生成，官网有如下的一句话：

自3.3.0开始,默认使用雪花算法+UUID(不含中划线)

也就是说，因为上面我们没有做任何的处理，所以它使用了默认的算法来当做主键 id

4.1.3.1 雪花算法（snowflake）

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

雪花算法 + UUID 所以基本是可以保证唯一的

当然除了雪花算法为，我们还有一些别的主键生成的策略，例如 Redis、数据库自增

对于我们之前常用的一种主键生成方式，一般都会用到数据库id自增

4.1.4 设置主键自增

数据库主键字段设置自增！！！
主键实体类字段注解 @TableId(type = IdType.AUTO)

再次插入，发现 id 已经实现了自增

4.1.5 字段注解解释

@TableId 注解中的属性 Type 的值来自于 IdType 这个枚举类，其中我把每一项简单解释一下

AUTO(0) ：数据库 ID 自增（MySQL 正常，Oracle 未测试）
- 如果你想要全局都使用 AUTO 这样的数据库自增方式，可以直接在 application.properties 中添加
- MyBatis-Plus.global-config.db-config.id-type=auto
NONE(1) ：该类型为未设置主键类型(注解里等于跟随全局,全局里约等于 INPUT)
INPUT(2) ：用户输入 ID，也可以自定义输入策略，内置策略如下
- DB2KeyGenerator
- H2KeyGenerator
- KingbaseKeyGenerator
- OracleKeyGenerator
- PostgreKeyGenerator

使用时：
先添加 @Bean，然后实体类配置主键 Sequence，指定主键策略为 IdType.INPUT 即可，重点不说这个，有需要可以直接扒官网

@Bean
public IKeyGenerator keyGenerator() {
    return new H2KeyGenerator();
}

ASSIGN_ID(3) ：雪花算法
ASSIGN_UUID(4)：不含中划线的UUID

3.3.0 后，ID_WORKER(3)、ID_WORKER_STR(3)、UUID(4) 就已经被弃用了，前两个可以使用 ASSIGN_ID(3)代替，最后一个使用 ASSIGN_UUID(4)代替

4.2 更新操作

4.2.1 可用方法

// 根据 whereEntity 条件，更新记录
int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
// 根据 ID 修改
int updateById(@Param(Constants.ENTITY) T entity);

4.2.2 演示

MyBatis-Plus 中的更新操作也是非常方便

举一种比较常见的一种情况，通过 id 值修改某些字段

传统做法会传一个修改后的对象，然后通过 #{} 设置具体更新的值和 id

<update id="updateById">
    UPDATE user SET name=#{name}, portrait=#{portrait}, gender=#{gender}, telephone=#{telephone}, email=#{email} WHERE id=#{id}
</update>

MyBatis-Plus 方式：

@Test
public void testUpdate() {
    // 拟一个对象
    User user = new User();
    user.setId(1L);
    user.setName("理想二旬不止");
    user.setAge(20);
    int i = userMapper.updateById(user);
    System.out.println(i);
}

首先我们给定了 id 值，同时又修改了姓名和年龄这两个字段，但是并不是全部字段，来看一下执行效果

神奇的发现，我们不需要在 sql 中进行设置了，所有的配置都被自动做好了，更新的内容和 id 都被自动填充好了

4.2.3 自动填充

自动填充是填充什么内容呢？首先我们需要知道，一般来说表中的创建时间，修改时间，我们总是希望能够给根据插入或者修改的时间自动填充，而不需要我们手动的去更新

可能以前的项目不是特别综合或需要等原因，有时候也不会去设置创建时间等字段，写这部分是因为，在阿里巴巴的Java开发手册（第5章 MySQL 数据库 - 5.1 建表规约 - 第 9 条）有明确指出：

【强制】表必备三字段：id, create_time, update_time。

说明：其中 id 必为主键，类型为 bigint unsigned、单表时自增、步长为 1。create_time, update_time

的类型均为 datetime 类型，前者现在时表示主动式创建，后者过去分词表示被动式更新

4.2.3.1 数据库级别（不常用）

我们可以通过直接修改数据库中对应字段的默认值，来实现数据库级别的自动添加语句

例如上图中我首先添加了 create_time, update_time 两个字段，然后将类型选择为 datetime，又设置其默认值为 CURRENT_TIMESTAMP

注：更新时间字段中要勾选 On Update Current_Timestamp ，插入不用，使用 SQLYog 没问题，在 Navicat 某个版本下直接通过可视化操作可能会报错，没有此默认值，这种情况就把表先导出来，然后修改SQL，在SQL 中修改语句

create_time` datetime(0)  DEFAULT CURRENT_TIMESTAMP(0) COMMENT '创建时间',
update_time` datetime(0)  DEFAULT CURRENT_TIMESTAMP(0) COMMENT '修改时间',

4.2.3.2 代码级别

根据官网的自动填充功能的说明，其实我们需要做的只有两点：

为 create_time, update_time 两个字段配置注解
自定义实现类 MyMetaObjectHandler

注：开始前，别忘了删除刚才数据库级别测试时的字段默认值等喔

首先填充字段注解：

@TableField(fill = FieldFill.INSERT)

@TableField(fill = FieldFill.INSERT_UPDATE)

@TableField(fill = FieldFill.INSERT)
private Date createTime;

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

FieldFill 说明：

public enum FieldFill {
    /**
     * 默认不处理
     */
    DEFAULT,
    /**
     * 插入时填充字段
     */
    INSERT,
    /**
     * 更新时填充字段
     */
    UPDATE,
    /**
     * 插入和更新时填充字段
     */
    INSERT_UPDATE
}

接着创建自定义实现类 MyMetaObjectHandler，让其实现MetaObjectHandler，重写其 insertFill 和 updateFill 方法，打印日志就不说了，通过 setFieldValByName 就可以对字段进行赋值，源码中这个方法有三个参数

/**
 * 通用填充
 *
 * @param fieldName  java bean property name
 * @param fieldVal   java bean property value
 * @param metaObject meta object parameter
 */
default MetaObjectHandler setFieldValByName(String fieldName, Object fieldVal, MetaObject metaObject) {...}

fieldName：字段名
fieldVal：该字段赋予的值
metaObject：操作哪个数据

@Slf4j
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
    @Override
    public void insertFill(MetaObject metaObject) {
        log.info("start insert fill ....");
        setFieldValByName("createTime", new Date(), metaObject);
        setFieldValByName("updateTime", new Date(), metaObject);

    }

    @Override
    public void updateFill(MetaObject metaObject) {
        log.info("start update fill ....");
        setFieldValByName("updateTime", new Date(), metaObject);
    }
}

查看一下效果：

下面还有一些注意事项：

注意事项：

填充原理是直接给entity的属性设置值!!!
注解则是指定该属性在对应情况下必有值,如果无值则入库会是null
MetaObjectHandler提供的默认方法的策略均为:如果属性有值则不覆盖,如果填充值为null则不填充
字段必须声明TableField注解,属性fill选择对应策略,该声明告知MyBatis-Plus需要预留注入SQL字段
填充处理器MyMetaObjectHandler在 Spring Boot 中需要声明@Component或@Bean注入
要想根据注解FieldFill.xxx和字段名以及字段类型来区分必须使用父类的strictInsertFill或者strictUpdateFill方法
不需要根据任何来区分可以使用父类的fillStrategy方法

4.2.4

演示乐观锁插件前，首先补充一些基础概念：

4.2.4.1 没有锁会怎么样

打个比方，一张电影票价格为 30，老板告诉员工 A ，把价格上调到 50，员工 A 因为有事耽搁了两个小时，但是老板想了一会觉得提价太高了，就想着定价 40 好了，正好碰到员工 B，就让员工 B 将价格降低 10 块

当正好两个员工都在操作后台系统时，两人同时取出当前价格，即 30 元，员工A 先操作后价格变成了 50元，但是员工 B 又将30 - 10 ，即变成20块，执行了更新操作，此时员工 B 的更新操作就会把前面的 50 元覆盖掉，即最终成为了 20元，虽然我内心毫无波澜，但老板却亏的一匹

4.2.4.2 观锁和悲观锁

乐观锁：故名思意十分乐观，它总是认为不会出现问题，无论干什么不去上锁！如果出现了问题，
再次更新值测试
- 乐观锁下，员工 B 更新时会检查是否这个价格已经被别人修改过了，如果是就会取出新的值，再操作
悲观锁：故名思意十分悲观，它总是认为总是出现问题，无论干什么都会上锁！再去操作！
- 悲观锁下，员工 B 只能在员工 A 操作完以后才能操作，这样能保证数据只有一个人在操作

4.2.4.3 MP 中的乐观锁插件

意图：

当要更新一条记录的时候，希望这条记录没有被别人更新

乐观锁实现方式：

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

实现这个功能，只需要两步：

添加数据库version字段和实体字段以及注解

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

创建配置类，引入乐观锁插件

// 扫描 mapper 文件夹
@MapperScan("cn.ideal.mapper")
@EnableTransactionManagement
// 代表配置类
@Configuration 
public class MyBatisPlusConfig {
    // 乐观锁插件
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }
}

说明：刚开始例如扫描 mapper 这样的注解就放在了启动类中，现在有了配置类，所以把它也移过来了

测试一下：

首先1号和2号获取到的数据是一样的，但是在1号还没有执行到更新的时候，2号抢先提交了更新操作，也就是说，当前真实数据已经是被2号修改过的了，与1号前面获取到的不一致了

如果没有乐观锁，那么2号提交的更新会被1号的更新数据覆盖

// 测试更新
@Test
public void testUpdate() {
    // 1号取得了数据
    User user1 = userMapper.selectById(1L);
    user1.setName("乐观锁1号");
    user1.setAge(20);
    user1.setEmail("ideal_bwh@xxx.com");
    // 2号取得了数据
    User user2 = userMapper.selectById(1L);
    user2.setName("乐观锁2号");
    user2.setAge(30);
    user2.setEmail("ideal@xxx.com");
    // 2号提交更新
     userMapper.updateById(user2);
    // 1号提交更新
    userMapper.updateById(user1);
}

可以看到，在2号抢先执行后，1号就没有成功执行了

同样数据库中表的其 version 也从1变成了1

4.3 查询操作

4.3.1 可用方法

// 根据 ID 查询
T selectById(Serializable id);
// 根据 entity 条件，查询一条记录
T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

// 查询（根据ID 批量查询）
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
// 根据 entity 条件，查询全部记录
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 查询（根据 columnMap 条件）
List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
// 根据 Wrapper 条件，查询全部记录
List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录。注意： 只返回第一个字段的值
List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

// 根据 entity 条件，查询全部记录（并翻页）
IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录（并翻页）
IPage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询总记录数
Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

4.3.2 简单查询

4.3.2.1 根据 id 查询

@Test
public void testSelectById(){
    User user = userMapper.selectById(1L);
    System.out.println(user);
}

4.3.2.2 根据 id 集合查询

说明：我这里使用的还是最基本的写法，例如 List 可以用工具类创建如：Arrays.asList(1, 2, 3)

遍历也完全可以这样 users.forEach(System.out::println);

@Test
public void testSelectByBatchId(){
    List list = new ArrayList();
    list.add(1);
    list.add(2);
    list.add(3);
    List<User> users = userMapper.selectBatchIds(list);
    for (User user : users){
        System.out.println(user);
    }
}

4.3.2.3 根据 map 查询

@Test
public void testSelectByMap(){
    HashMap<String, Object> map = new HashMap<>();
    // 自定义要查询的字段和值
    map.put("name","理想二旬不止");
    map.put("age",30);

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

通过日志的打印可以看到，它根据我们的选择自动拼出了 SQL 的条件

==>  Preparing: SELECT id,name,age,email,version,create_time,update_time FROM user WHERE name = ? AND age = ?
==> Parameters: 理想二旬不止(String), 30(Integer)

4.3.3 分页查询

JavaWeb 阶段，大家都应该有手写过分页，配合 SQL 的 limit 进行分页，后面在 Mybatis 就会用一些例如 pageHelper 的插件，而 MyBatis-Plus 中也有一个内置的分页插件

使用前只需要进行一个小小的配置，在刚才配置类中，加入分页插件的配置代码

// 扫描我们的mapper 文件夹
@MapperScan("cn.ideal.mapper")
@EnableTransactionManagement
@Configuration // 配置类

public class MyBatisPlusConfig {

    // 乐观锁插件
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }

    // 分页插件
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }

}

接着就可以测试分页了

@Test
public void testPage(){
    // Page 参数： 参数1：当前页 ，参数1：页面大小
    Page<User> page = new Page<>(2,3);
    userMapper.selectPage(page,null);

    List<User> users = page.getRecords();
    for (User user : users){
        System.out.println(user);
    }
    System.out.println(page.getTotal());
}

执行结果日志：

==>  Preparing: SELECT id,name,age,email,version,create_time,update_time FROM user LIMIT ?,?
==> Parameters: 3(Long), 3(Long)
<==    Columns: id, name, age, email, version, create_time, update_time
<==        Row: 4, Sandy, 21, test4@baomidou.com, 1, null, null
<==        Row: 5, Billie, 24, test5@baomidou.com, 1, null, null
<==        Row: 1308952901602811906, 理想二旬不止, 30, ideal_bwh@163.com, 1, null, null
<==      Total: 3

4.3.4 条件查询 ※

如何实现一些条件相对复杂的查询呢？MyBatis-Plus 也给我们提供了一些用法，帮助我们方便的构造各种条件

其实前面大家应该就注意到了，在查询操作的可用方法中，参数中往往带有一个名叫 Wrapper<T> queryWrapper 的内容，这就是我们要构造条件的重点

查询中最常用的就是 QueryWrapper

说明:

继承自 AbstractWrapper ,自身的内部属性 entity 也用于生成 where 条件
及 LambdaQueryWrapper, 可以通过 new QueryWrapper().lambda() 方法获取

实例化一个 QueryWrapper 后，通过调用一些内置的方法，就可以实现条件构造

4.3.4.1 如何使用

例如我们想要构造这样一个条件：查询邮箱不为空，且年龄小于 25 岁的用户

@Test
void contextLoads() {
    // 实例化一个 QueryWrapper 对象
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    // 进行具体条件构造
    wrapper
            .isNotNull("email")
            .lt("age", 25);
    // 执行具体的查询方法，同时将 wrapper 条件作为参数传入
    List<User> users = userMapper.selectList(wrapper);
    for (User user : users){
        System.out.println(user);
    }
}

看一下打印的日志：

==>  Preparing: SELECT id,name,age,email,version,deleted,create_time,update_time FROM user WHERE deleted=0 AND (email IS NOT NULL AND age < ?)
==> Parameters: 25(Integer)
<==    Columns: id, name, age, email, version, deleted, create_time, update_time
<==        Row: 2, 理想, 22, ideal_bwh@xxx.com, 1, 0, 2020-09-26 15:06:09, 2020-09-26 21:21:52
<==        Row: 4, Sandy, 21, test4@baomidou.com, 1, 0, null, null
<==        Row: 5, Billie, 24, test5@baomidou.com, 1, 0, null, null
<==      Total: 3

可以看到条件都被自动在 SQL 中构造出来了

使用的方式就这么简单，通过各种巧妙的构造就好了

4.3.4.2 构造方式

下面是从官网摘取的各种构造方式：

allEq

allEq(Map<R, V> params)
allEq(Map<R, V> params, boolean null2IsNull)
allEq(boolean condition, Map<R, V> params, boolean null2IsNull)

全部eq(或个别isNull)

个别参数说明:

params : key为数据库字段名,value为字段值
null2IsNull : 为true则在map的value为null时调用 isNull 方法,为false时则忽略value为null的

例1: allEq({id:1,name:"老王",age:null})—->id = 1 and name = '老王' and age is null
例2: allEq({id:1,name:"老王",age:null}, false)—->id = 1 and name = '老王'

allEq(BiPredicate<R, V> filter, Map<R, V> params)
allEq(BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull)
allEq(boolean condition, BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull)

个别参数说明:

filter : 过滤函数,是否允许字段传入比对条件中
params 与 null2IsNull : 同上

例1: allEq((k,v) -> k.indexOf("a") >= 0, {id:1,name:"老王",age:null})—->name = '老王' and age is null
例2: allEq((k,v) -> k.indexOf("a") >= 0, {id:1,name:"老王",age:null}, false)—->name = '老王'

eq

eq(R column, Object val)
eq(boolean condition, R column, Object val)

等于 =
例: eq("name", "老王")—->name = '老王'

ne

ne(R column, Object val)
ne(boolean condition, R column, Object val)

不等于 <>
例: ne("name", "老王")—->name <> '老王'

gt

gt(R column, Object val)
gt(boolean condition, R column, Object val)

大于 >
例: gt("age", 18)—->age > 18

ge

ge(R column, Object val)
ge(boolean condition, R column, Object val)

大于等于 >=
例: ge("age", 18)—->age >= 18

lt

lt(R column, Object val)
lt(boolean condition, R column, Object val)

小于 <
例: lt("age", 18)—->age < 18

le

le(R column, Object val)
le(boolean condition, R column, Object val)

小于等于 <=
例: le("age", 18)—->age <= 18

between

between(R column, Object val1, Object val2)
between(boolean condition, R column, Object val1, Object val2)

BETWEEN 值1 AND 值2
例: between("age", 18, 30)—->age between 18 and 30

notBetween

notBetween(R column, Object val1, Object val2)
notBetween(boolean condition, R column, Object val1, Object val2)

NOT BETWEEN 值1 AND 值2
例: notBetween("age", 18, 30)—->age not between 18 and 30

like

like(R column, Object val)
like(boolean condition, R column, Object val)

LIKE ‘%值%’
例: like("name", "王")—->name like '%王%'

notLike

notLike(R column, Object val)
notLike(boolean condition, R column, Object val)

NOT LIKE ‘%值%’
例: notLike("name", "王")—->name not like '%王%'

likeLeft

likeLeft(R column, Object val)
likeLeft(boolean condition, R column, Object val)

LIKE ‘%值’
例: likeLeft("name", "王")—->name like '%王'

likeRight

likeRight(R column, Object val)
likeRight(boolean condition, R column, Object val)

LIKE ‘值%’
例: likeRight("name", "王")—->name like '王%'

isNull

isNull(R column)
isNull(boolean condition, R column)

字段 IS NULL
例: isNull("name")—->name is null

isNotNull

isNotNull(R column)
isNotNull(boolean condition, R column)

字段 IS NOT NULL
例: isNotNull("name")—->name is not null

in

in(R column, Collection<?> value)
in(boolean condition, R column, Collection<?> value)

字段 IN (value.get(0), value.get(1), …)
例: in("age",{1,2,3})—->age in (1,2,3)

in(R column, Object... values)
in(boolean condition, R column, Object... values)

字段 IN (v0, v1, …)
例: in("age", 1, 2, 3)—->age in (1,2,3)

notIn

notIn(R column, Collection<?> value)
notIn(boolean condition, R column, Collection<?> value)

字段 NOT IN (value.get(0), value.get(1), …)
例: notIn("age",{1,2,3})—->age not in (1,2,3)

notIn(R column, Object... values)
notIn(boolean condition, R column, Object... values)

字段 NOT IN (v0, v1, …)
例: notIn("age", 1, 2, 3)—->age not in (1,2,3)

inSql

inSql(R column, String inValue)
inSql(boolean condition, R column, String inValue)

字段 IN ( sql语句 )
例: inSql("age", "1,2,3,4,5,6")—->age in (1,2,3,4,5,6)
例: inSql("id", "select id from table where id < 3")—->id in (select id from table where id < 3)

notInSql

notInSql(R column, String inValue)
notInSql(boolean condition, R column, String inValue)

字段 NOT IN ( sql语句 )
例: notInSql("age", "1,2,3,4,5,6")—->age not in (1,2,3,4,5,6)
例: notInSql("id", "select id from table where id < 3")—->id not in (select id from table where id < 3)

groupBy

groupBy(R... columns)
groupBy(boolean condition, R... columns)

分组：GROUP BY 字段, …
例: groupBy("id", "name")—->group by id,name

orderByAsc

orderByAsc(R... columns)
orderByAsc(boolean condition, R... columns)

排序：ORDER BY 字段, … ASC
例: orderByAsc("id", "name")—->order by id ASC,name ASC

orderByDesc

orderByDesc(R... columns)
orderByDesc(boolean condition, R... columns)

排序：ORDER BY 字段, … DESC
例: orderByDesc("id", "name")—->order by id DESC,name DESC

orderBy

orderBy(boolean condition, boolean isAsc, R... columns)

排序：ORDER BY 字段, …
例: orderBy(true, true, "id", "name")—->order by id ASC,name ASC

having

having(String sqlHaving, Object... params)
having(boolean condition, String sqlHaving, Object... params)

HAVING ( sql语句 )
例: having("sum(age) > 10")—->having sum(age) > 10
例: having("sum(age) > {0}", 11)—->having sum(age) > 11

func

func(Consumer<Children> consumer)
func(boolean condition, Consumer<Children> consumer)

func 方法(主要方便在出现if…else下调用不同方法能不断链)
例: func(i -> if(true) {i.eq("id", 1)} else {i.ne("id", 1)})

or

or()
or(boolean condition)

拼接 OR

注意事项:

主动调用or表示紧接着下一个方法不是用and连接!(不调用or则默认为使用and连接)

例: eq("id",1).or().eq("name","老王")—->id = 1 or name = '老王'

or(Consumer<Param> consumer)
or(boolean condition, Consumer<Param> consumer)

OR 嵌套
例: or(i -> i.eq("name", "李白").ne("status", "活着"))—->or (name = '李白' and status <> '活着')

and

and(Consumer<Param> consumer)
and(boolean condition, Consumer<Param> consumer)

AND 嵌套
例: and(i -> i.eq("name", "李白").ne("status", "活着"))—->and (name = '李白' and status <> '活着')

nested

nested(Consumer<Param> consumer)
nested(boolean condition, Consumer<Param> consumer)

正常嵌套不带 AND 或者 OR
例: nested(i -> i.eq("name", "李白").ne("status", "活着"))—->(name = '李白' and status <> '活着')

apply

apply(String applySql, Object... params)
apply(boolean condition, String applySql, Object... params)

拼接 sql

注意事项:

该方法可用于数据库函数动态入参的params对应前面applySql内部的{index}部分.这样是不会有sql注入风险的,反之会有!

例: apply("id = 1")—->id = 1
例: apply("date_format(dateColumn,'%Y-%m-%d') = '2008-08-08'")—->date_format(dateColumn,'%Y-%m-%d') = '2008-08-08'")
例: apply("date_format(dateColumn,'%Y-%m-%d') = {0}", "2008-08-08")—->date_format(dateColumn,'%Y-%m-%d') = '2008-08-08'")

last

last(String lastSql)
last(boolean condition, String lastSql)

无视优化规则直接拼接到 sql 的最后

注意事项:

只能调用一次,多次调用以最后一次为准有sql注入的风险,请谨慎使用

例: last("limit 1")

exists

exists(String existsSql)
exists(boolean condition, String existsSql)

拼接 EXISTS ( sql语句 )
例: exists("select id from table where age = 1")—->exists (select id from table where age = 1)

notExists

notExists(String notExistsSql)
notExists(boolean condition, String notExistsSql)

拼接 NOT EXISTS ( sql语句 )
例: notExists("select id from table where age = 1")—->not exists (select id from table where age = 1)

4.4 删除操作

4.4.1 可用方法

// 根据 entity 条件，删除记录
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
// 删除（根据ID 批量删除）
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
// 根据 ID 删除
int deleteById(Serializable id);
// 根据 columnMap 条件，删除记录
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

4.4.2 简单删除

4.4.2.1 根据 id 删除

@Test
public void testDeleteById(){
    userMapper.deleteById(1L);
}

4.4.2.2 根据 id 集合删除

@Test
public void testDeleteBatchIds(){
    List list = new ArrayList();
    list.add(1308952901602811906L);
    list.add(1308952901602811907L);
    list.add(1308952901602811908L);
    list.add(1308952901602811909L);
    userMapper.deleteBatchIds(list);
}

4.4.2.3 根据 map 删除

 @Test
public void testDeleteMap(){
    HashMap<String, Object> map = new HashMap<>();
    map.put("name","理想二旬不止");
    userMapper.deleteByMap(map);
}

4.4.3 逻辑删除

删除这块再补充一下逻辑删除的概念，物理删除很好理解，就是实实在在的在数据库中删没了，但是逻辑删除，顾名思义只是逻辑上被删除了，实际上并没有，只是通过增加一个字段让其失效而已，例如 deleted = 0 => deleted = 1

可以

应用的场景就是管理员想查看删除记录，在错误删除下，可以有逆转的机会等等

首先数据库增加 deleted 字段，同时创建其实体和注解

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

接着只需要在全局配置中配置即可

application.properties

# 配置逻辑删除
MyBatis-Plus.global-config.db-config.logic-delete-value=1
MyBatis-Plus.global-config.db-config.logic-not-delete-value=0

application.yml

MyBatis-Plus:
  global-config:
    db-config:
      logic-delete-field: flag  # 全局逻辑删除的实体字段名(since 3.3.0,配置后可以忽略不配置步骤2)
      logic-delete-value: 1 # 逻辑已删除值(默认为 1)
      logic-not-delete-value: 0 # 逻辑未删除值(默认为 0)

效果如下：

你会发现，逻辑删除会走一个更新操作，通过修改指定字段 deleted 的值为 0 实现我们想要的效果

5. 代码自动生成器

MyBatis-Plus 提供了一个非常便捷，有意思的内容，那就是代码的自动生成，我们通过一些配置，就可以自动的生成 controller、service、mapper、pojo 的内容，并且接口或者注解等内容都会按照配置指定的格式生成。（提前准备好数据库和表）

首先除了 MyBatis-Plus 的依赖以外，还需要引入 swagger 和 velocity 的依赖，但是这两者其实是可选的，可以选择不配置就不用引入了，默认使用 velocity 这个模板引擎，大家还可以换成别的

<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-engine-core</artifactId>
    <version>2.0</version>
</dependency>

<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>2.9.2</version>
</dependency>

<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
    <version>2.9.2</version>
</dependency>

例如：

Velocity（默认）：

<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-engine-core</artifactId>
    <version>latest-velocity-version</version>
</dependency>

Freemarker：

<dependency>
    <groupId>org.freemarker</groupId>
    <artifactId>freemarker</artifactId>
    <version>latest-freemarker-version</version>
</dependency>

Beetl：

<dependency>
    <groupId>com.ibeetl</groupId>
    <artifactId>beetl</artifactId>
    <version>latest-beetl-version</version>
</dependency>

注意！如果您选择了非默认引擎，需要在 AutoGenerator 中设置模板引擎。
```java AutoGenerator generator = new AutoGenerator();

// set freemarker engine generator.setTemplateEngine(new FreemarkerTemplateEngine());

// set beetl engine generator.setTemplateEngine(new BeetlTemplateEngine());

// set custom engine (reference class is your custom engine class) generator.setTemplateEngine(new CustomTemplateEngine());

// other config …


下面就是一个主配置了，修改其中的数据库连接等信息，以及包的名称等等等执行就可以了

```java
package cn.ideal;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.GlobalConfig;
import com.baomidou.mybatisplus.generator.config.PackageConfig;
import com.baomidou.mybatisplus.generator.config.StrategyConfig;
import com.baomidou.mybatisplus.generator.config.po.TableFill;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;

import java.util.ArrayList;


/**
 * @ClassName: AutomaticCodeGenerate
 * @Description: TODO
 * @Author: BWH_Steven
 * @Date: 2020/10/2 21:29
 * @Version: 1.0
 */
public class AutomaticCodeGenerate {
    public static void main(String[] args) {
        // 需要构建一个代码自动生成器对象
        AutoGenerator mpg = new AutoGenerator();
        // 配置策略
        // 全局配置
        GlobalConfig gc = new GlobalConfig();
        String projectPath = System.getProperty("user.dir");
        gc.setAuthor("BWH_Steven");
        gc.setOutputDir(projectPath + "/src/main/java");
        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);
        // 设置数据源
        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("root99");
        dsc.setDbType(DbType.MYSQL);
        mpg.setDataSource(dsc);
        // 包的配置
        PackageConfig pc = new PackageConfig();
        pc.setModuleName("test");
        pc.setParent("cn.ideal");
        pc.setEntity("entity");
        pc.setMapper("mapper");
        pc.setService("service");
        pc.setController("controller");
        mpg.setPackageInfo(pc);
        // 策略配置
        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 gmtCreate = new TableFill("create_time", FieldFill.INSERT);
        TableFill gmtModified = new TableFill("update_time", FieldFill.INSERT_UPDATE);
        ArrayList<TableFill> tableFills = new ArrayList<>();
        tableFills.add(gmtCreate);
        tableFills.add(gmtModified);
        strategy.setTableFillList(tableFills); // 乐观锁
        strategy.setVersionFieldName("version");
        strategy.setRestControllerStyle(true);
        strategy.setControllerMappingHyphenStyle(true);
        mpg.setStrategy(strategy);
        mpg.execute(); //执行
    }
}

生成结构效果如下：

我简单贴两段生成的内容：

controller

package cn.ideal.test.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * <p>
 *  前端控制器
 * </p>
 *
 * @author BWH_Steven
 * @since 2020-10-02
 */
@RestController
@RequestMapping("/test/user")
public class UserController {

}

entity

package cn.ideal.test.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.Version;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableField;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;

/**
 * <p>
 * 
 * </p>
 *
 * @author BWH_Steven
 * @since 2020-10-02
 */
@Data
@EqualsAndHashCode(callSuper = false)
@ApiModel(value="User对象", description="")
public class User implements Serializable {

    private static final long serialVersionUID = 1L;

    @ApiModelProperty(value = "主键ID")
      @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    @ApiModelProperty(value = "姓名")
    private String name;

    @ApiModelProperty(value = "年龄")
    private Integer age;

    @ApiModelProperty(value = "邮箱")
    private String email;

    @ApiModelProperty(value = "版本")
    @Version
    private Integer version;

    @TableLogic
    private Integer deleted;

    @ApiModelProperty(value = "创建时间")
      @TableField(fill = FieldFill.INSERT)
    private Date createTime;

    @ApiModelProperty(value = "修改时间")
      @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;


}

service

package cn.ideal.test.service;

import cn.ideal.test.entity.User;
import com.baomidou.mybatisplus.extension.service.IService;

/**
 * <p>
 *  服务类
 * </p>
 *
 * @author BWH_Steven
 * @since 2020-10-02
 */
public interface UserService extends IService<User> {

}

service 实现类

package cn.ideal.test.service.impl;

import cn.ideal.test.entity.User;
import cn.ideal.test.mapper.UserMapper;
import cn.ideal.test.service.UserService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author BWH_Steven
 * @since 2020-10-02
 */
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {

}

mapper

package cn.ideal.test.mapper;

import cn.ideal.test.entity.User;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

/**
 * <p>
 *  Mapper 接口
 * </p>
 *
 * @author BWH_Steven
 * @since 2020-10-02
 */
public interface UserMapper extends BaseMapper<User> {

}

mapper XML

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.ideal.test.mapper.UserMapper">

</mapper>

1. MyBatis进阶！Mybatis-Plus

1. 引言

2. 初识 MyBatis-Plus

2.1 概述

2.2 特性

2.3 支持数据库

3. 入门初体验

3.1 创建入门案例表

3.2 初始化 SpringBoot 项目

3.2.1 引入依赖

3.2.2 配置数据库信息

3.2.3 创建实体类

3.2.4 创建Mapper接口

3.2.5 测试

3.2.6 结果

3.2.7 开启日志

4. CRUD

4.1 插入操作

4.1.1 可用方法

4.1.2 演示

4.1.3 主键生成策略

4.1.3.1 雪花算法（snowflake）

4.1.4 设置主键自增

4.1.5 字段注解解释

4.2 更新操作

4.2.1 可用方法

4.2.2 演示

4.2.3 自动填充

4.2.3.1 数据库级别（不常用）

4.2.3.2 代码级别

4.2.4

4.2.4.1 没有锁会怎么样

4.2.4.2 观锁和悲观锁

4.2.4.3 MP 中的乐观锁插件

4.3 查询操作

4.3.1 可用方法

4.3.2 简单查询

4.3.2.1 根据 id 查询

4.3.2.2 根据 id 集合查询

4.3.2.3 根据 map 查询

4.3.3 分页查询

4.3.4 条件查询 ※

4.3.4.1 如何使用

4.3.4.2 构造方式

allEq

eq

ne

gt

ge

lt

le

between

notBetween

like

notLike

likeLeft

likeRight

isNull

isNotNull

in

notIn

inSql

notInSql

groupBy

orderByAsc

orderByDesc

orderBy

having

or

and

nested

apply

last

exists

notExists

4.4 删除操作

4.4.1 可用方法

4.4.2 简单删除

4.4.2.1 根据 id 删除

4.4.2.2 根据 id 集合删除