【Plus】三、BaseMapper

1、BaseMapper接口

点击 BaseMapper 访问官网！

/**
 * Mapper 继承该接口后，无需编写 mapper.xml 文件，即可获得CRUD功能
 * 
这个 Mapper 支持 id 泛型
 *
 * @author hubin
 * @since 2016-01-23
 */
public interface BaseMapper<T> extends Mapper<T> {

    /**
     * 插入一条记录
     *
     * @param entity 实体对象
     */
    int insert(T entity);

    /**
     * 根据 ID 删除
     *
     * @param id 主键ID
     */
    int deleteById(Serializable id);

    /**
     * 根据实体(ID)删除
     *
     * @param entity 实体对象
     * @since 3.4.4
     */
    int deleteById(T entity);

    /**
     * 根据 columnMap 条件，删除记录
     *
     * @param columnMap 表字段 map 对象
     */
    int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

    /**
     * 根据 entity 条件，删除记录
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
     */
    int delete(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

    /**
     * 删除（根据ID或实体 批量删除）
     *
     * @param idList 主键ID列表或实体列表(不能为 null 以及 empty)
     */
    int deleteBatchIds(@Param(Constants.COLLECTION) Collection<?> idList);

    /**
     * 根据 ID 修改
     *
     * @param entity 实体对象
     */
    int updateById(@Param(Constants.ENTITY) T entity);

    /**
     * 根据 whereEntity 条件，更新记录
     *
     * @param entity        实体对象 (set 条件值,可以为 null)
     * @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
     */
    int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);

    /**
     * 根据 ID 查询
     *
     * @param id 主键ID
     */
    T selectById(Serializable id);

