Mybatis-Plus入门学习笔记 [详细完整版]

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;

添加数据

INSERT INTO user (id, name, age, email) VALUES
(1, 'Jone', 18, '[email protected]'),
(2, 'Jack', 20, '[email protected]'),
(3, 'Tom', 28, '[email protected]'),
(4, 'Sandy', 21, '[email protected]'),
(5, 'Billie', 24, '[email protected]');

3、创建SpringBoot工程

使用 Spring Initializr 快速初始化一个 Spring Boot 工程

引入依赖

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.1</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

安装Lombok插件

4、编写代码

配置application.properties

注意：

这里的 url 使用了 ?serverTimezone=Hongkong 后缀，因为Spring Boot 2.1 集成了 8.0版本的jdbc驱动，这个版本的 jdbc 驱动需要添加这个后缀
这里的 driver-class-name 使用了 com.mysql.cj.jdbc.Driver ，在 jdbc 8 中建议使用这个驱动，之前的 com.mysql.jdbc.Driver 已经被废弃，否则运行测试用例的时候会有 WARN 信息

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?serverTimezone=Hongkong
spring.datasource.username=root
spring.datasource.password=123456

实体类使用Lombok @Data注解

@Data //Lombok注解
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

点击User.java文件，查看编译结果

添加mapper

BaseMapper是MyBatis-Plus提供的模板mapper

其中包含了基本的CRUD方法，泛型为操作的实体类型

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

启动类中增加@MapperScan注解

测试

@SpringBootTest
class MybatisPlusDemoApplicationTests {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelectList(){
        //UserMapper 中的 selectList() 方法的参数为 MP 内置的条件封装器 Wrapper
        //所以不填写就是无任何条件
        List<User> users = userMapper.selectList(null);
        users.forEach(user -> System.out.println(user));
    }

}

application.properties中加入查看sql输出日志

#mybatis日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

测试结果

三、基本CRUD

MyBatis-Plus中的基本CRUD在内置的BaseMapper中都已得到了实现，可以直接使用

1、插入 insert

@Test
    public void testInsert(){
       User user = new User();
       user.setName("张三");
       user.setAge(19);
       user.setEmail("[email protected]");
       int result=userMapper.insert(user);
       System.out.println("受影响行数result: "+result);
        System.out.println("id自动获取: "+user.getId());
    }

MyBatis-Plus默认的主键策略是：ID_WORKER 全局唯一ID （基于雪花算法的策略生成id）

2、删除 delete

通过id删除记录 deleteById

@Test
    public void testDeleteById(){
        //通过id删除用户信息
        //DELETE FROM user WHERE id=?
        int result = userMapper.deleteById(1511604736883720194L);
        System.out.println("受影响行数："+result);
    }

通过id批量删除记录 deleteBatchIds

先增加几条测试数据

    @Test
    public void testDeleteBatchIds(){
    //通过多个id批量删除
    //DELETE FROM user WHERE id IN ( ? , ? , ? )
        List<Long> idList = Arrays.asList(6L, 7L, 9L);
        int result = userMapper.deleteBatchIds(idList);
        System.out.println("受影响行数："+result);
    }

测试结果

通过map条件删除记录 deleteByMap

    @Test
    public void testDeleteByMap(){
    //根据map集合中所设置的条件删除记录
    //DELETE FROM user WHERE name = ? AND age = ?
        Map<String, Object> map = new HashMap<>();
        map.put("age", 28);
        map.put("name", "Test08");
        int result = userMapper.deleteByMap(map);
        System.out.println("受影响行数："+result);
    }

测试结果

3、修改 update

通过id修改记录 updateById

 @Test
    public void testUpdateById(){
        User user = new User();
        user.setId(4L);
        user.setName("李四");
    //UPDATE user SET name=?, age=? WHERE id=?
        int result = userMapper.updateById(user);
        System.out.println("受影响行数："+result);
    }

测试结果

4、查询 select

根据id查询用户信息 selectById

@Test
    public void testSelectById(){
    //根据id查询用户信息
    //SELECT id,name,age,email FROM user WHERE id=?
        User user = userMapper.selectById(1L);
        System.out.println(user);
    }

测试结果

根据多个id查询多个用户信息 selectBatchIds

 @Test
    public void testSelectBatchIds(){
    //根据多个id查询多个用户信息
    //SELECT id,name,age,email FROM user WHERE id IN ( ? , ? )
        List<Long> idList = Arrays.asList(1L,2L,3L);
        List<User> list = userMapper.selectBatchIds(idList);
        list.forEach(user -> System.out.println(user));
    }

