【MybatisPlus】CRUD操作，映射匹配兼容性，ID生成策略，逻辑删除，乐观锁

MybatisPlus简介

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

MyBatisPlus的官网为:https://mp.baomidou.com/

从这张图中我们可以看出MP旨在成为MyBatis的最好搭档，而不是替换MyBatis,所以可以理解为MP是MyBatis的一套增强工具，它是在MyBatis的基础上进行开发的，我们虽然使用MP但是底层依然是MyBatis的东西，也就是说我们也可以在MP中写MyBatis的内容。

一、数据层基本的开发

1. 引入jar包

如果想要使用mybatis-plus，要导入mybatis-plus-boot-starter和数据库连接的包

 
 <dependency>
     <groupId>com.mysqlgroupId>
     <artifactId>mysql-connector-jartifactId>
     <scope>runtimescope>
 dependency>
 
 <dependency>
     <groupId>com.baomidougroupId>
     <artifactId>mybatis-plus-boot-starterartifactId>
     <version>3.5.1version>
 dependency>
1
2
3
4
5
6
7
8
9
10
11
12

注意

• 使用mybatis-plus-boot-starter就不需要引入mybatis的依赖了，它里面已经帮我们引过了。
• 也就是说mybatis-plus中引入过mybatis了，就必须要配置数据源信息。
  

2. 配置数据源

# 配置数据源
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db1?useSSL=false&&characterEncoding=utf-8&&serverTimezone=Asia/Shanghai
    hikari:
      username: root
      password: 1234
1
2
3
4
5
6
7
8

这里没有引入数据源，使用的springboot自带的hikari数据源，也可以自己引入druid数据源。

3. 编写实体类

@Getter
@Setter
@TableName("tbl_book")
public class Book implements Serializable {

    private static final long serialVersionUID = 1L;

    @TableId(value = "id", type = IdType.AUTO)
    private Integer id;

    private String type;

    private String name;

    private String description;
    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4. 创建Dao接口

@Mapper
public interface BookMapper extends BaseMapper<Book> {

}
1
2
3
4

说明: Dao接口要想被容器扫描到，有两种解决方案:

• 方案一:在Dao接口上添加@Mapper注解，并且确保Dao处在引导类所在包
  或其子包中
  • 该方案的缺点是需要在每一Dao接口中添加注解
• 方案二:在引导类上添加@MapperScan注解，其属性为所要扫描的Dao所在包
  • 该方案的好处是只需要写一次，则指定包下的所有Dao接口都能被扫描到，@Mapper就可以不写。

5. 测试

@SpringBootTest
class MpDemoApplicationTests {

    @Autowired
    private BookMapper bookMapper;

