一、MyBatis-Plus官方介绍

1.简介

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

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

2.特性

• 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
• 损耗小：启动即会自动注入基本 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 操作智能分析阻断，也可自定义拦截规则，预防误操作

3.支持数据库

任何能使用 MyBatis 进行 CRUD, 并且支持标准 SQL 的数据库，具体支持情况如下，如果不在下列表查看分页部分教程 PR 您的支持。

• MySQL，Oracle，DB2，H2，HSQL，SQLite，PostgreSQL，SQLServer，Phoenix，Gauss ，ClickHouse，Sybase，OceanBase，Firebird，Cubrid，Goldilocks，csiidb
• 达梦数据库，虚谷数据库，人大金仓数据库，南大通用(华库)数据库，南大通用数据库，神通数据库，瀚高数据库

4.框架结构

个人理解
右边部分：启动器、注解、扩展、核心、代码生成
左边部分：扫描实体类，通过反射将实体中的属性进行抽取，接着分析当前的表和实体类之间的关系，再接着分析通过反射抽取出来的属性与字段之间的关系，再根据我们所调用的方法（通用Mapper或者Service方法）动态生成CRUD的SQL注入到mybatis容器中去

5.官方地址

官方网站：https://baomidou.com/

官方文档：https://baomidou.com/pages/24112f/

二、入门案例

1.开发环境

• IDE：IDEA 2021.3.3
• JDK：JDK8+
• 构建工具：Maven 3.5.2
• MySQL：MySQL 8.0.27
• Navicat：Navicat Premium 15
• Spring Boot：2.7.2
• MyBatis-Plus：3.5.1

2.建库建表

• 打开Navicat运行以下SQL脚本进行建库建表

CREATE DATABASE `mybatis_plus` /*!40100 DEFAULT CHARACTER SET utf8mb4 */; 
use `mybatis_plus`; 
CREATE TABLE `user` ( 
    `id` bigint(20) NOT NULL COMMENT '主键ID', 
    `name` varchar(30) DEFAULT NULL COMMENT '姓名', 
    `age` int(11) DEFAULT NULL COMMENT '年龄', 
    `email` varchar(50) DEFAULT NULL COMMENT '邮箱', 
    PRIMARY KEY (`id`) 
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
1
2
3
4
5
6
7
8
9

• 插入几条测试数据

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');
1
2
3
4
5
6

3.创建工程

• 使用**Spring Initializer**快速初始化一个 Spring Boot 工程

• 引入lombok和MySQL的依赖

• 引入MyBatis-Plus的依赖

<dependency>
    <groupId>com.baomidougroupId>
    <artifactId>mybatis-plus-boot-starterartifactId>
    <version>3.5.1version>
dependency>
1
2
3
4
5

• 安装Lombok插件

4.配置编码

• 配置application.yml文件

#配置端口
server:
  port: 80

spring:
  #配置数据源
  datasource:
    #配置数据源类型
    type: com.zaxxer.hikari.HikariDataSource
    #配置连接数据库的信息
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mybatis_plus?characterEncoding=utf-8&useSSL=false
    username: root
    password: 123456

#MyBatis-Plus相关配置
mybatis-plus:
  configuration:
    #配置日志
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

• 在 Spring Boot 启动类中添加 @MapperScan 注解，扫描 Mapper包

@SpringBootApplication
@MapperScan("指定Mapper接口所在的包")
public class MybatisPlusDemoApplication {
	public static void main(String[] args) {
		SpringApplication.run(MybatisPlusDemoApplication.class, args);
	}
}
1
2
3
4
5
6
7

• 编写实体类 User（此处使用了 Lombok 简化代码）

@Data
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;
}
1
2
3
4
5
6
7

• **编写 Mapper 包下的 **UserMapper接口

public interface UserMapper extends BaseMapper<User> {}
1

5.测试查询

• 编写一个测试类MyBatisPlusTest.java

@SpringBootTest
public class MyBatisPlusTest {
    @Resource
    private UserMapper userMapper;