测试结果

通过map条件查询用户信息 selectByMap

@Test
    public void testSelectByMap(){
    //通过map条件查询用户信息
    //SELECT id,name,age,email FROM user WHERE name = ? AND age = ?
        Map<String, Object> map = new HashMap<>();
        map.put("age", 28);
        map.put("name", "Tom");
        List<User> list = userMapper.selectByMap(map);
        list.forEach(user -> System.out.println(user));
    }

测试结果

查询所有数据 selectList(null)

BaseMapper中大多方法中都有Wrapper类型的形参，此为条件构造器
可针对于SQL语句设置不同的条件，若没有条件赋值null，即查询（删除/修改）所有数据

@Test
    public void testSelectList(){
    //查询所有用户信息
    //SELECT id,name,age,email FROM user
        List<User> list = userMapper.selectList(null);
        list.forEach(user -> System.out.println(user));
    }

测试结果

5、自定义功能

Mybatis-Plus是对Mybatis的增强，所以也能够使用映射文件来自定义功能
Mybatis映射文件默认位置 resource/mapper/xxxMapper.xml

@Repository
public interface UserMapper extends BaseMapper<User>{
    //自定义功能 根据id查询用户信息为map
    Map<String,Object> selectMapById(Long id);
}

<?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="com.hua.mybatisplus.mapper.UserMapper">
<!--    Map<String,Object> selectMapById(Long id);-->
    <select id="selectMapById" resultType="map">
        select id,name,age,email from user where id=#{id}
    </select>
</mapper>

@Test
    public void testSelectMapById(){
       Map<String,Object> map=userMapper.selectMapById(1L);
       System.out.println(map);
    }

测试结果

6、通用Service

官方地址：CRUD 接口 | MyBatis-Plus (baomidou.com)

创建Service接口和实现类

UserService继承IService模板提供的基础功能

public interface UserService extends IService<User> {
}

ServiceImpl实现了IService，提供了IService中基础功能的实现
若ServiceImpl无法满足业务需求，可以使用自定的UserService定义方法，并在实现类中实现

public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
}

测试查询记录数

@SpringBootTest
public class MybatisPlusServiceTest {

    @Autowired
    private UserService userService;

    @Test
    public void testCount(){
        //查询总记录数
        //SELECT COUNT (*) FROM user
        long count = userService.count();
        System.out.println("总记录数："+count);
    }

}

测试结果

测试批量插入

 @Test
    public void testInsertMore() {
        // SQL长度有限制，海量数据插入单条SQL无法实行，
        // 因此MP将批量插入放在了通用Service中实现，而不是通用Mapper
        List<User> list = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            User user = new User();
            user.setName("Test" + i);
            user.setAge(20 + i);
            list.add(user);
        }
        //SQL:INSERT INTO t_user ( username, age ) VALUES ( ?, ? )
        boolean b = userService.saveBatch(list);
        System.out.println(b);
    }

测试结果

四、常用注解

1、@TableName

之前在实现基本的CRUD时，并没有指定要操作的表，只是在Mapper接口继承BaseMapper时设置了泛型User，而操作的表为user表，所以MyBatis-Plus在确定操作的表时，由BaseMapper的泛型决定，即实体类型决定，且默认操作的表名和实体类型的类名一致。

实体类类名与表名不一致的情况下的问题：

更改user表的名称为 t_user，再次测试查询功能，会抛出异常：

Error querying database.

Cause: java.sql.SQLSyntaxErrorException: Table 'mybatis_plus.user' doesn't exist

①通过 @TableName 解决问题：

在实体类类型上添加 @TableName("t_user")，标识实体类对应的表，即可成功执行SQL语句

②通过全局配置解决问题

当实体类所对应的表都有固定的前缀时，可以使用MyBatis-Plus提供的全局配置，为实体类所对应的表名设置默认的前缀，就不需要在每个实体类上通过@TableName标识实体类对应的表

在application.properties中配置

#设置Mybatis-Plus操作表的默认前缀
mybatis-plus.global-config.db-config.table-prefix=t_

2、@TableId

MyBatis-Plus在实现CRUD时会默认将id作为主键列

在插入数据时默认基于雪花算法的策略生成id