    /**
     * 查询（根据ID 批量查询）
     *
     * @param idList 主键ID列表(不能为 null 以及 empty)
     */
    List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);

    /**
     * 查询（根据 columnMap 条件）
     *
     * @param columnMap 表字段 map 对象
     */
    List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

    /**
     * 根据 entity 条件，查询一条记录
     * 
查询一条记录，例如 qw.last("limit 1") 限制取一条记录, 注意：多条数据会报异常
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    default T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper) {
        List<T> ts = this.selectList(queryWrapper);
        if (CollectionUtils.isNotEmpty(ts)) {
            if (ts.size() != 1) {
                throw ExceptionUtils.mpe("One record is expected, but the query result is multiple records");
            }
            return ts.get(0);
        }
        return null;
    }

    /**
     * 根据 Wrapper 条件，判断是否存在记录
     *
     * @param queryWrapper 实体对象封装操作类
     * @return
     */
    default boolean exists(Wrapper<T> queryWrapper) {
        Long count = this.selectCount(queryWrapper);
        return null != count && count > 0;
    }

    /**
     * 根据 Wrapper 条件，查询总记录数
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    Long selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

    /**
     * 根据 entity 条件，查询全部记录
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

    /**
     * 根据 Wrapper 条件，查询全部记录
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

    /**
     * 根据 Wrapper 条件，查询全部记录
     * 
注意： 只返回第一个字段的值
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

    /**
     * 根据 entity 条件，查询全部记录（并翻页）
     *
     * @param page         分页查询条件（可以为 RowBounds.DEFAULT）
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    <P extends IPage<T>> P selectPage(P page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

    /**
     * 根据 Wrapper 条件，查询全部记录（并翻页）
     *
     * @param page         分页查询条件
     * @param queryWrapper 实体对象封装操作类
     */
    <P extends IPage<Map<String, Object>>> P selectMapsPage(P page, @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
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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

2、测试

2.1、insert(T): int

User user = new User(null, "Ami", 20, "999@mm.com");
System.out.println("结果：" + userMapper.insert(user));
System.out.println(user);
1
2
3

==>  Preparing: INSERT INTO user ( id, name, age, email ) VALUES ( ?, ?, ?, ? )
==> Parameters: 1583712489828356098(Long), Ami(String), 20(Integer), 999@mm.com(String)
<==    Updates: 1
结果：1
User(id=1583712489828356098, name=Ami, age=20, email=999@mm.com)
1
2
3
4
5

第一次用的小伙伴肯定很好奇，我没有给表主键设置自增，我也没给主键赋值，为何主键会有值呢？

MP默认使用雪花算法给主键赋值

2.2、deleteById(Serializable): int

System.out.println("结果：" + userMapper.deleteById(1583712489828356098L));
1

==>  Preparing: DELETE FROM user WHERE id=?
==> Parameters: 1583712489828356098(Long)
<==    Updates: 1
结果：1
1
2
3
4

2.3、deleteById(T): int

User user = new User(1583717556941848577L, null, null, null);
System.out.println("结果：" + userMapper.deleteById(user));
1
2

结果与2.2如出一辙

2.4、deleteByMap(Map): int

Map<String, Object> map = new HashMap<>();
map.put("name", "张三");
map.put("age", 20);
System.out.println("结果：" + userMapper.deleteByMap(map));
1
2
3
4

==>  Preparing: DELETE FROM user WHERE name = ? AND age = ?
==> Parameters: 张三(String), 20(Integer)
<==    Updates: 0
结果：0
1
2
3
4

2.5、delete(Wrapper): int

System.out.println("结果：" + userMapper.delete(new QueryWrapper<User>().eq("id", 1L)));
1

==>  Preparing: DELETE FROM user WHERE (id = ?)
==> Parameters: 1(Long)
<==    Updates: 1
结果：1
1
2
3
4

2.6、deleteBatchIds(Collection): int

System.out.println("结果：" + userMapper.deleteBatchIds(Arrays.asList(1L, 2L, 3L)));
1

==>  Preparing: DELETE FROM user WHERE id IN ( ? , ? , ? )
==> Parameters: 1(Long), 2(Long), 3(Long)
<==    Updates: 3
结果：3
1
2
3
4

2.7、updateById(T): int

User user = new User();
user.setId(4L);
user.setName("嘎嘎嘎");
user.setAge(3);
user.setEmail("gagaga@gaga.com");
System.out.println("结果：" + userMapper.updateById(user));
1
2
3
4
5
6

==>  Preparing: UPDATE user SET name=?, age=?, email=? WHERE id=?
==> Parameters: 嘎嘎嘎(String), 3(Integer), gagaga@gaga.com(String), 4(Long)
<==    Updates: 1
结果：1
1
2
3
4

2.8、update(T, Wrapper): int

User user = new User();
user.setId(400L);
user.setName("咕咕咕");
user.setAge(16);
user.setEmail("gugugu@gugu.com");
System.out.println("结果：" + userMapper.update(user, 
                                             new UpdateWrapper<User>().eq("id", 4L)));
1
2
3
4
5
6
7

==>  Preparing: UPDATE user SET name=?, age=?, email=? WHERE (id = ?)
==> Parameters: 咕咕咕(String), 16(Integer), gugugu@gugu.com(String), 4(Long)
<==    Updates: 1
结果：1
1
2
3
4

2.9、selectById(Serializable): T

System.out.println("结果：" + userMapper.selectById(4L));
1

==>  Preparing: SELECT id,name,age,email FROM user WHERE id=?
==> Parameters: 4(Long)
<==    Columns: id, name, age, email
<==        Row: 4, 嘎嘎嘎, 3, gagaga@gaga.com
<==      Total: 1
结果：User(id=4, name=嘎嘎嘎, age=3, email=gagaga@gaga.com)
1
2
3
4
5
6

2.10、selectBatchIds(Collection idList): List

userMapper.selectBatchIds(Arrays.asList(1L, 2L, 3L)).forEach(System.out::println);
1

==>  Preparing: SELECT id,name,age,email FROM user WHERE id IN ( ? , ? , ? )
==> Parameters: 1(Long), 2(Long), 3(Long)
<==    Columns: id, name, age, email
<==        Row: 1, lili, 19, lili@lili.com
<==        Row: 2, 小明, 12, xxx@xxx.com
<==        Row: 3, 小黑, 20, hhi@hi.com
<==      Total: 3
User(id=1, name=lili, age=19, email=lili@lili.com)
User(id=2, name=小明, age=12, email=xxx@xxx.com)
User(id=3, name=小黑, age=20, email=hhi@hi.com)
1
2
3
4
5
6
7
8
9
10

2.11、selectByMap(Map): List

Map<String, Object> map = new HashMap<>();
map.put("name", "嘎嘎嘎");
map.put("age", 3);
userMapper.selectByMap(map).forEach(System.out::println);
1
2
3
4

==>  Preparing: SELECT id,name,age,email FROM user WHERE name = ? AND age = ?
==> Parameters: 嘎嘎嘎(String), 3(Integer)
<==    Columns: id, name, age, email
<==        Row: 4, 嘎嘎嘎, 3, gagaga@gaga.com
<==      Total: 1
User(id=4, name=嘎嘎嘎, age=3, email=gagaga@gaga.com)
1
2
3
4
5
6

2.12、selectOne(Wrapper): T

System.out.println("结果：" + userMapper.selectOne(new QueryWrapper<User>().eq("id", 1L)));
1

==>  Preparing: SELECT id,name,age,email FROM user WHERE (id = ?)
==> Parameters: 1(Long)
<==    Columns: id, name, age, email
<==        Row: 1, lili, 19, lili@lili.com
<==      Total: 1
结果：User(id=1, name=lili, age=19, email=lili@lili.com)
1
2
3
4
5
6

2.13、exists(Wrapper): boolean

System.out.println("结果：" + userMapper.exists(new QueryWrapper<User>().eq("id", 1L)));
1

==>  Preparing: SELECT COUNT( * ) FROM user WHERE (id = ?)
==> Parameters: 1(Long)
<==    Columns: COUNT( * )
<==        Row: 1
<==      Total: 1
结果：true
1
2
3
4
5
6

2.14、selectCount(Wrapper): Long

System.out.println("结果：" + userMapper.selectCount(new QueryWrapper<User>().eq("id", 1L)));
1

==>  Preparing: SELECT COUNT( * ) FROM user WHERE (id = ?)
==> Parameters: 1(Long)
<==    Columns: COUNT( * )
<==        Row: 1
<==      Total: 1
结果：1
1
2
3
4
5
6

2.15、selectList(Wrapper): List

userMapper.selectList(new QueryWrapper<User>().eq("age", 20)).forEach(System.out::println);
1

==>  Preparing: SELECT id,name,age,email FROM user WHERE (age = ?)
==> Parameters: 20(Integer)
<==    Columns: id, name, age, email
<==        Row: 3, 小黑, 20, hhi@hi.com
<==        Row: 1583722107052756994, Ami, 20, 999@mm.com
<==        Row: 1583722317866962946, 王五, 20, wangwu@mm.com
<==      Total: 3
User(id=3, name=小黑, age=20, email=hhi@hi.com)
User(id=1583722107052756994, name=Ami, age=20, email=999@mm.com)
User(id=1583722317866962946, name=王五, age=20, email=wangwu@mm.com)
1
2
3
4
5
6
7
8
9
10

2.16、selectMaps(Wrapper): List>

userMapper.selectMaps(new QueryWrapper<User>().eq("age", 20)).forEach(System.out::println);
1

结果与2.15如出一辙

2.17、selectObjs(Wrapper): List