前言
BaseMapper 是 Mybatis-Plus 提供的一个通用 Mapper 接口，它封装了一系列常用的数据库操作方法，包括增、删、改、查等。通过继承 BaseMapper，开发者可以快速地对数据库进行操作，而无需编写繁琐的 SQL 语句。
Mapper Interface：
- insert
- delete
- update
- select
泛型
T为任意实体对象
参数Serializable为任意类型主键Mybatis-Plus 不推荐使用复合主键约定每一张表都有自己的唯一 id 主键
对象Wrapper为条件构造器
一、insert
// 插入一条记录
int insert(T entity);
功能描述： 插入一条记录。
返回值： int，表示插入操作影响的行数，通常为 1，表示插入成功。
参数说明：
| 类型 | 参数名 | 描述 |
|---|---|---|
| T | entity | 实体对象 |
1. 示例（insert）
User user = new User();
user.setName("John Doe");
user.setEmail("john.doe@example.com");
int rows = userMapper.insert(user); // 调用 insert 方法
if (rows > 0) {
System.out.println("User inserted successfully.");
} else {
System.out.println("Failed to insert user.");
}
生成的 SQL:
INSERT INTO user (name, email) VALUES (?, ?)
通过上述示例，我们可以看到 insert 方法是如何在 Mapper 层进行插入操作的，以及它对应的 SQL 语句。这个方法简化了插入操作的实现，使得开发者无需手动编写 SQL 语句。
二、delete
// 根据 entity 条件，删除记录
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
// 删除（根据ID 批量删除）
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
// 根据 ID 删除
int deleteById(Serializable id);
// 根据 columnMap 条件，删除记录
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
功能描述： 删除符合条件的记录。
返回值： int，表示删除操作影响的行数，通常为 1，表示删除成功。
参数说明：
| 类型 | 参数名 | 描述 |
|---|---|---|
| Wrapper | wrapper | 实体对象封装操作类（可以为 null） |
| Collection<? extends Serializable> | idList | 主键 ID 列表(不能为 null 以及 empty) |
| Serializable | id | 主键 ID |
| Map<String, Object> | columnMap | 表字段 map 对象 |
1. 示例（delete）
// 假设有一个 QueryWrapper 对象，设置查询条件为 age > 25，删除满足条件的用户
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gt("age", 25);
int rows = userMapper.delete(queryWrapper); // 调用 delete 方法
if (rows > 0) {
System.out.println("Users deleted successfully.");
} else {
System.out.println("No users deleted.");
}
生成的 SQL:
DELETE FROM user WHERE age > 25
2. 示例（deleteBatchIds）
// 假设有一组 ID 列表，批量删除用户
List<Integer> ids = Arrays.asList(1, 2, 3);
int rows = userMapper.deleteBatchIds(ids); // 调用 deleteBatchIds 方法
if (rows > 0) {
System.out.println("Users deleted successfully.");
} else {
System.out.println("No users deleted.");
}
生成的 SQL:
DELETE FROM user WHERE id IN (1, 2, 3)
3. 示例（deleteById）
// 根据 ID 删除单个用户
int userId = 1;
int rows = userMapper.deleteById(userId); // 调用 deleteById 方法
if (rows > 0) {
System.out.println("User deleted successfully.");
} else {
System.out.println("No user deleted.");
}
生成的 SQL:
DELETE FROM user WHERE id = 1
4. 示例（deleteByMap）：
// 假设有一个 columnMap，设置查询条件为 age = 30，删除满足条件的用户
Map<String, Object> columnMap = new HashMap<>();
columnMap.put("age", 30);
int rows = userMapper.deleteByMap(columnMap); // 调用 deleteByMap 方法
if (rows > 0) {
System.out.println("Users deleted successfully.");
} else {
System.out.println("No users deleted.");
}
生成的 SQL:
DELETE FROM user WHERE age > 30
通过上述示例，我们可以看到 delete 系列方法是如何在 Mapper 层进行删除操作的，以及它们对应的 SQL 语句。这些方法提供了灵活的数据删除方式，可以根据不同的条件进行删除操作。
三、update
// 根据 whereWrapper 条件，更新记录
int update(@Param(Constants.ENTITY) T updateEntity, @Param(Constants.WRAPPER) Wrapper<T> whereWrapper);
// 根据 ID 修改
int updateById(@Param(Constants.ENTITY) T entity);
功能描述： 更新符合条件的记录。
返回值： int，表示更新操作影响的行数，通常为 1，表示更新成功。
参数说明：
| 类型 | 参数名 | 描述 |
|---|---|---|
| T | entity | 实体对象 (set 条件值,可为 null) |
| Wrapper | updateWrapper | 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句） |
1. 示例（update）
// 假设有一个 UpdateWrapper 对象，设置查询条件为 age > 25，更新满足条件的用户的邮箱
UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
updateWrapper.gt("age", 25);
User updateUser = new User();
updateUser.setEmail("new.email@example.com");
int rows = userMapper.update(updateUser, updateWrapper); // 调用 update 方法
if (rows > 0) {
System.out.println("Users updated successfully.");
} else {
System.out.println("No users updated.");
}
生成的 SQL:
UPDATE user SET email = ? WHERE age > 25
2. 示例（updateById）
// 假设要更新 ID 为 1 的用户的邮箱
User updateUser = new User();
updateUser.setId(1);
updateUser.setEmail("new.email@example.com");
int rows = userMapper.updateById(updateUser); // 调用 updateById 方法
if (rows > 0) {
System.out.println("User updated successfully.");
} else {
System.out.println("No user updated.");
}
生成的 SQL:
UPDATE user SET email = ? WHERE id = 1
通过上述示例，我们可以看到 update 系列方法是如何在 Mapper 层进行更新操作的，以及它们对应的 SQL 语句。这些方法提供了灵活的数据更新方式，可以根据不同的条件进行更新操作。
四、select
// 根据 ID 查询
T selectById(Serializable id);
// 根据 entity 条件，查询一条记录
T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 查询（根据ID 批量查询）
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
// 根据 entity 条件，查询全部记录
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 查询（根据 columnMap 条件）
List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
// 根据 Wrapper 条件，查询全部记录
List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录。注意： 只返回第一个字段的值
List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 entity 条件，查询全部记录（并翻页）
IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录（并翻页）
IPage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询总记录数
Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
功能描述： 查询符合条件的记录。
返回值： 查询结果，可能是实体对象、Map 对象或其他类型。
参数说明：
| 类型 | 参数名 | 描述 |
|---|---|---|
| Serializable | id | 主键 ID |
| Wrapper | queryWrapper | 实体对象封装操作类（可以为 null） |
| Collection<? extends Serializable> | idList | 主键 ID 列表(不能为 null 以及 empty) |
| Map<String, Object> | columnMap | 表字段 map 对象 |
| IPage | page | 分页查询条件（可以为 RowBounds.DEFAULT） |
1. 示例（selectById）
// 根据 ID 查询单个用户
int userId = 1;
User user = userMapper.selectById(userId); // 调用 selectById 方法
System.out.println("User: " + user);
生成的 SQL:
SELECT * FROM user WHERE id = 1
2. 示例（selectOne）
// 假设有一个 QueryWrapper 对象，设置查询条件为 age > 25，查询一条满足条件的用户
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gt("age", 25);
User user = userMapper.selectOne(queryWrapper); // 调用 selectOne 方法
System.out.println("User: " + user);
生成的 SQL:
SELECT * FROM user WHERE age > 25
3. 示例（selectBatchIds）
// 假设有一组 ID 列表，批量查询用户
List<Integer> ids = Arrays.asList(1, 2, 3);
List<User> users = userMapper.selectBatchIds(ids); // 调用 selectBatchIds 方法
for (User u : users) {
System.out.println("User: " + u);
}
生成的 SQL:
SELECT * FROM user WHERE id IN (1, 2, 3)
4. 示例（selectList）
// 假设有一个 QueryWrapper 对象，设置查询条件为 age > 25，查询所有满足条件的用户
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gt("age", 25);
List<User> users = userMapper.selectList(queryWrapper); // 调用 selectList 方法
for (User u : users) {
System.out.println("User: " + u);
}
生成的 SQL:
SELECT * FROM user WHERE age > 25
5. 示例（selectByMap）
// 假设有一个 columnMap，设置查询条件为 age = 30，查询满足条件的用户
Map<String, Object> columnMap = new HashMap<>();
columnMap.put("age", 30);
List<User> users = userMapper.selectByMap(columnMap); // 调用 selectByMap 方法
for (User u : users) {
System.out.println("User: " + u);
}
生成的 SQL:
SELECT * FROM user WHERE age = 30
6. 示例（selectMaps）
// 假设有一个 QueryWrapper 对象，设置查询条件为 age > 25，查询所有满足条件的用户，并将结果映射为 Map
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gt("age", 25);
List<Map<String, Object>> userMaps = userMapper.selectMaps(queryWrapper); // 调用 selectMaps 方法
for (Map<String, Object> userMap : userMaps) {
System.out.println("User Map: " + userMap);
}
生成的 SQL:
SELECT * FROM user WHERE age > 25
7. 示例（selectObjs）
// 假设有一个 QueryWrapper 对象，设置查询条件为 age > 25，查询所有满足条件的用户，但只返回每个记录的第一个字段的值
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gt("age", 25);
List<Object> userIds = userMapper.selectObjs(queryWrapper); // 调用 selectObjs 方法
for (Object userId : userIds) {
System.out.println("User ID: " + userId);
}
生成的 SQL:
SELECT id FROM user WHERE age > 25
8. 示例（selectPage）
// 假设要进行分页查询，每页显示10条记录，查询第1页，查询条件为 age > 25
IPage<User> page = new Page<>(1, 10);
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gt("age", 25);
IPage<User> userPage = userMapper.selectPage(page, queryWrapper); // 调用 selectPage 方法
List<User> userList = userPage.getRecords();
long total = userPage.getTotal();
System.out.println("Total users (age > 25): " + total);
for (User user : userList) {
System.out.println("User: " + user);
}
生成的 SQL:
SELECT * FROM user WHERE age > 25 LIMIT 10 OFFSET 0
9. 示例（selectMapsPage）
// 假设要进行分页查询，每页显示10条记录，查询第1页，查询条件为 age > 25，并将结果映射为 Map
IPage<Map<String, Object>> page = new Page<>(1, 10);
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gt("age", 25);
IPage<Map<String, Object>> userPageMaps = userMapper.selectMapsPage(page, queryWrapper); // 调用 selectMapsPage 方法
List<Map<String, Object>> userMapList = userPageMaps.getRecords();
long total = userPageMaps.getTotal();
System.out.println("Total users (age > 25): " + total);
for (Map<String, Object> userMap : userMapList) {
System.out.println("User Map: " + userMap);
}
这里的IPage<User>，要替换为IPage<Map<String, Object>>
生成的 SQL:
SELECT * FROM user WHERE age > 25 LIMIT 10 OFFSET 0
10. 示例（selectCount）
// 假设有一个 QueryWrapper 对象，设置查询条件为 age > 25，查询总记录数
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gt("age", 25);
Long totalUsers = userMapper.selectCount(queryWrapper); // 调用 selectCount 方法
System.out.println("Total users (age > 25): " + totalUsers);
这里的selectCount返回值类型为Long
生成的 SQL:
SELECT COUNT(*) FROM user WHERE age > 25
通过上述示例，我们可以看到 select 系列方法是如何在 Mapper 层进行查询操作的，以及它们对应的 SQL 语句。这些方法提供了灵活的数据查询方式，可以根据不同的条件进行查询操作，包括单条记录查询、批量查询、条件查询、分页查询等。
扫一扫
1112
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