实体类和表中表示主键的不是id，而是其他字段的情况：

更改user表中字段id和实体类中属性id为 uid ，再次测试添加功能，会抛出异常：

Error updating database.

Cause: java.sql.SQLException: Field 'uid' doesn't have a default value

通过 @TableId 解决问题：

在实体类中uid属性上通过 @TableId 将其标识为主键，即可成功执行SQL语句

@TableId的value属性

当实体类中主键对应的属性为id，而表中表示主键的字段为uid，如果此时只在属性id上添加注解@TableId，MyBatis-Plus仍然会将id作为表的主键操作而表中表示主键的是字段uid，会抛出异常

Error updating database.

Cause: java.sql.SQLSyntaxErrorException: Unknown column 'id' in 'field list'

需要通过 @TableId 的 value 属性，在实体类中指定表中的主键字段，

@TableId("uid") 或 @TableId(value="uid")

@TableId的type属性

type属性用来定义主键策略

IdType.ASSIGN_ID(默认)：基于雪花算法的策略生成数据id，与数据库id是否设置自增无关
IdType.AUTO：使用数据库的自增策略，要确保数据库设置了id自增，否则无效

重新创建数据表t_user并将主键字段设置自动递增，@TableId(type=IdType.AUTO)

再次插入一条数据测试，可以看到此时主键策略为自动递增

配置全局主键策略：

在application.properties中配置

# 配置MyBatis-Plus的主键策略
mybatis-plus.global-config.db-config.id-type=auto

3、@TableField

经过以上的测试，MyBatis-Plus在执行SQL语句时，要保证实体类中的属性名和表中的字段名一致

实体类中的属性名和字段名不一致的情况

情况①

实体类中的属性使用的是驼峰命名风格，而表中的字段使用的是下划线命名风格

如实体类属性userName，表中字段user_name

此时MyBatis-Plus会自动将下划线命名风格转化为驼峰命名风格，相当于在MyBatis中配置

情况②

实体类中的属性和表中的字段不满足情况①，如实体类属性name，表中字段username

此时需要在实体类属性上使用 @TableField("username") 设置属性所对应的字段名

4、@TableLogic

逻辑删除

物理删除：真实删除，将对应数据从数据库中删除，之后查询不到此条被删除的数据
逻辑删除：假删除，将对应数据中代表是否被删除字段的状态修改为“被删除状态”，之后在数据库中仍旧能看到此条数据记录
使用场景：可以进行数据恢复

实现逻辑删除

数据库中创建逻辑删除状态列，设置默认值为0

实体类中添加逻辑删除属性

测试删除功能，真正执行的是修改

测试查询功能，被逻辑删除的数据默认不会被查询

五、条件构造器和常用接口

条件构造器 | MyBatis-Plus (baomidou.com)

1、Wapper

Wrapper ：条件构造抽象类，最顶端父类
AbstractWrapper ：用于查询条件封装，生成 sql 的 where 条件
- QueryWrapper ：查询条件封装
- UpdateWrapper ： Update 条件封装
- AbstractLambdaWrapper ：使用Lambda 语法
  - LambdaQueryWrapper ：用于Lambda语法使用的查询Wrapper
  - LambdaUpdateWrapper ： Lambda 更新封装Wrapper

2、 QueryWrapper

①组装查询条件

public class MybatisPlusWrapperTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void test01() {
//查询用户名包含a，年龄在20到30之间，并且邮箱不为null的用户信息
//SELECT id,username AS name,age,email,is_deleted FROM t_user WHERE
// is_deleted = 0 AND(username LIKE ? AND age BETWEEN ? AND ? AND email IS NOT NULL)
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.like("username", "a")
                .between("age", 20, 30)
                .isNotNull("email");
        List<User> list = userMapper.selectList(queryWrapper);
        list.forEach(user -> System.out.println(user));
    }
}

②组装排序条件

  @Test
    public void test02(){
//按年龄降序查询用户，如果年龄相同则按id升序排列
//SELECT id,username AS name,age,email,is_deleted FROM t_user WHERE
// is_deleted=0 ORDER BY age DESC,id ASC
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper
                .orderByDesc("age")
                .orderByAsc("id");
        List<User> users = userMapper.selectList(queryWrapper);
        users.forEach(System.out::println);
    }