    /**
     * 测试查询所有数据
     */
    @Test
    void testSelectList(){
        //通过条件构造器查询一个list集合，若没有条件，则可以设置null为参数
        List<User> users = userMapper.selectList(null);
        users.forEach(System.out::println);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 控制台打印查询结果
  

三、增删改查

1.BaseMapper

说明:

• 通用 CRUD 封装BaseMapper 接口，为 Mybatis-Plus 启动时自动解析实体表关系映射转换为 Mybatis 内部对象注入容器
• 泛型 T 为任意实体对象
• 参数 Serializable 为任意类型主键 Mybatis-Plus 不推荐使用复合主键约定每一张表都有自己的唯一 id 主键
• 对象 Wrapper 为条件构造器

MyBatis-Plus中的基本CRUD在内置的BaseMapper中都已得到了实现，因此我们继承该接口以后可以直接使用。

本次演示的CRUD操作不包含参数带有条件构造器的方法，关于条件构造器将单独在一个章节进行演示。

---

BaseMapper中提供的CRUD方法：

• 增加：Insert

// 插入一条记录
int insert(T entity);
1
2

• 删除：Delete

// 根据 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);
1
2
3
4
5
6
7
8

• 修改：Update

// 根据 whereWrapper 条件，更新记录
int update(@Param(Constants.ENTITY) T updateEntity, @Param(Constants.WRAPPER) Wrapper<T> whereWrapper);
// 根据 ID 修改
int updateById(@Param(Constants.ENTITY) T entity);
1
2
3
4

• 查询：Selete

// 根据 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);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2.调用Mapper层实现CRUD

2.1 插入

---

最终执行的结果，所获取的id为1527206783590903810

这是因为MyBatis-Plus在实现插入数据时，会默认基于雪花算法的策略生成id

/**
  * 测试插入一条数据
  * MyBatis-Plus在实现插入数据时，会默认基于雪花算法的策略生成id
  */
@Test
public void testInsert(){
    User user = new User();
    user.setName("Vz");
    user.setAge(21);
    user.setEmail("vz@oz6.cn");
    int result = userMapper.insert(user);
    System.out.println(result > 0 ? "添加成功！" : "添加失败！");
    System.out.println("受影响的行数为：" + result);
    //1527206783590903810（当前 id 为雪花算法自动生成的id）
    System.out.println("id自动获取" + user.getId());
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2.2 删除

---

a、根据ID删除数据

调用方法：int deleteById(Serializable id);

/**
  * 测试根据id删除一条数据
  */
@Test
public void testDeleteById(){
    int result = userMapper.deleteById(1527206783590903810L);
    System.out.println(result > 0 ? "删除成功！" : "删除失败！");
    System.out.println("受影响的行数为：" + result);
}
1
2
3
4
5
6
7
8
9

b、根据ID批量删除数据

**调用方法：int deleteBatchIds(@Param(Constants.COLLECTION) Collection idList); **

/**
  * 测试通过id批量删除数据
  */
@Test
public void testDeleteBatchIds(){
    List<Long> ids = Arrays.asList(6L,7L,8L);
    int result = userMapper.deleteBatchIds(ids);
    System.out.println(result > 0 ? "删除成功！" : "删除失败！");
    System.out.println("受影响的行数为：" + result);
}
1
2
3
4
5
6
7
8
9
10

c、根据Map条件删除数据

**调用方法：int deleteByMap(@Param(Constants.COLUMN_MAP) Map columnMap); **

/**
   * 测试根据Map集合中所设置的条件删除数据
   */
@Test
public void testDeleteByMap(){
    //当前演示为根据name和age删除数据
    //执行SQL为：DELETE FROM user WHERE name = ? AND age = ?
    Map<String,Object> map = new HashMap<>();
    map.put("name","张三");
    map.put("age",23);
    int result = userMapper.deleteByMap(map);
    System.out.println(result > 0 ? "删除成功！" : "删除失败！");
    System.out.println("受影响的行数为：" + result);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.3 修改

**调用方法：int updateById(@Param(Constants.ENTITY) T entity); **

/**
  * 测试根据id修改用户信息
  */
@Test
public void testUpdateById(){
    //执行SQL为： UPDATE user SET name=?, age=?, email=? WHERE id=?
    User user = new User();
    user.setId(6L);
    user.setName("张三");
    user.setAge(22);
    user.setEmail("zhangsan@163.com.com");
    int result = userMapper.updateById(user);
    System.out.println(result > 0 ? "修改成功！" : "修改失败！");
    System.out.println("受影响的行数为：" + result);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.4 查询

---

a、根据ID查询用户信息

调用方法：T selectById(Serializable id);

/**
  * 测试根据id查询用户数据
  */
@Test
public void testSelectById(){
    User user = userMapper.selectById(1L);
    System.out.println(user);
}
1
2
3
4
5
6
7
8

b、根据多个ID查询多个用户信息

**调用方法：List selectBatchIds(@Param(Constants.COLLECTION) Collection idList); **

/**
  * 根据多个id查询用户数据
  */
@Test
public void testSelectBatchIds(){
    //执行SQL为：SELECT id,name,age,email FROM user WHERE id IN ( ? , ? , ? )
    List<Long> ids = Arrays.asList(1L,2L,3L);
    List<User> users = userMapper.selectBatchIds(ids);
    users.forEach(System.out::println);
}
1
2
3
4
5
6
7
8
9
10

c、根据Map条件查询用户信息

**调用方法：List selectByMap(@Param(Constants.COLUMN_MAP) Map columnMap); **

/**
  * 根据Map所设置的条件查询用户
  */
@Test
public void testSelectByMap(){
    //执行SQL为：SELECT id,name,age,email FROM user WHERE age = ?
    Map<String,Object> map = new HashMap<>();
    map.put("age",18);
    List<User> users = userMapper.selectByMap(map);
    users.forEach(System.out::println);
}
1
2
3
4
5
6
7
8
9
10
11

d、查询所有用户信息

调用方法：List selectList(@Param(Constants.WRAPPER) Wrapper queryWrapper);

/**
  * 测试查询所有数据
  */
@Test
void testSelectList(){
    List<User> users = userMapper.selectList(null);
    users.forEach(System.out::println);
}
1
2
3
4
5
6
7
8

3.通用Service

说明:

• 通用 Service CRUD 封装IService接口，进一步封装 CRUD 采用 get 查询单行 remove 删除 list 查询集合 page 分页 前缀命名方式区分 Mapper 层避免混淆，
• 泛型 T 为任意实体对象
• 建议如果存在自定义通用 Service 方法的可能，请创建自己的 IBaseService 继承 Mybatis-Plus 提供的基类
• 对象 Wrapper 为 条件构造器

MyBatis-Plus中有一个接口 IService和其实现类 ServiceImpl，封装了常见的业务层逻辑，详情查看源码IService和ServiceImpl

因此我们在使用的时候仅需在自己定义的Service接口中继承IService接口，在自己的实现类中实现自己的Service并继承ServiceImpl即可

---

IService中的CRUD方法

• 增加：Save、SaveOrUpdate

// 插入一条记录（选择字段，策略插入）
boolean save(T entity);
// 插入（批量）
boolean saveBatch(Collection<T> entityList);
// 插入（批量）
boolean saveBatch(Collection<T> entityList, int batchSize);

// TableId 注解存在更新记录，否插入一条记录
boolean saveOrUpdate(T entity);
// 根据updateWrapper尝试更新，否继续执行saveOrUpdate(T)方法
boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 删除：Remove

// 根据 entity 条件，删除记录
boolean remove(Wrapper<T> queryWrapper);
// 根据 ID 删除
boolean removeById(Serializable id);
// 根据 columnMap 条件，删除记录
boolean removeByMap(Map<String, Object> columnMap);
// 删除（根据ID 批量删除）
boolean removeByIds(Collection<? extends Serializable> idList);
1
2
3
4
5
6
7
8

• 修改：Update

// 根据 UpdateWrapper 条件，更新记录 需要设置sqlset
boolean update(Wrapper<T> updateWrapper);
// 根据 whereWrapper 条件，更新记录
boolean update(T updateEntity, Wrapper<T> whereWrapper);
// 根据 ID 选择修改
boolean updateById(T entity);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList, int batchSize);
1
2
3
4
5
6
7
8
9
10

• 查询：Get、List、Count

// 根据 ID 查询
T getById(Serializable id);
// 根据 Wrapper，查询一条记录。结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")
T getOne(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
T getOne(Wrapper<T> queryWrapper, boolean throwEx);
// 根据 Wrapper，查询一条记录
Map<String, Object> getMap(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
<V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);


// 查询所有
List<T> list();
// 查询列表
List<T> list(Wrapper<T> queryWrapper);
// 查询（根据ID 批量查询）
Collection<T> listByIds(Collection<? extends Serializable> idList);
// 查询（根据 columnMap 条件）
Collection<T> listByMap(Map<String, Object> columnMap);
// 查询所有列表
List<Map<String, Object>> listMaps();
// 查询列表
List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper);
// 查询全部记录
List<Object> listObjs();
// 查询全部记录
<V> List<V> listObjs(Function<? super Object, V> mapper);
// 根据 Wrapper 条件，查询全部记录
List<Object> listObjs(Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录
<V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

// 查询总记录数
int count();
// 根据 Wrapper 条件，查询总记录数
int count(Wrapper<T> queryWrapper);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

• 分页：Page

// 根据 ID 查询
T getById(Serializable id);
// 根据 Wrapper，查询一条记录。结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")
T getOne(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
T getOne(Wrapper<T> queryWrapper, boolean throwEx);
// 根据 Wrapper，查询一条记录
Map<String, Object> getMap(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
<V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);
1
2
3
4
5
6
7
8
9
10

4.调用Service层实现CRUD

我们在自己的Service接口中通过继承MyBatis-Plus提供的IService接口，不仅可以获得其提供的CRUD方法，而且还可以使用自身定义的方法。

4.1 相关前提步骤

• 创建UserService并继承IService

/**
  * UserService继承IService模板提供的基础功能 
  */
public interface UserService extends IService<User> {}
1
2
3
4

• 创建UserService的实现类并继承ServiceImpl

/**
  * ServiceImpl实现了IService，提供了IService中基础功能的实现 
  * 若ServiceImpl无法满足业务需求，则可以使用自定的UserService定义方法，并在实现类中实现
  */
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper,User> implements UserService{}
1
2
3
4
5
6

4.2 增加

1)、save方法（插入一条数据）

（1）、官方提供的接口说明

// 插入一条记录（选择字段，策略插入）
boolean save(T entity);
1
2

参数说明

（2）、实现方式

    /**
     * 插入一条数据,保存方法
     * 

     * ==>  Preparing: INSERT INTO user ( id, name, age, email ) VALUES ( ?, ?, ?, ? )
     * ==> Parameters: 1550462217613271041(Long), lyq(String), 23(Integer), liuyanqiang_98@163.com(String)
     * <==    Updates: 1
     */
    @Test
    void testSave() {
        User user = new User();
        user.setName("lyq");
        user.setAge(23);
        user.setEmail("liuyanqiang_98@163.com");
        boolean result = userService.save(user);
        System.out.println(result ? "添加成功！" : "添加失败！");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2)、saveBatch方法（批量插入数据）

（1）、官方提供的接口说明

// 插入（批量）
boolean saveBatch(Collection<T> entityList);
// 插入（批量）
boolean saveBatch(Collection<T> entityList, int batchSize);
1
2
3
4

参数说明

（2）、实现方式

    /**
     * 批量插入数据
     * 

     * ==>  Preparing: INSERT INTO user ( id, name, age, email ) VALUES ( ?, ?, ?, ? )
     * ==> Parameters: 1550463363870363649(Long), 王五(String), 22(Integer), wangwu@163.com(String)
     * ==> Parameters: 1550463363958444033(Long), 赵六(String), 23(Integer), zhaoliu@163.com(String)
     */
    @Test
    void saveBatch() {
        List<User> list = new ArrayList<>();
        list.add(new User().setName("王五").setAge(22).setEmail("wangwu@163.com"));
        list.add(new User().setName("赵六").setAge(23).setEmail("zhaoliu@163.com"));
        userService.saveBatch(list);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3)、saveOrUpdate方法（插入数据或更新数据）

（1）、官方提供的接口说明

// TableId 注解存在更新记录，否插入一条记录
boolean saveOrUpdate(T entity);
// 根据updateWrapper尝试更新，否继续执行saveOrUpdate(T)方法
boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper);
1
2
3
4

参数说明

（2）、实现方式

    /**
     * 插入或修改(当有主键id存在的时候为修改update，当无主键是增加insert)
     * 

     * ==>  Preparing: INSERT INTO user ( id, name, age, email ) VALUES ( ?, ?, ?, ? )
     * ==> Parameters: 1550465459546066945(Long), 刘二(String), 13(Integer), liuer@163.com(String)
     * <==    Updates: 1
     * 

     * ==>  Preparing: UPDATE user SET name=?, age=?, email=? WHERE id=?
     * ==> Parameters: 张三(String), 23(Integer), zhangsan@163.com(String), 1550465459546066945(Long)
     * <==    Updates: 1
     */
    @Test
    void saveOrUpdate() {
        User user = new User();
        //添加或修改，同一时间只能进行一项操作
        //此修改
//        user.setName("刘二").setAge(13).setEmail("liuer@163.com");
        //此添加
        user.setId(1550465459546066945L).setName("张三").setAge(23).setEmail("zhangsan@163.com");
        userService.saveOrUpdate(user);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

4)、saveOrUpdateBatch方法（批量插入数据或更新数据）

（1）、官方提供的接口说明

// TableId 注解存在更新记录，否插入一条记录
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);
1
2
3
4
5

参数说明

（2）、实现方式

    /**
     * 批量插入或批量修改(当有主键id存在的时候为修改update，当无主键是增加insert)
     * 

     * ==>  Preparing: INSERT INTO user ( id, name, age, email ) VALUES ( ?, ?, ?, ? )
     * ==> Parameters: 1550466709259816961(Long), 张三(String), 21(Integer), zhangsan@163.com(String)
     * ==> Parameters: 1550466709368868865(Long), 李四(String), 11(Integer), lisi@163.com(String)
     *
     * ==>  Preparing: SELECT id,name,age,email FROM user WHERE id=?
     * ==> Parameters: 1550466709259816961(Long)
     * <==    Columns: id, name, age, email
     * <==        Row: 1550466709259816961, 张三, 21, zhangsan@163.com
     * <==      Total: 1
     * ==>  Preparing: UPDATE user SET name=?, age=?, email=? WHERE id=?
     * ==> Parameters: 王五(String), 12(Integer), wangwu@163.com(String), 1550466709259816961(Long)
     * ==>  Preparing: SELECT id,name,age,email FROM user WHERE id=?
     * ==> Parameters: 1550466709368868865(Long)
     * <==    Columns: id, name, age, email
     * <==        Row: 1550466709368868865, 李四, 11, lisi@163.com
     * <==      Total: 1
     * ==>  Preparing: UPDATE user SET name=?, age=?, email=? WHERE id=?
     * ==> Parameters: 赵六(String), 13(Integer), zhaoliu@163.com(String), 1550466709368868865(Long)
     */
    @Test
    void saveOrUpdateBatch() {
        //添加或修改，同一时间只能进行一项操作
        List<User> list = new ArrayList<>();
        //此添加
//        list.add(new User().setName("张三").setAge(21).setEmail("zhangsan@163.com"));
//        list.add(new User().setName("李四").setAge(11).setEmail("lisi@163.com"));
        //此修改
        list.add(new User().setId(1550466709259816961L).setName("王五").setAge(12).setEmail("wangwu@163.com"));
        list.add(new User().setId(1550466709368868865L).setName("赵六").setAge(13).setEmail("zhaoliu@163.com"));
        userService.saveOrUpdateBatch(list);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

4.3 删除

1)、remove方法（根据 entity 条件，删除记录）

（1）、官方提供的接口说明

// 根据 entity 条件，删除记录
boolean remove(Wrapper<T> queryWrapper);
1
2

参数说明

（2）、实现方式

    /**
     * 根据实体对象删除
     * 

     * ==>  Preparing: DELETE FROM user WHERE (name = ?)
     * ==> Parameters: 张三(String)
     * <==    Updates: 1
     */
    @Test
    void remove() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("name", "张三");
        userService.remove(queryWrapper);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

2)、removeById方法（根据 ID 删除）

（1）、官方提供的接口说明

// 根据 ID 删除
boolean removeById(Serializable id);
1
2

参数说明

（2）、实现方式

    /**
     * 根据主键删除
     * 

     * ==>  Preparing: DELETE FROM user WHERE id=?
     * ==> Parameters: 3(Integer)
     * <==    Updates: 1
     */
    @Test
    void removeById() {
        userService.removeById(3);
    }
1
2
3
4
5
6
7
8
9
10
11

3)、removeByMap方法（根据 columnMap 条件，删除记录）

（1）、官方提供的接口说明

// 根据 columnMap 条件，删除记录
boolean removeByMap(Map<String, Object> columnMap);
1
2

参数说明

（2）、实现方式

