MyBatis-Plus入门使用小案例

MyBatis-Plus入门使用

第一步：创建数据表

第二步：创建类

第三步：创建mapper类，用于操作数据表people

public interface PeopleMapper extends BaseMapper<People> {
    
}
1
2
3

第四步：创建config类，标记mapper扫描包

@Configuration
@MapperScan("com.gis507.mpdemp.mapper")
public class MpConfigure {}
1
2
3

其中@Configuration是声明为配置类，@MapperScan是声明扫描包

第五步：测试是否成功

在Test中，自动注入PeopleMapper，用于操作表people

5.1 插入数据

class Test {
    @Autowired
    private PeopleMapper peopleMapper;

    @Test
    void testPeopleInsert() {
        People people = new People();
        people.setId(1L);
        people.setName("Leon");
        people.setAge(18);
        people.setEmail("leon@163.com");
        peopleMapper.insert(people);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

5.2 查询数据

5.2.1 查询全部数据

class Test {
    @Test
    void testPeopleTest() {
        peopleMapper.selectList(null);
    }
}
1
2
3
4
5
6

5.2.2 查询单条数据

class Test {
    @Test
    void testPeopleTest() {
        peopleMapper.selectById(1L);
    }
}
1
2
3
4
5
6

5.2.3 查询多条数据

import java.util.Arrays;

class Test {
    @Test
    void testPeopleTest() {
        peopleMapper.selectBatchIds(Arrays.asList(1,2,3));
    }
}
1
2
3
4
5
6
7
8

5.2.4 自定义查询

QueryWrapper对象

class Test{
    @Test
    void testSelectQuery(){
        // create queryWrapper object
        QueryWrapper<People> oqw = new QueryWrapper<>();

        // use querwarapper set args
        // ge, gt, le, lt
        // select age >= 30
//        oqw.ge("age", 30);

        // eq, ne
//        oqw.eq("age", 40);
//        oqw.ne("age", 40);

        // between, notBetween
//        oqw.between("age", 30,80);

        // allEq

        // like, not like
//        oqw.like("name", "ci");

        // orderBy

        // last
//        oqw.last("limit 1");

        // select confirm column
        oqw.select("id", "name");


        List<People> people = peopleMapper.selectList(oqw);
        System.out.println(people);
    }
}
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

5.3 修改数据

class Test{
    void updateTest(){
        People people = new People();
        people.setId(6L);
        people.setAge(30);
        int row = userMapper.updateById(people);
        System.out.println(row);
    }
}
1
2
3
4
5
6
7
8
9

第六步：自动实现表的字段变化

6.1 自动生成创建时间数据和修改时间数据

在表中增加两个字段：create_time和update_time,在插入数据时候，可以自动的补充上create_time和update_time数据；
在people.setCreateTime(new Date())这种方法肯定是可以实现的，但是希望通过MyBatis提供的方式自动实现

1. 在类中增加createTime和updateTime属性

import java.util.Date;

class People {
    // xxxxx
    private Date createTime;
    private Date updateTime;
}
1
2
3
4
5
6
7

2. 在属性上增加注解@TableField

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

    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;
}
1
2
3
4
5
6
7

3. 声明一个类handle，继承MetaObjectHandler类，重写里面的方法

@Component
public class MyMetaObjectHandle implements MetaObjectHandler {

    // use mp to insert, will use this function
    @Override
    public void insertFill(MetaObject metaObject) {
        this.setFieldValByName("createTime", new Date(), metaObject);
        this.setFieldValByName("updateTime", new Date(), metaObject);
    }

    // use mp to update, will run this function
    @Override
    public void updateFill(MetaObject metaObject) {
        this.setFieldValByName("updateTime", new Date(), metaObject);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

6.2 实现数据版本标记

当一条数据被更改后，需要把版本号放在字段内，用作标记
MyBatisPlus已经提供了Version的功能

1. 在类中增加属性version，并添加注解@TableField和@Version

class People{
    @Version
    @TableField(fill = FieldFill.INSERT)
    private Integer version;
}
1
2
3
4
5

2. 除此之外，还需要声明一个配置类，将乐观锁的插件加载进去

@Configuration
public class MpConfigure {

    // 乐观锁插件
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }
}
1
2
3
4
5
6
7
8
9

3. 在Handle类中，将关于version的处理添加到方法中

@Component
public class MyMetaObjectHandle implements MetaObjectHandler {

    // use mp to insert, will use this function
    @Override
    public void insertFill(MetaObject metaObject) {
        this.setFieldValByName("createTime", new Date(), metaObject);
        this.setFieldValByName("updateTime", new Date(), metaObject);
        // 默认从1开始
        this.setFieldValByName("version", 1, metaObject);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

上述这些配置完成后，在增加数据时候就会自动加入一个version，并且每次修改这条数据后，就会version+1
注意：要先查询，再改

class Test{
    @Test
    void testPeopleOpLock(){
        // 先查询
        People people = peopleMapper.selectById(3L);
        people.setName("faker");
        // 再改
        peopleMapper.updateById(people);
    }
}
1
2
3
4
5
6
7
8
9
10

第七步：实现逻辑删除

当一条数据删除的时候，物理删除的话直接delete就可以，但是当我们想要保存数据，但是还不显示的时候，就可以使用逻辑删除的方法

1. 增加一个deleted字段
   当数据删除，就将deleted改为1，否则为0；
2. 增加属性deleted，添加注释@TableLogic@TableField

class People{
    @TableLogic
    @TableField(fill = FieldFill.INSERT)
    private Integer deleted;
}
1
2
3
4
5

3. 加载逻辑删除插件到配置类中

@Configuration
public class MpConfigure {

    // logic delete
    @Bean
    public ISqlInjector sqlInjector() {
        return new LogicSqlInjector();
    }
}
1
2
3
4
5
6
7
8
9

测试：

class Test{
    @Test
    void testPeopleDelete(){
        peopleMapper.deleteById(1L);
    }
}
1
2
3
4
5
6

执行的结果语句：

-- Time：39 ms - ID：com.gis507.mpdemp.mapper.PeopleMapper.deleteById
-- Execute SQL：
    UPDATE
        people 
    SET
        deleted=1 
    WHERE
        id=1 
        AND deleted=0
1
2
3
4
5
6
7
8
9