③组装删除条件

   @Test
    public void test03(){
//删除email为空的用户
//DELETE FROM t_user WHERE (email IS NULL)
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.isNull("email");
//条件构造器也可以构建删除语句的条件
        int result = userMapper.delete(queryWrapper);
        System.out.println("受影响的行数：" + result);
    }

④组装修改条件

    @Test
    public void test04() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
//将（年龄大于20并且用户名中包含有a）或邮箱为null的用户信息修改
//UPDATE t_user SET age=?, email=? WHERE (username LIKE ? AND age > ? OR email IS NULL)
        queryWrapper
                .like("username", "a")
                .gt("age", 20)
                .or()
                .isNull("email");
        User user = new User();
        user.setEmail("[email protected]");
        int result = userMapper.update(user, queryWrapper);
        System.out.println("受影响的行数：" + result);
    }

⑤条件优先级

lambda表达式内的逻辑优先运算

  @Test
    public void test05(){
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
//将用户名中包含有a并且（年龄大于20或邮箱为null）的用户信息修改
//UPDATE t_user SET age=?, email=? WHERE (username LIKE ? AND (age > ? OR email IS NULL))
//lambda表达式内的逻辑优先运算
        queryWrapper.like("username","a")
                .and(i->i.gt("age",20).or().isNull("email"));
        User user=new User();
        user.setEmail("[email protected]");
        int result = userMapper.update(user, queryWrapper);
        System.out.println("受影响的行数：" + result);
        }

⑥组装select子句

    @Test
    public void test06() {
//查询用户信息的username和age字段
//SELECT username,age FROM t_user
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.select("username", "age");
//selectMaps()返回Map集合列表，通常配合select()使用，避免User对象中没有被查询到的列值为null
        List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
        maps.forEach(System.out::println);
    }

⑦组装子查询

    @Test
    public void test07() {
//子查询实现 查询uid小于等于3的用户信息
//SELECT uid,username AS name,age,email,is_deleted FROM t_user WHERE (uid IN (select id from t_user where uid <= 3))
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.inSql("uid", "select uid from t_user where uid <= 3");
        List<User> list = userMapper.selectList(queryWrapper);
        list.forEach(System.out::println);
    }

3、UpdateWrapper

    @Test
    public void test08() {
        //将用户名中包含有a并且（年龄大于20或邮箱为null）的用户信息修改
        UpdateWrapper<User> updateWrapper=new UpdateWrapper<>();
        updateWrapper.like("username","a")
                .and(i->i.gt("age",20).or().isNull("email"));
        updateWrapper.set("email","[email protected]");
        int result = userMapper.update(null,updateWrapper);
        System.out.println("受影响的行数：" + result);
    }

4、condition

在开发过程中，组装条件是常见的功能，而这些条件数据来源于用户输入，是可选的，因此我们在组装这些条件时，必须先判断用户是否选择了这些条件，若选择则需要组装该条件，若没有选择则一定不能组装，以免影响SQL执行的结果。

思路一：

@Test
    public void test09(){
//定义查询条件，有可能为null（用户未输入或未选择）
        String username = null;
        Integer ageBegin = 18;
        Integer ageEnd = 20;
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
//StringUtils.isNotBlank()判断某字符串是否不为空且长度不为0且不由空白符(whitespace)构成
        if(StringUtils.isNotBlank(username)){
            queryWrapper.like("username","a");
        }
        if(ageBegin != null){
            queryWrapper.ge("age", ageBegin);
        }
        if(ageEnd != null){
            queryWrapper.le("age", ageEnd);
        }
//SELECT id,username AS name,age,email,is_deleted FROM t_user WHERE (age >=? AND age <= ?)
        List<User> users = userMapper.selectList(queryWrapper);
        users.forEach(System.out::println);
    }

思路二：

使用带condition参数的重载方法构建查询条件，简化代码的编写

5、LambdaQueryWrapper

通过Lambda访问实体类属性对应的字段，避免使用字符串表示字段，防止运行时错误

6、LambdaUpdateWrapper

    @Test
    public void test11() {
        //组装set子句
        //将用户名中包含有a并且（年龄小于24或邮箱为null）的用户信息修改
        LambdaUpdateWrapper<User> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper
                //Lambda表达式设置操作字段
                .set(User::getAge, 18)
                .set(User::getEmail, "[email protected]")
                .like(User::getName, "a")
                //lambda表达式内的逻辑优先运算
                .and(i -> i.lt(User::getAge, 24).or().isNull(User::getEmail));
        User user = new User();
        int result = userMapper.update(user, updateWrapper);
        System.out.println("受影响的行数：" + result);
    }