    @Test
    void contextLoads() {
        List<Book> books = bookMapper.selectList(null);
        System.out.println("books = " + books);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

跟之前整合MyBatis相比，你会发现我们不需要在DAO接口中编写方法和SQL语句了，只需要继承BaseMapper接口即可。整体来说简化很多。

二、数据层CRUD使用

1. 查询

2. 添加

3. 删除

4. 修改

• 上面是mybatis-plus提供数据层的方法。想要完成相应的操作，只需要传入相应的类型就可以了。

5. 业务层使用MP

业务层接口
业务层接口只需要继承IService接口，记得加泛型。否则不知道要返回什么样类型的数据

public interface BookService extends IService<Book> {

}
1
2
3

业务层实现类
业务层实现类需要继承ServiceImpl，并实现BookService 接口
ServiceImpl要传入数据层使用的接口和实体类类型

@Service
public class BookServiceImp extends ServiceImpl<BookMapper, Book> implements BookService {

}
1
2
3
4

• 如果业务层也是使用MP的话，MP业务层的方法名与数据层的方法名有所改变。但是传递的参数大致都一样，几乎都是见名知意（例如查询是list开头了，添加的时候使用save开头，删除为remove开头），自己需要相关操作时输入个开头，根据提示找方法，里面的方法能完成什么功能一目了然

6. 分页查询

分页查询我们使用MP自动生成的业务层（service），在controller中实现。

1. controller编写接口

    @Autowired
    private BookService bookService;
    
    @GetMapping("getBooksByPage")
    public Result getBooksByPage(Integer limit, Integer size) {
        //封装实现类，将前端传入的limit和size传进去就行了。
        IPage<Book> page = new Page<>(limit, size);
        
        //调用业务层的分页方法，需要一个Page的参数，我们自己封装一个Page的实现类。
        IPage<Book> books = bookService.page(page);
        //将查询出的结果返回
        return new Result(200,"",books);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

2. 配置分页拦截器

如果只写一个接口，查询的结果并不是我们想要的结果，他会把所有的结果全部都查询出来。这是因为我们还要写一个分页拦截器。

意思就是如果不写分页拦截器，它在查询的时候就不会帮我们在sql语句中拼接 limit 语句

@Configuration
public class MpConfig {
    @Bean
    public MybatisPlusInterceptor mpInterceptor() {
        //1.定义Mp拦截器
        MybatisPlusInterceptor mpInterceptor = new MybatisPlusInterceptor();
        // 添加分页拦截器
        mpInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return mpInterceptor;
    }
}
1
2
3
4
5
6
7
8
9
10
11

添加拦截器就在这里面添加就行了，使用addInnerInterceptor方法，下面的乐观锁拦截器也是这样添加的。

3. 浏览器中查询结果：
   

Page里面不仅封装了我们想要的分页数据还封装了总条数total，总页数pages。一条简单的语句就完成了我们之前那么多复杂的操作。十分的方便。

分页查询时也可以带条件查询，MP也帮我们做了，只需要再传入一个queryWrapper参数就行了

Wrapper的用法就在下面👇

三、条件查询

在进行查询的时候，我们的入口是在Wrapper这个类上，因为它是一个接口，所以我们需要去找它对应的实现类，关于实现类也有很多，说明我们有多种构建查询条件对象的方式

1. 条件查询的方式

1. QueryWrapper

@SpringBootTest
class Mybatisplus02DqlApplicationTests {

    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll(){
        QueryWrapper qw = new QueryWrapper();
        qw.lt("age",18);
        List<User> userList = userDao.selectList(qw);
        System.out.println(userList);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

lt: 小于(<) ,最终的sql语句为

SELECT id,name,password,age,tel FROM user WHERE (age < ?)
1

第一种方式介绍完后，有个小问题就是在写条件的时候，容易出错，比如age写错，就会导致查询不成功

2. QueryWrapper的基础上使用lambda

@SpringBootTest
class Mybatisplus02DqlApplicationTests {

    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll(){
        QueryWrapper<User> qw = new QueryWrapper<User>();
        qw.lambda().lt(User::getAge, 10);//添加条件
        List<User> userList = userDao.selectList(qw);
        System.out.println(userList);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

但是qw后面多了一层lambda()调用，可以用LambdaQueryWrapper来代替

3. LambdaQueryWrapper

@SpringBootTest
class Mybatisplus02DqlApplicationTests {

    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll(){
        LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
        lqw.lt(User::getAge, 10);
        List<User> userList = userDao.selectList(lqw);
        System.out.println(userList);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2. 多条件查询

@SpringBootTest
class Mybatisplus02DqlApplicationTests {

    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll(){
        LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
        lqw.lt(User::getAge, 30);
        lqw.gt(User::getAge, 10);
        List<User> userList = userDao.selectList(lqw);
        System.out.println(userList);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

多条件只需要往后面继续加条件就行了。
gt：大于(>),最终的SQL语句为
SELECT id,name,password,age,tel FROM user WHERE (age < ? AND age > ?)

构建多条件的时候，可以支持链式编程

LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
lqw.lt(User::getAge, 30).gt(User::getAge, 10);
List<User> userList = userDao.selectList(lqw);
System.out.println(userList);
1
2
3
4

需求:查询数据库表中，年龄小于10或年龄大于30的数据

@SpringBootTest
class Mybatisplus02DqlApplicationTests {

    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll(){
        LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
        lqw.lt(User::getAge, 10).or().gt(User::getAge, 30);
        List<User> userList = userDao.selectList(lqw);
        System.out.println(userList);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• or()就相当于我们sql语句中的or关键字,不加默认是and，最终的sql语句为:

SELECT id,name,password,age,tel FROM user WHERE (age < ? OR age > ?)
1

四、映射匹配兼容性

1. 表字段与编码属性设计不同步

当表的列名和模型类的属性名发生不一致，就会导致数据封装不到模型对象，这个时候就需要其中一方做出修改，那如果前提是两边都不能改又该如何解决?

MP给我们提供了一个注解@TableField,使用该注解可以实现模型类属性名和表的列名之间的映射关系

2. 编码中添加了数据库中未定义的属性

当模型类中多了一个数据库表不存在的字段，就会导致生成的sql语句中在select的时候查询了数据库不存在的字段，程序运行就会报错，错误信息为:

Unknown column ‘多出来的字段名称’ in ‘field list’

具体的解决方案用到的还是@TableField注解，它有一个属性叫exist，设置该字段是否在数据库表中存在，如果设置为false则不存在，生成sql语句查询的时候，就不会再查询该字段了。

3. 采用默认查询开放了更多的字段查看权限

查询表中所有的列的数据，就可能把一些敏感数据查询到返回给前端，这个时候我们就需要限制哪些字段默认不要进行查询。解决方案是@TableField注解的一个属性叫select，该属性设置默认是否需要查询该字段的值，true(默认值)表示默认查询该字段，false表示默认不查询该字段。

查询时将pwd隐藏

@Data
@TableName("tbl_user")
public class User {
    private Long id;
    private String name;
    @TableField(value="pwd",select=false)
    private String password;
    private Integer age;
    private String tel;
    @TableField(exist=false)
    private Integer online;
}
1
2
3
4
5
6
7
8
9
10
11
12

4. 表名与编码开发设计不同步

该问题主要是表的名称和模型类的名称不一致，导致查询失败，这个时候通常会报如下错误信息:

Table ‘databaseName.tableNaem’ doesn’t exist,翻译过来就是数据库中的表不存在。

解决方案是使用MP提供的另外一个注解@TableName来设置表与模型类之间的对应关系。

五、ID生成策略

• INPUT: 不设置id生成策略，MP不自动生成，需要用户手动设置，但是手动设置第一个问题是容易出现相同的ID造成主键冲突，为了保证主键不冲突就需要做很多判定，实现起来比较复杂
• AUTO:数据库ID自增,这种策略适合在数据库服务器只有1台的情况下使用,不可作为分布式ID使用
• ASSIGN_UUID:可以在分布式的情况下使用，而且能够保证唯一，但是生成的主键是32位的字符串，长度过长占用空间而且还不能排序，查询性能也慢
• ASSIGN_ID:可以在分布式的情况下使用，生成的是Long类型的数字，可以排序性能也高，但是生成的策略和服务器时间有关，如果修改了系统时间就有可能导致出现重复主键

每一种主键策略都有自己的优缺点，根据自己项目业务的实际情况来选择使用才是最明智的选择。

@Getter
@Setter
public class Dept implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 主键，部门编号
     */
    @TableId(value = "deptno", type = IdType.AUTO)
    private Long deptno;

    private String dname;

    private String loc;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

通过在yml配置文件中配置，可以全局生效。配置完成后，每个模型类的主键ID策略都将成为assign_id.

mybatis-plus:
  global-config:
    db-config:
    	id-type: assign_id
1
2
3
4

设置表的前缀内容，这样MP就会拿 tbl_加上模型类的首字母小写，就刚好组装成数据库的表名。

mybatis-plus:
  global-config:
    db-config:
    	table-prefix: tbl_
1
2
3
4

六、逻辑删除

• 物理删除:业务数据从数据库中丢弃，执行的是delete操作
• 逻辑删除:为数据设置是否可用状态字段，删除时设置状态字段为不可用状态，数据保留在数据库中，执行的是update操作

MP中逻辑删除十分简单

1. 修改数据库表添加deleted列

字段名可以任意，内容也可以自定义，比如0代表正常，1代表删除，可以在添加列的同时设置其默认值为0正常。

2. 实体类添加属性

@Getter
@Setter
public class Dept implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 主键，部门编号
     */
    @TableId(value = "deptno", type = IdType.AUTO)
    private Integer deptno;

    private String dname;

    private String loc;

    @TableLogic(value="0",delval="1")
    //value为正常数据的值，delval为删除数据的值
    private Integer deleted;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3. 测试删除

@SpringBootTest
class MpDemoApplicationTests {

    @Autowired
    private DeptMapper deptMapper;

    @Test
    void testDelete(){
        deptMapper.deleteById(4L);
    }
}
1
2
3
4
5
6
7
8
9
10
11

MP中添加逻辑删除之后，对查询也是有影响的

注意：

• 只对mybatis-plus中的语句生效。
• 要想查到已经删除过的数据，可以自己写sql语句

如果每个表都要有逻辑删除，那么就需要在每个模型类的属性上添加@TableLogic注解，在配置文件中添加全局配置，如下:

mybatis-plus:
  global-config:
    db-config:
      # 逻辑删除字段名
      logic-delete-field: deleted
      # 逻辑删除字面值：未删除为0
      logic-not-delete-value: 0
      # 逻辑删除字面值：删除为1
      logic-delete-value: 1
1
2
3
4
5
6
7
8
9

七、乐观锁

乐观锁主要解决的问题是当要更新一条记录的时候，希望这条记录没有被别人更新。

业务并发现象带来的问题:秒杀
假如有100个商品或者票在出售，为了能保证每个商品或者票只能被一个人购买，如何保证不会出现超买或者重复卖

乐观锁是在修改的时候把某一个字段作为锁，修改的时候连带修改字段的值，并判断值是否发生变化，如果值已经发生变化就认为别人已经对这条数据做过修改，自己就不能再操作了。

1. 数据库表添加列

2. 在模型类中添加对应的属性

@Getter
@Setter
public class Dept implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 主键，部门编号
     */
    @TableId(value = "deptno", type = IdType.AUTO)
    private Long deptno;

    private String dname;

    private String loc;

    @TableLogic(value="0",delval="1")
    //value为正常数据的值，delval为删除数据的值
    private Integer deleted;

    @Version
    private Integer version;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

3. 添加乐观锁的拦截器

@Configuration
public class MpConfig {
    @Bean
    public MybatisPlusInterceptor mpInterceptor() {
        //1.定义Mp拦截器
        MybatisPlusInterceptor mpInterceptor = new MybatisPlusInterceptor();
        //2.添加乐观锁拦截器
        mpInterceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return mpInterceptor;
    }
}
1
2
3
4
5
6
7
8
9
10
11

4. 测试

做修改的时候实体类中version的值必须要传，否则不能实现乐观锁的效果