[toc]
持久层接口
本文详细介绍了 MyBatis-Plus 进行持久化操作的各种方法,包括插入、更新、删除、查询和分页等。通过本文,您可以了解到 MyBatis-Plus 提供的各种方法是如何进行数据操作的,以及它们对应的 SQL 语句。
Service Interface
<span style="color:red">
IService 是 MyBatis-Plus 提供的一个通用 Service 层接口,它封装了常见的 CRUD 操作,包括插入、删除、查询和分页等。<span style="color:red">
通过继承 IService 接口,可以快速实现对数据库的基本操作,同时保持代码的简洁性和可维护性。
IService 接口中的方法命名遵循了一定的规范,如 get 用于查询单行,remove 用于删除,list 用于查询集合,page 用于分页查询,这样可以避免与 Mapper 层的方法混淆。
提示:
- 泛型 T 为任意实体对象
- 建议如果存在自定义通用 Service 方法的可能,请创建自己的 IBaseService 继承 Mybatis-Plus 提供的 IService 基类
- 对象 Wrapper 为 条件构造器
步骤有:
- 创建 UserService 并继承 IService
1 2 3 4
|
public interface UserService extends IService<User> {}
|
- 创建 UserMapper
1 2 3 4
| @Mapper public interface UserMapper extends BaseMapper<User> { }
|
- 创建 UserService 的实现类并继承 ServiceImpl,传入映射的 mapper(继承了 BaseMapper)和实体类泛型。
1 2 3
| @Service public class UserServiceImpl extends ServiceImpl<UserMapper,User> implements UserService{}
|
ServiceImpl 实现了 IService,提供了 IService中基础功能的实现。若 ServiceImpl 无法满足业务需求,则可以使用自定的 UserService 定义方法,并在实现类中实现
- 接下来就可以在ServiceImpl下调用UserService中继承得到的方法了
1.save
1 2 3 4 5 6
| boolean save(T entity);
boolean saveBatch(Collection<T> entityList);
boolean saveBatch(Collection<T> entityList, int batchSize);
|
功能描述
插入记录,根据实体对象的字段进行策略性插入。
返回值
boolean,表示插入操作是否成功。
参数说明
类型 | 参数名 | 描述 |
---|
T | entity | 实体对象 |
Collection<T> | entityList | 实体对象集合 |
int | batchSize | 插入批次数量 |
示例
save:
1 2 3 4 5 6 7 8 9 10
| User user = new User(); user.setName("John Doe"); user.setEmail("john.doe@example.com"); boolean result = userService.save(user); if (result) { System.out.println("User saved successfully."); } else { System.out.println("Failed to save user."); }
|
生成的 SQL:
1
| INSERT INTO user (name, email) VALUES ('John Doe', 'john.doe@example.com')
|
saveBatch:
1 2 3 4 5 6 7 8 9 10 11 12 13
| List<User> users = Arrays.asList( new User("Alice", "alice@example.com"), new User("Bob", "bob@example.com"), new User("Charlie", "charlie@example.com") );
boolean result = userService.saveBatch(users); if (result) { System.out.println("Users saved successfully."); } else { System.out.println("Failed to save users."); }
|
生成的 SQL(假设默认批次大小为 3):
1 2 3 4
| INSERT INTO user (name, email) VALUES ('Alice', 'alice@example.com'), ('Bob', 'bob@example.com'), ('Charlie', 'charlie@example.com')
|
saveBatch 指定批次大小:
1 2 3 4 5 6 7 8 9 10 11 12 13 14
| List<User> users = Arrays.asList( new User("David", "david@example.com"), new User("Eve", "eve@example.com"), new User("Frank", "frank@example.com"), new User("Grace", "grace@example.com") );
boolean result = userService.saveBatch(users, 2); if (result) { System.out.println("Users saved successfully."); } else { System.out.println("Failed to save users."); }
|
生成的 SQL(指定批次大小为 2):
1 2 3 4 5 6 7 8 9
| INSERT INTO user (name, email) VALUES ('David', 'david@example.com'), ('Eve', 'eve@example.com')
INSERT INTO user (name, email) VALUES ('Frank', 'frank@example.com'), ('Grace', 'grace@example.com')
|
这些方法大大简化了插入操作的代码编写,提高了开发效率
2.saveOrUpdate
1 2 3 4 5 6 7 8
| boolean saveOrUpdate(T entity);
boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper);
boolean saveOrUpdateBatch(Collection<T> entityList);
boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);
|
功能描述
根据实体对象的主键 ID 进行判断,存在则更新记录,否则插入记录。
返回值
boolean,表示插入或更新操作是否成功。
参数说明
类型 | 参数名 | 描述 |
---|
T | entity | 实体对象 |
Wrapper<T> | updateWrapper | 实体对象封装操作类 UpdateWrapper |
Collection<T> | entityList | 实体对象集合 |
int | batchSize | 插入批次数量 |
示例
saveOrUpdate:
1 2 3 4 5 6 7 8 9 10 11
| User user = new User(); user.setId(1); user.setName("John Doe"); user.setEmail("john.doe@example.com"); boolean result = userService.saveOrUpdate(user); if (result) { System.out.println("User updated or saved successfully."); } else { System.out.println("Failed to update or save user."); }
|
生成的 SQL(假设 id 为 1 的记录已存在):
1
| UPDATE user SET name = 'John Doe', email = 'john.doe@example.com' WHERE id = 1
|
生成的 SQL(假设 id 为 1 的记录不存在):
1
| INSERT INTO user (id, name, email) VALUES (1, 'John Doe', 'john.doe@example.com')
|
saveOrUpdateBatch:
1 2 3 4 5 6 7 8 9 10 11 12 13
| List<User> users = Arrays.asList( new User(1, "Alice", "alice@example.com"), new User(2, "Bob", "bob@example.com"), new User(3, "Charlie", "charlie@example.com") );
boolean result = userService.saveOrUpdateBatch(users); if (result) { System.out.println("Users updated or saved successfully."); } else { System.out.println("Failed to update or save users."); }
|
生成的 SQL(假设 id 为 1 和 2 的记录已存在,id 为 3 的记录不存在):
1 2 3
| UPDATE user SET name = 'Alice', email = 'alice@example.com' WHERE id = 1 UPDATE user SET name = 'Bob', email = 'bob@example.com' WHERE id = 2 INSERT INTO user (id, name, email) VALUES (3, 'Charlie', 'charlie@example.com')
|
saveOrUpdateBatch 指定批次大小:
1 2 3 4 5 6 7 8 9 10 11 12 13
| List<User> users = Arrays.asList( new User(4, "David", "david@example.com"), new User(5, "Eve", "eve@example.com"), new User(6, "Frank", "frank@example.com") );
boolean result = userService.saveOrUpdateBatch(users, 2); if (result) { System.out.println("Users updated or saved successfully."); } else { System.out.println("Failed to update or save users."); }
|
生成的 SQL(假设指定批次大小为 2):
1 2 3 4 5 6
| -- 第一批次 UPDATE user SET name = 'David', email = 'david@example.com' WHERE id = 4 UPDATE user SET name = 'Eve', email = 'eve@example.com' WHERE id = 5
-- 第二批次 INSERT INTO user (id, name, email) VALUES (6, 'Frank', 'frank@example.com')
|
这些方法提供了高效的数据操作方式,可以根据不同的条件进行更新或插入操作。
3.remove
1 2 3 4 5 6 7 8
| boolean remove(Wrapper<T> queryWrapper);
boolean removeById(Serializable id);
boolean removeByMap(Map<String, Object> columnMap);
boolean removeByIds(Collection<? extends Serializable> idList);
|
功能描述
通过指定条件删除符合条件的记录。
返回值
boolean,表示删除操作是否成功。
参数说明
类型 | 参数名 | 描述 |
---|
Wrapper<T> | queryWrapper | 实体包装类 QueryWrapper |
Serializable | id | 主键 ID |
Map<String, Object> | columnMap | 表字段 map 对象 |
Collection<? extends Serializable> | idList | 主键 ID 列表 |
示例
remove:
1 2 3 4 5 6 7 8 9
| QueryWrapper<User> queryWrapper = new QueryWrapper<>(); queryWrapper.eq("name", "John Doe"); boolean result = userService.remove(queryWrapper); if (result) { System.out.println("Record deleted successfully."); } else { System.out.println("Failed to delete record."); }
|
生成的 SQL:
1
| DELETE FROM user WHERE name = 'John Doe'
|
removeById:
1 2 3 4 5 6 7
| boolean result = userService.removeById(1); if (result) { System.out.println("User deleted successfully."); } else { System.out.println("Failed to delete user."); }
|
生成的 SQL:
1
| DELETE FROM user WHERE id = 1
|
removeByMap:
1 2 3 4 5 6 7 8 9
| Map<String, Object> columnMap = new HashMap<>(); columnMap.put("age", 30); boolean result = userService.removeByMap(columnMap); if (result) { System.out.println("Records deleted successfully."); } else { System.out.println("Failed to delete records."); }
|
生成的 SQL:
1
| DELETE FROM user WHERE age = 30
|
removeByIds:
1 2 3 4 5 6 7 8
| List<Integer> ids = Arrays.asList(1, 2, 3); boolean result = userService.removeByIds(ids); if (result) { System.out.println("Users deleted successfully."); } else { System.out.println("Failed to delete users."); }
|
生成的 SQL:
1
| DELETE FROM user WHERE id IN (1, 2, 3)
|
这些方法提供了灵活的数据操作方式,可以根据不同的条件进行删除操作。
4.update
1 2 3 4 5 6 7 8 9 10
| boolean update(Wrapper<T> updateWrapper);
boolean update(T updateEntity, Wrapper<T> whereWrapper);
boolean updateById(T entity);
boolean updateBatchById(Collection<T> entityList);
boolean updateBatchById(Collection<T> entityList, int batchSize);
|
功能描述
通过指定条件更新符合条件的记录。
返回值
boolean,表示更新操作是否成功。
参数说明
类型 |参数名| 描述
Wrapper<T>
|pdateWrapper| 实体对象封装操作类 UpdateWrapper
T |entity| 实体对象
Collection<T>
|entityList| 实体对象集合
int |batchSize| 更新批次数量
update UpdateWrapper 形式:
1 2 3 4 5 6 7 8 9
| UpdateWrapper<User> updateWrapper = new UpdateWrapper<>(); updateWrapper.eq("name", "John Doe").set("email", "john.doe@newdomain.com"); boolean result = userService.update(updateWrapper); if (result) { System.out.println("Record updated successfully."); } else { System.out.println("Failed to update record."); }
|
生成的 SQL:
1
| UPDATE user SET email = 'john.doe@newdomain.com' WHERE name = 'John Doe'
|
update WhereWrapper 形式:
1 2 3 4 5 6 7 8 9 10 11
| User updateEntity = new User(); updateEntity.setName("Updated Name"); QueryWrapper<User> whereWrapper = new QueryWrapper<>(); whereWrapper.eq("id", 1); boolean result = userService.update(updateEntity, whereWrapper); if (result) { System.out.println("Record updated successfully."); } else { System.out.println("Failed to update record."); }
|
生成的 SQL:
1
| UPDATE user SET name = 'Updated Name' WHERE id = 1
|
updateById:
1 2 3 4 5 6 7 8 9 10
| User updateEntity = new User(); updateEntity.setId(1); updateEntity.setEmail("updated.email@example.com"); boolean result = userService.updateById(updateEntity); if (result) { System.out.println("Record updated successfully."); } else { System.out.println("Failed to update record."); }
|
生成的 SQL:
1
| UPDATE user SET email = 'updated.email@example.com' WHERE id = 1
|
updateBatchById:
1 2 3 4 5 6 7 8 9 10 11
| List<User> users = Arrays.asList( new User(1, null, "new.email1@example.com"), new User(2, null, "new.email2@example.com") ); boolean result = userService.updateBatchById(users); if (result) { System.out.println("Records updated successfully."); } else { System.out.println("Failed to update records."); }
|
生成的 SQL(假设默认批次大小为 2):
1 2
| UPDATE user SET email = 'new.email1@example.com' WHERE id = 1 UPDATE user SET email = 'new.email2@example.com' WHERE id = 2
|
updateBatchById 指定批次大小:
1 2 3 4 5 6 7 8 9 10 11
| List<User> users = Arrays.asList( new User(1, null, "new.email1@example.com"), new User(2, null, "new.email2@example.com") ); boolean result = userService.updateBatchById(users, 1); if (result) { System.out.println("Records updated successfully."); } else { System.out.println("Failed to update records."); }
|
生成的 SQL(假设指定批次大小为 1):
1 2 3 4
| UPDATE user SET email = 'new.email1@example.com' WHERE id = 1
UPDATE user SET email = 'new.email2@example.com' WHERE id = 2
|
这些方法提供了灵活的数据操作方式,可以根据不同的条件进行更新操作。
5.get
1 2 3 4 5 6 7 8 9 10
| T getById(Serializable id);
T getOne(Wrapper<T> queryWrapper);
T getOne(Wrapper<T> queryWrapper, boolean throwEx);
Map<String, Object> getMap(Wrapper<T> queryWrapper);
<V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);
|
功能描述
根据指定条件查询符合条件的记录。
返回值
查询结果,可能是实体对象、Map 对象或其他类型。
参数说明
类型 | 参数名 | 描述 |
---|
Serializable | id | 主键 ID |
Wrapper<T> | queryWrapper | 实体对象封装操作类 QueryWrapper |
boolean | throwEx | 有多个 result 是否抛出异常 |
T | entity | 实体对象 |
Function<? super Object, V> | mapper | 转换函数 |
示例
getById:
1 2 3 4 5 6 7
| User user = userService.getById(1); if (user != null) { System.out.println("User found: " + user); } else { System.out.println("User not found."); }
|
生成的 SQL:
1
| SELECT * FROM user WHERE id = 1
|
getOne:
1 2 3 4 5 6 7 8 9
| QueryWrapper<User> queryWrapper = new QueryWrapper<>(); queryWrapper.eq("name", "John Doe"); User user = userService.getOne(queryWrapper); if (user != null) { System.out.println("User found: " + user); } else { System.out.println("User not found."); }
|
生成的 SQL:
1
| SELECT * FROM user WHERE name = 'John Doe' LIMIT 1
|
getOne 不抛出异常:
1 2 3 4 5 6 7 8 9
| QueryWrapper<User> queryWrapper = new QueryWrapper<>(); queryWrapper.eq("name", "John Doe"); User user = userService.getOne(queryWrapper, false); if (user != null) { System.out.println("User found: " + user); } else { System.out.println("User not found."); }
|
生成的 SQL:
1
| SELECT * FROM user WHERE name = 'John Doe'
|
getMap:
1 2 3 4 5 6 7 8 9
| QueryWrapper<User> queryWrapper = new QueryWrapper<>(); queryWrapper.eq("name", "John Doe"); Map<String, Object> userMap = userService.getMap(queryWrapper); if (userMap != null) { System.out.println("User found: " + userMap); } else { System.out.println("User not found."); }
|
生成的 SQL:
1
| SELECT * FROM user WHERE name = 'John Doe' LIMIT 1
|
getObj:
1 2 3 4 5 6 7 8 9
| QueryWrapper<User> queryWrapper = new QueryWrapper<>(); queryWrapper.eq("name", "John Doe"); String userName = userService.getObj(queryWrapper, obj -> ((User) obj).getName()); if (userName != null) { System.out.println("User name found: " + userName); } else { System.out.println("User name not found."); }
|
生成的 SQL:
1
| SELECT * FROM user WHERE name = 'John Doe' LIMIT 1
|
这些方法提供了灵活的数据查询方式,可以根据不同的条件进行查询操作。
6.list
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
| List<T> list();
List<T> list(Wrapper<T> queryWrapper);
Collection<T> listByIds(Collection<? extends Serializable> idList);
Collection<T> listByMap(Map<String, Object> columnMap);
List<Map<String, Object>> listMaps();
List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper);
List<Object> listObjs();
<V> List<V> listObjs(Function<? super Object, V> mapper);
List<Object> listObjs(Wrapper<T> queryWrapper);
<V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);
|
功能描述
查询符合条件的记录。
返回值
查询结果,可能是实体对象、Map 对象或其他类型。
参数说明
类型 | 参数名 | 描述 |
---|
Wrapper<T> | queryWrapper | 实体对象封装操作类 QueryWrapper |
Collection<? extends Serializable> | idList | 主键 ID 列表 |
Map<String, Object> columnMap | 表字段 | map 对象 |
Function<? super Object, V> | mapper | 转换函数 |
示例
list:
1 2 3 4 5
| List<User> users = userService.list(); for (User user : users) { System.out.println("User: " + user); }
|
生成的 SQL:
list QueryWrapper 形式:
1 2 3 4 5 6 7
| QueryWrapper<User> queryWrapper = new QueryWrapper<>(); queryWrapper.gt("age", 25); List<User> users = userService.list(queryWrapper); for (User user : users) { System.out.println("User: " + user); }
|
生成的 SQL:
1
| SELECT * FROM user WHERE age > 25
|
listByIds:
1 2 3 4 5 6
| List<Integer> ids = Arrays.asList(1, 2, 3); Collection<User> users = userService.listByIds(ids); for (User user : users) { System.out.println("User: " + user); }
|
生成的 SQL:
1
| SELECT * FROM user WHERE id IN (1, 2, 3)
|
listByMap:
1 2 3 4 5 6 7
| Map<String, Object> columnMap = new HashMap<>(); columnMap.put("age", 30); Collection<User> users = userService.listByMap(columnMap); for (User user : users) { System.out.println("User: " + user); }
|
生成的 SQL:
1
| SELECT * FROM user WHERE age = 30
|
listMaps:
1 2 3 4 5
| List<Map<String, Object>> userMaps = userService.listMaps(); for (Map<String, Object> userMap : userMaps) { System.out.println("User Map: " + userMap); }
|
生成的 SQL:
listMaps QueryWrapper 形式:
1 2 3 4 5 6 7
| QueryWrapper<User> queryWrapper = new QueryWrapper<>(); queryWrapper.gt("age", 25); List<Map<String, Object>> userMaps = userService.listMaps(queryWrapper); for (Map<String, Object> userMap : userMaps) { System.out.println("User Map: " + userMap); }
|
生成的 SQL:
1
| SELECT * FROM user WHERE age > 25
|
listObjs:
1 2 3 4 5
| List<String> userNames = userService.listObjs(obj -> ((User) obj).getName()); for (String userName : userNames) { System.out.println("User Name: " + userName); }
|
生成的 SQL:
listObjs QueryWrapper 形式:
1 2 3 4 5 6 7
| QueryWrapper<User> queryWrapper = new QueryWrapper<>(); queryWrapper.gt("age", 25); List<String> userNames = userService.listObjs(queryWrapper, obj -> ((User) obj).getName()); for (String userName : userNames) { System.out.println("User Name: " + userName); }
|
生成的 SQL:
1
| SELECT * FROM user WHERE age > 25
|
这些方法提供了灵活的数据查询方式,可以根据不同的条件进行查询操作。
7.page
1 2 3 4 5 6 7 8
| IPage<T> page(IPage<T> page);
IPage<T> page(IPage<T> page, Wrapper<T> queryWrapper);
IPage<Map<String, Object>> pageMaps(IPage<T> page);
IPage<Map<String, Object>> pageMaps(IPage<T> page, Wrapper<T> queryWrapper);
|
功能描述
分页查询符合条件的记录。
返回值
分页查询结果,包含记录列表和总记录数。
参数说明
类型 |参数名| 描述
IPage<T>
|page| 翻页对象
Wrapper<T>
|queryWrapper| 实体对象封装操作类 QueryWrapper
示例
page:
1 2 3 4 5 6 7 8 9
| IPage<User> page = new Page<>(1, 10); IPage<User> userPage = userService.page(page); List<User> userList = userPage.getRecords(); long total = userPage.getTotal(); System.out.println("Total users: " + total); for (User user : userList) { System.out.println("User: " + user); }
|
生成的 SQL:
1
| SELECT * FROM user LIMIT 10 OFFSET 0
|
page QueryWrapper 形式:
1 2 3 4 5 6 7 8 9 10 11
| IPage<User> page = new Page<>(1, 10); QueryWrapper<User> queryWrapper = new QueryWrapper<>(); queryWrapper.gt("age", 25); IPage<User> userPage = userService.page(page, queryWrapper); 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:
1
| SELECT * FROM user WHERE age > 25 LIMIT 10 OFFSET 0
|
pageMaps:
1 2 3 4 5 6 7 8 9
| IPage<Map<String, Object>> page = new Page<>(1, 10); IPage<Map<String, Object>> userPageMaps = userService.pageMaps(page); List<Map<String, Object>> userMapList = userPageMaps.getRecords(); long total = userPageMaps.getTotal(); System.out.println("Total users: " + total); for (Map<String, Object> userMap : userMapList) { System.out.println("User Map: " + userMap); }
|
生成的 SQL:
1
| SELECT * FROM user LIMIT 10 OFFSET 0
|
pageMaps QueryWrapper 形式:
1 2 3 4 5 6 7 8 9 10 11
| IPage<Map<String, Object>> page = new Page<>(1, 10); QueryWrapper<User> queryWrapper = new QueryWrapper<>(); queryWrapper.gt("age", 25); IPage<Map<String, Object>> userPageMaps = userService.pageMaps(page, queryWrapper); 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); }
|
生成的 SQL:
1
| SELECT * FROM user WHERE age > 25 LIMIT 10 OFFSET 0
|
这些方法提供了灵活的数据查询方式,可以根据不同的条件进行分页查询操作。
8.count
1 2 3 4 5 6 7 8 9 10
| int count();
int count(Wrapper<T> queryWrapper);
long count();
long count(Wrapper<T> queryWrapper);
|
功能描述
查询符合条件的记录总数。
返回值
符合条件的记录总数。
参数说明
类型 | 参数名 | 描述 |
---|
Wrapper<T> | queryWrapper | 实体对象封装操作类 QueryWrapper |
示例
count:
1 2 3
| int totalUsers = userService.count(); System.out.println("Total users: " + totalUsers);
|
生成的 SQL:
1
| SELECT COUNT(*) FROM user
|
count QueryWrapper 形式:
1 2 3 4 5
| QueryWrapper<User> queryWrapper = new QueryWrapper<>(); queryWrapper.gt("age", 25); int totalUsers = userService.count(queryWrapper); System.out.println("Total users (age > 25): " + totalUsers);
|
生成的 SQL:
1
| SELECT COUNT(*) FROM user WHERE age > 25
|
这些方法提供了灵活的数据统计方式,可以根据不同的条件进行记录数统计。