六、Mybatis-Plus插件

插件主体 | MyBatis-Plus (baomidou.com)

1、分页插件

MyBatis Plus自带分页插件，官方地址：分页插件 | MyBatis-Plus (baomidou.com)

①新建MybatisPlusConfig配置类

@Configuration
@MapperScan("com.hua.mybatisplus.mapper") //可以将主类中的注解移到此处
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

②测试

@SpringBootTest
public class MybatisPlusPluginsTest {

    @Autowired
    private UserMapper userMapper;
    @Test
    public void testPage(){
        //当前页起始索引，每页显示条数
        Page<User> page = new Page<>(1,3);
        userMapper.selectPage(page,null);
        //获取分页数据
        List<User> list = page.getRecords();
        list.forEach(System.out::println);
        System.out.println("当前页："+page.getCurrent());
        System.out.println("每页显示的条数："+page.getSize());
        System.out.println("总记录数："+page.getTotal());
        System.out.println("总页数："+page.getPages());
        System.out.println("是否有上一页："+page.hasPrevious());
        System.out.println("是否有下一页："+page.hasNext());

    }
}

自定义分页功能

@Repository
public interface UserMapper extends BaseMapper<User>{

    //根据年龄查询用户信息，分页显示
    Page<User> selectPageVo(
    //page 分页对象,xml中可以从里面进行取值,传递参数 Page 即自动分页,必须放在第一位
        @Param("page") Page<User> page,
    //age 年龄
        @Param("age") Integer age);
}

配置application.properties，通过类型别名访问某个类型

#配置类型别名对应的包
mybatis-plus.type-aliases-package=com.hua.mybatisplus.pojo

UserMapper.xml

<!--    Page<User> selectPageVo(@Param("page") Page<User> page,@Param("age") Integer age);-->
    <!--SQL片段，记录基础字段-->
    <sql id="BaseColumns">uid,username,age,email</sql>
    <select id="selectPageVo" resultType="User">
        SELECT <include refid="BaseColumns"></include> FROM t_user
        WHERE age > #{age}
    </select>

 @Test
    public void testPageVo(){
        Page<User> page= new Page<>(1,3);
        //获取年龄大于20的用户信息
        userMapper.selectPageVo(page,20);
        //获取分页数据
        List<User> list = page.getRecords();
        list.forEach(System.out::println);
        System.out.println("当前页："+page.getCurrent());
        System.out.println("每页显示的条数："+page.getSize());
        System.out.println("总记录数："+page.getTotal());
        System.out.println("总页数："+page.getPages());
        System.out.println("是否有上一页："+page.hasPrevious());
        System.out.println("是否有下一页："+page.hasNext());
    }

2、乐观锁

场景：

一件商品，成本价是80元，售价是100元。老板先是通知小李去把商品价格增加50元。
小李正在玩游戏，耽搁了一个小时。正好一个小时后，老板觉得商品价格增加到150元，价格太高，可能会影响销量。又通知小王把商品价格降低30元。
此时，小李和小王同时操作商品后台系统。小李操作的时候，系统先取出商品价格100元；小王也在操作，取出的商品价格也是100元。小李将价格加了50元，并将100+50=150元存入了数据库；小王将商品减了30元，并将100-30=70元存入了数据库。
如果没有锁，小李的操作就完全被小王的覆盖了。

乐观锁与悲观锁

上面的故事，如果是乐观锁，小王保存价格前，会检查下价格是否被人修改过了。如果被修改过了，则重新取出的被修改后的价格150元，这样他会将120元存入数据库。

如果是悲观锁，小李取出数据后，小王只能等小李操作完之后，才能对价格进行操作，也会保证最终的价格是120元。

模拟修改冲突

数据库中增加商品表

CREATE TABLE t_product
(
id BIGINT(20) NOT NULL COMMENT '主键ID',
NAME VARCHAR(30) NULL DEFAULT NULL COMMENT '商品名称',
price INT(11) DEFAULT 0 COMMENT '价格',
VERSION INT(11) DEFAULT 0 COMMENT '乐观锁版本号',
PRIMARY KEY (id)
);

添加数据

INSERT INTO t_product (id, NAME, price) VALUES (1, '可乐', 100);

添加实体

@Data
public class Product {
    private Long id;
    private String name;
    private Integer price;
    private Integer version;
}