    /**
     * 根据 columnMap 条件，删除记录
     * 

     * ==>  Preparing: DELETE FROM user WHERE name = ? AND age = ?
     * ==> Parameters: 赵六(String), 23(String)
     * <==    Updates: 1
     */
    @Test
    void removeByMap() {
        Map<String, Object> map = new HashMap<>();
        map.put("name", "赵六");
        map.put("age", "23");
        userService.removeByMap(map);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

4)、removeByIds方法（根据 ID 批量删除）

（1）、官方提供的接口说明

// 删除（根据ID 批量删除）
boolean removeByIds(Collection<? extends Serializable> idList);
1
2

参数说明

（2）、实现方式

    /**
     * 根据ID批量删除
     * 

     * ==>  Preparing: DELETE FROM user WHERE id IN ( ? , ? )
     * ==> Parameters: 2(String), 3(String)
     * <==    Updates: 1
     */
    @Test
    void removeByIds() {
        List<String> list = new ArrayList<>();
        list.add("2");
        list.add("3");
        userService.removeByIds(list);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

4.4 修改

1)、update方法（根据updateWrapper和entity条件，更新记录）

（1）、官方提供的接口说明

// 根据 UpdateWrapper 条件，更新记录 需要设置sqlset
boolean update(Wrapper<T> updateWrapper);
// 根据 whereWrapper 条件，更新记录
boolean update(T updateEntity, Wrapper<T> whereWrapper);
1
2
3
4

参数说明

（2）、实现方式

