Bootstrap

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

目录

一、Mybaits-Plus简介

​二、入门案例

三、基本CRUD

四、常用注解

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

六、Mybatis-Plus插件

七、通用枚举 

八、代码生成器

九、多数据源

十、MybatisX快速开发插件


一、Mybaits-Plus简介

1、简介

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

支持任何能使用 Mybatis 进行 CRUD, 并且支持标准 SQL 的数据库

官方地址:MyBatis-Plus (baomidou.com)

2、特性

​二、入门案例

1、开发环境

  • IDE:IntelliJ IDEA 2021.2.3
  • JDK:JDK 8+
  • 构建工具:maven 3.6.3
  • MySQL版本:MySQL 5.7
  • Spring Boot:2.6.6
  • MyBatis-Plus:3.5.1

2、创建数据库及表

创建表

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

注意:

  1. 这里的 url 使用了 ?serverTimezone=Hongkong 后缀,因为Spring Boot 2.1 集成了 8.0版本的jdbc驱动,这个版本的 jdbc 驱动需要添加这个后缀
  2. 这里的 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

;