ProductMapper

@Repository
public interface ProductMapper extends BaseMapper<Product> {
}

测试

  @Autowired
    private ProductMapper productMapper;
    @Test
    public void testProduct01(){
        //1、小李查询商品价格
        Product productLi=productMapper.selectById(1L);
        System.out.println("小李查询出的商品价格："+productLi.getPrice());
        //2、小王查询商品价格
        Product productWang=productMapper.selectById(1L);
        System.out.println("小王查询出的商品价格："+productWang.getPrice());
        //3、小李将商品价格+50
        productLi.setPrice(productLi.getPrice()+50);
        int result1=productMapper.updateById(productLi);
        System.out.println("小李修改结果："+result1);
        //4、小王将商品价格-30
        productWang.setPrice(productWang.getPrice()-30);
        int result2=productMapper.updateById(productWang);
        System.out.println("小王修改结果："+result2);
        //5、老板查询价格
        Product productBoss=productMapper.selectById(1L);
        System.out.println("最终老板查询出的商品价格："+productBoss.getPrice());
    }

乐观锁实现方式

官方地址：乐观锁插件 | MyBatis-Plus (baomidou.com)

数据库中添加version字段
取出记录时，获取当前version
更新时，version + 1，如果where语句中的version版本不对，则更新失败

Mybatis-Plus实现乐观锁

实体类中添加@Version 标识乐观锁版本号字段

MybatisPlusConfig配置类中添加乐观锁插件配置

测试

先将数据库中的价格修改回100

再次执行 testProduct01 测试类

小李执行修改操作，版本号+1，由0更新为1，修改成功

小王执行修改操作，此时版本号为1与之前查询出的不一致，修改失败

此时最后查询价格为 150

优化流程小王操作失败后重试，重新获取版本号，在小李修改后的基础上再进行修改

重新获取版本号后，小王在小李修改后的基础上进行操作，修改成功

最后查询价格为 120

七、通用枚举

表中的有些字段值是固定的，例如性别（男或女），此时可以使用MyBatis-Plus的通用枚举来实现

t_user表中增加sex字段

1、创建通用枚举类型

@Getter
public enum SexEnum {
    MALE(1,"男"),
    FEMALE(2,"女");

    @EnumValue //将注解标识的属性的值存储到数据库中
    private Integer sex;
    private String sexName;

    SexEnum(Integer sex, String sexName) {
        this.sex = sex;
        this.sexName = sexName;
    }
}

实体类中添加枚举类型的性别属性

2、配置扫描通用枚举

# 配置扫描通用枚举
mybatis-plus.type-enums-package=com.hua.mybatisplus.enums

测试

@SpringBootTest
public class MybatisPlusEnumTest {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void test(){
        User user= new User();
        user.setName("admin");
        user.setAge(22);
        user.setSex(SexEnum.MALE);
    }
}

八、代码生成器

官方地址：代码生成器（新） | MyBatis-Plus (baomidou.com)

mybatis-plus-generator 3.5.1以下版本：代码生成器（旧） | MyBatis-Plus (baomidou.com)

1、引入依赖

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.5.1</version>
        </dependency>
        <dependency>
            <groupId>org.freemarker</groupId>
            <artifactId>freemarker</artifactId>
            <version>2.3.31</version>
        </dependency>

2、快速生成

执行方法，会自动在在配置的目录下生成文件

public class FastAutoGeneratorTest {
    public static void main(String[] args) {
        FastAutoGenerator.create("jdbc:mysql://127.0.0.1:3306/mybatis_plus?characterEncoding=utf-8&userSSL=false", "root", "123456")
                        .globalConfig(builder -> {
                            builder.author("HUA") // 设置作者
                                    // .enableSwagger() // 开启 swagger 模式
                                    .fileOverride() // 覆盖已生成文件
                                    .outputDir("D://mybatis_plus"); // 指定输出目录
                        })
                        .packageConfig(builder -> {
                            builder.parent("com.hua") // 设置父包名
                                    .moduleName("mybatisplus") // 设置父包模块名
                                    .pathInfo(Collections.singletonMap(OutputFile.mapperXml, "D://mybatis_plus"));
                        // 设置mapperXml生成路径
                        })
                        .strategyConfig(builder -> {
                            builder.addInclude("t_user") // 设置需要生成的表名
                                    .addTablePrefix("t_", "c_"); // 设置过滤表前缀
                        })
                        .templateEngine(new FreemarkerTemplateEngine()) // 使用Freemarker引擎模板，默认的是Velocity引擎模板
                        .execute();
    }

}