    /**
     * 根据updateWrapper和entity条件，更新记录
     * 

     * ==>  Preparing: UPDATE user SET name=?, age=?, email=? WHERE (name = ?)
     * ==> Parameters: 张三(String), 23(Integer), “zhangsan@163.com(String), 张三(String)
     * <==    Updates: 1
     * 

     * ==>  Preparing: UPDATE user SET age=? WHERE (name = ?)
     * ==> Parameters: 35(Integer), 张三(String)
     * <==    Updates: 1
     */
    @Test
    void update() {
        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        //条件构造器作为参数进行更新(user可以设置多个属性  ， user属性为set = "value"  条件构造器为where字句的条件)
//        updateWrapper.eq("name", "张三");
//        User user = new User();
//        user.setName("张三").setAge(23).setEmail("“zhangsan@163.com");
//        userService.update(user, updateWrapper);
        //条件构造器Set方法(直接set想要修改的字段和值)
        updateWrapper.eq("name", "张三").set("age", 35);
        userService.update(updateWrapper);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

2)、updateById方法（根据ID，更新记录）

（1）、官方提供的接口说明

// 根据 ID 选择修改
boolean updateById(T entity);
1
2

参数说明

（2）、实现方式

    /**
     * 根据ID更新记录
     * 

     * ==>  Preparing: UPDATE user SET name=?, age=?, email=? WHERE id=?
     * ==> Parameters: 张三(String), 23(Integer), zhangsan@163.com(String), 1550471175593820161(Long)
     * <==    Updates: 1
     */
    @Test
    void updateById() {
        User user = new User();
        user.setId(1550471175593820161L).setName("张三").setAge(23).setEmail("zhangsan@163.com");
        userService.updateById(user);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

3)、updateBatchById方法（根据ID，批量更新）

（1）、官方提供的接口说明

// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList, int batchSize);
1
2
3
4

参数说明

（2）、实现方式

    /**
     * 根据ID批量更新
     * 

     * ==>  Preparing: UPDATE user SET name=?, age=? WHERE id=?
     * ==> Parameters: 张三(String), 12(Integer), 1550471175593820161(Long)
     * ==> Parameters: 李四(String), 13(Integer), 1550471175690289154(Long)
     */
    @Test
    void updateBatchById() {
        Collection<User> list = new ArrayList<>();
        list.add(new User().setAge(12).setName("张三").setId(1550471175593820161L));
        list.add(new User().setAge(13).setName("李四").setId(1550471175690289154L));
        userService.updateBatchById(list);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

5、查询

1)、Get方法

（1）、官方提供的接口说明

// 根据 ID 查询
T getById(Serializable id);
// 根据 Wrapper，查询一条记录。结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")
T getOne(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
T getOne(Wrapper<T> queryWrapper, boolean throwEx);
// 根据 Wrapper，查询一条记录
Map<String, Object> getMap(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
<V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);
1
2
3
4
5
6
7
8
9
10

参数说明

（2）、实现方式

    /**
     * 根据 ID 查询
     * 

     * ==>  Preparing: SELECT id,name,age,email FROM user WHERE id=?
     * ==> Parameters: 1(Integer)
     * <==    Columns: id, name, age, email
     * <==        Row: 1, Jone, 18, test1@baomidou.com
     * <==      Total: 1
     */
    @Test
    void getById() {
        System.out.println(userService.getById(1));
    }

    /**
     * 根据 Wrapper，查询一条记录。结果集，如果是多个会抛出异常，随机取一条加上限制条件
     * 

     * ==>  Preparing: SELECT id,name,age,email FROM user WHERE (name LIKE ? AND age < ?)
     * ==> Parameters: %张%(String), 40(Integer)
     * <==    Columns: id, name, age, email
     * <==        Row: 1550471175593820161, 张三, 12, zhangsan@163.com
     * <==      Total: 1
     */
    @Test
    void getOne() {
        // 查询条件：名字中包含'张'并且年龄小于40
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.like(User::getName, "张").lt(User::getAge, 40);
        // 开始查询符合的单条记录（如果满足条件的记录有多条，那就不能用这个方法，会报错。）
        User user = userService.getOne(queryWrapper);
        System.out.println(user);
    }

    /**
     * 根据 Wrapper，查询一条记录
     * getMap 的用法和上面的 getOne 很像，都是传入一个查询构造器进行查询。不同的是 getMap 返回的是一个 Map，而不是实体类对象
     * 注意： Map 里的 key 为表字段名，而不是对应实体类的属性名。
     * 

     * ==>  Preparing: SELECT id,name,age,email FROM user WHERE (name = ?)
     * ==> Parameters: 张三(String)
     * <==    Columns: id, name, age, email
     * <==        Row: 1550471175593820161, 张三, 12, zhangsan@163.com
     * <==      Total: 1
     */
    @Test
    void getMap() {
        QueryWrapper wrapper = new QueryWrapper();
        wrapper.eq("name", "张三");
        Map<String, Object> map = userService.getMap(wrapper);
        System.out.println(map);
    }

    /**
     * 根据 Wrapper，查询一条记录（使用查询构造器，查询一条记录，返回这条记录的第一个字段值）
     * getObj 的用法和上面的 getOne 很像，都是传入一个查询构造器进行查询。不同的是 getObj 返回的是一个字段值（该方法第二个参数是转换函数，必填）
     * 

     * ==>  Preparing: SELECT id,name,age,email FROM user WHERE (name LIKE ? AND age = ?)
     * ==> Parameters: %王%(String), 22(Integer)
     * <==    Columns: id, name, age, email
     * <==        Row: 1550463923835146242, 王五, 22, wangwu@163.com
     * <==      Total: 1
     */
    @Test
    void getObj() {
        // 查询条件：名字中包含'王'并且年龄等于22
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.like(User::getName, "王").eq(User::getAge, 22);
        // 开始查询符合的单条记录的第一个字段值
        Long id = userService.getObj(queryWrapper, (o) -> {
            System.out.println(o);
            return Long.getLong(o.toString());
        });
        System.out.println(id);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

2)、List方法

（1）、官方提供的接口说明

// 查询所有
List<T> list();
// 查询列表
List<T> list(Wrapper<T> queryWrapper);
// 查询（根据ID 批量查询）
Collection<T> listByIds(Collection<? extends Serializable> idList);
// 查询（根据 columnMap 条件）
Collection<T> listByMap(Map<String, Object> columnMap);
// 查询所有列表
List<Map<String, Object>> listMaps();
// 查询列表
List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper);
// 查询全部记录
List<Object> listObjs();
// 查询全部记录
<V> List<V> listObjs(Function<? super Object, V> mapper);
// 根据 Wrapper 条件，查询全部记录
List<Object> listObjs(Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录
<V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

参数说明

（2）、实现方式

/**
     * 使用查询构造器，返回一个 list
     * 

     * ==>  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
     * <==        Row: 6, lyq, 23, liuyanqiang_98@163.com
     * <==        Row: 1550463923835146242, 王五, 22, wangwu@163.com
     * <==        Row: 1550466709259816961, 王五, 12, wangwu@163.com
     * <==        Row: 1550466709368868865, 赵六, 13, zhaoliu@163.com
     * <==        Row: 1550471175593820161, 张三, 12, zhangsan@163.com
     * <==        Row: 1550471175690289154, 李四, 13, lisi@163.com
     * <==      Total: 11
     * 

     * ==>  Preparing: SELECT id,name,age,email FROM user WHERE (name LIKE ? AND age = ?)
     * ==> Parameters: %王%(String), 22(Integer)
     * <==    Columns: id, name, age, email
     * <==        Row: 1550463923835146242, 王五, 22, wangwu@163.com
     * <==      Total: 1
     */
    @Test
    void list() {
        //1.list 方法如果参数为空，则查询所有的数据
//        List list = userService.list();
        //2.list 方法也可以传入查询条件构造器进行查询
        // 查询条件：名字中包含'王'并且年龄等于22
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.like(User::getName, "王").eq(User::getAge, 22);
        // 开始查询
        List<User> list = userService.list(queryWrapper);
        System.out.println(list);
    }

    /**
     * 根据 ID 批量查询，返回一个 list
     * 

     * ==>  Preparing: SELECT id,name,age,email FROM user WHERE id IN ( ? , ? , ? )
     * ==> Parameters: 1(Integer), 2(Integer), 3(Integer)
     * <==    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
     * <==      Total: 3
     */
    @Test
    void listByIds() {
        List<User> list = userService.listByIds(Arrays.asList(1, 2, 3));
        System.out.println(list);
    }

    /**
     * 通过 MAP 封装的条件查询，返回一个 list
     * 注意：map 写的是数据表中的列名，而非实体类的属性名。比如属性名为 userName，数据表中字段为 user_name，这里应该写的是 user_name。
     * 

     * ==>  Preparing: SELECT id,name,age,email FROM user WHERE (name LIKE ? AND age = ?)
     * ==> Parameters: %王%(String), 22(Integer)
     * <==    Columns: id, name, age, email
     * <==        Row: 1550463923835146242, 王五, 22
     */
    @Test
    void listByMap() {
        Map<String, Object> map = new HashMap<>();
        map.put("name", "张三");
        map.put("age", 23);
        List<User> list = userService.listByMap(map);
        System.out.println(list);
    }

    /**
     * 使用查询构造器，返回一个 list
     * listMaps 的用法和上面的 list 很像，都是传入一个查询构造器进行查询，然后返回一个 List。不同在于 listMaps 返回的 List 里面是 Map。
     * 注意： Map 里的 key 为表字段名，而不是对应实体类的属性名。
     * 

     * ==>  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
     * <==        Row: 6, lyq, 23, liuyanqiang_98@163.com
     * <==        Row: 1550463923835146242, 王五, 22, wangwu@163.com
     * <==        Row: 1550466709259816961, 王五, 12, wangwu@163.com
     * <==        Row: 1550466709368868865, 赵六, 13, zhaoliu@163.com
     * <==        Row: 1550471175593820161, 张三, 12, zhangsan@163.com
     * <==        Row: 1550471175690289154, 李四, 13, lisi@163.com
     * <==      Total: 11
     * 

     * ==>  Preparing: SELECT id,name,age,email FROM user WHERE (name LIKE ? AND age = ?)
     * ==> Parameters: %王%(String), 22(Integer)
     * <==    Columns: id, name, age, email
     * <==        Row: 1550463923835146242, 王五, 22, wangwu@163.com
     * <==      Total: 1
     */
    @Test
    void listMaps() {
        //1.listMaps 方法如果参数为空，则查询所有的数据
//        List> list = userService.listMaps();
//        System.out.println(list);
        //2.listMaps 方法也可以传入查询条件构造器进行查询
        // 查询条件：名字中包含'王'并且年龄等于22
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.like(User::getName, "王").eq(User::getAge, 22);
        // 开始查询
        List<Map<String, Object>> list = userService.listMaps(queryWrapper);
        System.out.println(list);
    }


    /**
     * 使用查询构造器，返回一个 List