九、多数据源

适用于多种场景：纯粹多库、读写分离、一主多从、混合模式等

模拟一个纯粹多库的一个场景:

创建两个库，分别为：mybatis_plus（以前的库）与mybatis_plus_1（新建），
将 mybatis_plus 库的 t_product表移动到 mybatis_plus_1 库，这样每个库一张表，
通过一个测试用例分别获取用户数据与商品数据，如果获取到说明多库模拟成功

1、创建数据库及表

创建数据库mybatis_plus_1 和表product

CREATE DATABASE `mybatis_plus_1` /*!40100 DEFAULT CHARACTER SET utf8mb4 */;
use `mybatis_plus_1`;
CREATE TABLE t_product
(
id BIGINT(20) NOT NULL COMMENT '主键ID',
name VARCHAR(30) NULL DEFAULT NULL COMMENT '商品名称',
price INT(11) DEFAULT 0 COMMENT '价格',
version INT(11) DEFAULT 0 COMMENT '乐观锁版本号',
PRIMARY KEY (id)
);

添加测试数据

INSERT INTO product (id, NAME, price) VALUES (1, '笔记本', 100);

删除mybatis_plus库的 t_product表

use mybatis_plus;
DROP TABLE IF EXISTS t_product;

2、引入依赖

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
            <version>3.5.0</version>
        </dependency>

3、配置多数据源

在application.yml中配置

spring:
# 配置数据源信息
  datasource:
    dynamic:
# 设置默认的数据源或者数据源组,默认值即为master
      primary: master
# 严格匹配数据源,默认false.true未匹配到指定数据源时抛异常,false使用默认数据源
      strict: false
      datasource:
        master:
          url: jdbc:mysql://localhost:3306/mybatis_plus?characterEncoding=utf-8&useSSL=false
          driver-class-name: com.mysql.cj.jdbc.Driver
          username: root
          password: 123456
        slave_1:
          url: jdbc:mysql://localhost:3306/mybatis_plus_1?characterEncoding=utf-8&useSSL=false
          driver-class-name: com.mysql.cj.jdbc.Driver
          username: root
          password: 123456

# 配置MyBatis日志
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

4、创建service

创建用户service

public interface UserService extends IService<User> {
}

@DS注解指定所操作的数据源

@Service
@DS("master")
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
}

创建商品service

public interface ProductService extends IService<Product> {
}

@Service
@DS("slave_1")
public class ProductServiceImpl extends ServiceImpl<ProductMapper, Product> implements ProductService {
}

测试多数据源

@SpringBootTest
class MybatisPlusDatasourceApplicationTests {

    @Autowired
    private UserService userService;
    @Autowired
    private ProductService productService;

    @Test
    public void test(){
        System.out.println(userService.getById(1));
        System.out.println(productService.getById(1));
    }

}

测试结果：顺利获取数据

十、MybatisX快速开发插件

MyBatis-Plus为我们提供了强大的mapper和service模板，能够大大的提高开发效率，但在开发过程中，MyBatis-Plus并不能为我们解决所有问题，例如一些复杂的SQL，多表联查，就需要自己去编写代码和SQL语句，这个时候可以使用MyBatisX插件

MyBatisX一款基于 IDEA 的快速开发插件，为效率而生

官方地址：MybatisX快速开发插件 | MyBatis-Plus (baomidou.com)

安装MybatisX插件

File -> Settings -> Plugins -> Browse Repositories 搜索并安装 MybatisX，安装完成后重启IDEA

功能：

XML跳转

在XXXMapper中，点击侧边的红色小鸟图标，可以从mapper接口快速跳转到相应的映射文件

在XXXMapper.xml中，点击侧边的蓝色小鸟图标，可以从映射文件快速跳转到对应的 mapper接口

代码快速生成

需要先在IDEA中配置数据源

填写数据库连接相关信息

高版本需要设置时区

配置完成后，在数据表右键使用MybatisX代码生成

生成的文件及结构

快速生成CRUD

以生成新增为例，生成查询、修改、删除方法同理

输入方法名 insertXXX，可以选择MybatisX提供的模板

选择方法名按Alt+Enter选择生成内容，方法自动补全并会在映射文件中生成相应的SQL