Mybatis-plus进阶篇(六)

持久层接口

本文详细介绍了 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 层的方法混淆。

提示:

  1. 泛型 T 为任意实体对象
  2. 建议如果存在自定义通用 Service 方法的可能，请创建自己的 IBaseService 继承 Mybatis-Plus 提供的 IService 基类
  3. 对象 Wrapper 为 条件构造器

步骤有：

  1. 创建 UserService 并继承 IService
1
2
3
4
/**
* UserService 继承 IService 模板提供的基础功能
*/
public interface UserService extends IService<User> {}
  1. 创建 UserMapper
1
2
3
4
@Mapper
public interface UserMapper extends BaseMapper<User> {
    // 这里不需要编写任何方法，继承了 BaseMapper 接口后，已经包含了常用的数据库操作方法
}
  1. 创建 UserService 的实现类并继承 ServiceImpl，传入映射的 mapper（继承了 BaseMapper）和实体类泛型。
1
2
3
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper,User>
implements UserService{}

ServiceImpl 实现了 IService，提供了 IService 中基础功能的实现。若 ServiceImpl 无法满足业务需求，则可以使用自定的 UserService 定义方法，并在实现类中实现

  1. 接下来就可以在 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，表示插入操作是否成功。

参数说明

类型参数名描述
Tentity实体对象
Collection <T>entityList实体对象集合
intbatchSize插入批次数量

示例

save:

1
2
3
4
5
6
7
8
9
10
// 假设有一个 User 实体对象
User user = new User();
user.setName("John Doe");
user.setEmail("john.doe@example.com");
boolean result = userService.save(user); // 调用 save 方法
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
// 假设有一组 User 实体对象
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); // 调用 saveBatch 方法，默认批次大小
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
// 假设有一组 User 实体对象
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")
);
// 指定批次大小为 2进行批量插入
boolean result = userService.saveBatch(users, 2); // 调用 saveBatch 方法，指定批次大小
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
// TableId 注解属性值存在则更新记录，否插入一条记录
boolean saveOrUpdate(T entity);
// 根据updateWrapper尝试更新，否继续执行saveOrUpdate(T)方法
boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);

功能描述

根据实体对象的主键 ID 进行判断，存在则更新记录，否则插入记录。

返回值

boolean，表示插入或更新操作是否成功。

参数说明

类型参数名描述
Tentity实体对象
Wrapper <T>updateWrapper实体对象封装操作类 UpdateWrapper
Collection <T>entityList实体对象集合
intbatchSize插入批次数量

示例

saveOrUpdate：

1
2
3
4
5
6
7
8
9
10
11
// 假设有一个 User 实体对象，其中 id 是 TableId 注解的属性
User user = new User();
user.setId(1);
user.setName("John Doe");
user.setEmail("john.doe@example.com");
boolean result = userService.saveOrUpdate(user); // 调用 saveOrUpdate 方法
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
// 假设有一组 User 实体对象，每个对象都有 id 属性
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); // 调用 saveOrUpdateBatch 方法，默认批次大小
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
// 假设有一组 User 实体对象
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")
);
// 指定批次大小为 2进行批量修改插入
boolean result = userService.saveOrUpdateBatch(users, 2); // 调用 saveOrUpdateBatch 方法，指定批次大小
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
// 根据 queryWrapper 设置的条件，删除记录
boolean remove(Wrapper<T> queryWrapper);
// 根据 ID 删除
boolean removeById(Serializable id);
// 根据 columnMap 条件，删除记录
boolean removeByMap(Map<String, Object> columnMap);
// 删除（根据ID 批量删除）
boolean removeByIds(Collection<? extends Serializable> idList);

功能描述

通过指定条件删除符合条件的记录。

返回值

boolean，表示删除操作是否成功。

参数说明

类型参数名描述
Wrapper <T>queryWrapper实体包装类 QueryWrapper
Serializableid主键 ID
Map<String, Object>columnMap表字段 map 对象
Collection<? extends Serializable>idList主键 ID 列表

示例

remove：

1
2
3
4
5
6
7
8
9
// 假设有一个 QueryWrapper 对象，设置删除条件为 name = 'John Doe'
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("name", "John Doe");
boolean result = userService.remove(queryWrapper); // 调用 remove 方法
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
// 假设要删除 ID 为 1 的用户
boolean result = userService.removeById(1); // 调用 removeById 方法
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
// 假设有一个 columnMap，设置删除条件为 age = 30
Map<String, Object> columnMap = new HashMap<>();
columnMap.put("age", 30);
boolean result = userService.removeByMap(columnMap); // 调用 removeByMap 方法
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
// 假设有一组 ID 列表，批量删除用户
List<Integer> ids = Arrays.asList(1, 2, 3);
boolean result = userService.removeByIds(ids); // 调用 removeByIds 方法
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
// 根据 UpdateWrapper 条件，更新记录 需要设置sqlset
boolean update(Wrapper<T> updateWrapper);
// 根据 whereWrapper 条件，更新记录
boolean update(T updateEntity, Wrapper<T> whereWrapper);
// 根据 ID 选择修改
boolean updateById(T entity);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList);
// 根据ID 批量更新
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 对象，设置更新条件为 name = 'John Doe'，更新字段为 email
UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
updateWrapper.eq("name", "John Doe").set("email", "john.doe@newdomain.com");
boolean result = userService.update(updateWrapper); // 调用 update 方法
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 实体对象，设置更新字段为 name，以及一个 whereWrapper 设置更新条件为 id = 1
User updateEntity = new User();
updateEntity.setName("Updated Name");
QueryWrapper<User> whereWrapper = new QueryWrapper<>();
whereWrapper.eq("id", 1);
boolean result = userService.update(updateEntity, whereWrapper); // 调用 update 方法
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 实体对象，设置更新字段为 email，根据 ID 更新
User updateEntity = new User();
updateEntity.setId(1);
updateEntity.setEmail("updated.email@example.com");
boolean result = userService.updateById(updateEntity); // 调用 updateById 方法
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
// 假设有一组 User 实体对象，批量更新
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); // 调用 updateBatchById 方法，默认批次大小
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
// 假设有一组 User 实体对象，批量更新，并指定批次大小为 1
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); // 调用 updateBatchById 方法，指定批次大小
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
// 根据 ID 查询
T getById(Serializable id);
// 根据 Wrapper，查询一条记录。结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")
T getOne(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
T getOne(Wrapper<T> queryWrapper, boolean throwEx);
// 根据 Wrapper，查询一条记录
Map<String, Object> getMap(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
<V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

功能描述

根据指定条件查询符合条件的记录。

返回值

查询结果，可能是实体对象、Map 对象或其他类型。

参数说明

类型参数名描述
Serializableid主键 ID
Wrapper <T>queryWrapper实体对象封装操作类 QueryWrapper
booleanthrowEx有多个 result 是否抛出异常
Tentity实体对象
Function<? super Object, V>mapper转换函数

示例

getById：

1
2
3
4
5
6
7
// 假设要查询 ID 为 1 的用户
User user = userService.getById(1); // 调用 getById 方法
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 对象，设置查询条件为 name = 'John Doe'
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("name", "John Doe");
User user = userService.getOne(queryWrapper); // 调用 getOne 方法
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 对象，设置查询条件为 name = 'John Doe'，并且不抛出异常
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("name", "John Doe");
User user = userService.getOne(queryWrapper, false); // 调用 getOne 方法
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 对象，设置查询条件为 name = 'John Doe'，并将结果映射为 Map
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("name", "John Doe");
Map<String, Object> userMap = userService.getMap(queryWrapper); // 调用 getMap 方法
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 对象，设置查询条件为 name = 'John Doe'，并将结果转换为 String
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("name", "John Doe");
String userName = userService.getObj(queryWrapper, obj -> ((User) obj).getName()); // 调用 getObj 方法
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);
// 查询（根据ID 批量查询）
Collection<T> listByIds(Collection<? extends Serializable> idList);
// 查询（根据 columnMap 条件）
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);
// 根据 Wrapper 条件，查询全部记录
List<Object> listObjs(Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录
<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(); // 调用 list 方法
for (User user : users) {
    System.out.println("User: " + user);
}

生成的 SQL:

1
SELECT * FROM user

list QueryWrapper 形式：

1
2
3
4
5
6
7
// 假设有一个 QueryWrapper 对象，设置查询条件为 age > 25
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gt("age", 25);
List<User> users = userService.list(queryWrapper); // 调用 list 方法
for (User user : users) {
    System.out.println("User: " + user);
}

生成的 SQL:

1
SELECT * FROM user WHERE age > 25

listByIds：

1
2
3
4
5
6
// 假设有一组 ID 列表，批量查询用户
List<Integer> ids = Arrays.asList(1, 2, 3);
Collection<User> users = userService.listByIds(ids); // 调用 listByIds 方法
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
// 假设有一个 columnMap，设置查询条件为 age = 30
Map<String, Object> columnMap = new HashMap<>();
columnMap.put("age", 30);
Collection<User> users = userService.listByMap(columnMap); // 调用 listByMap 方法
for (User user : users) {
    System.out.println("User: " + user);
}

生成的 SQL:

1
SELECT * FROM user WHERE age = 30

listMaps：

1
2
3
4
5
// 查询所有用户，并将结果映射为 Map
List<Map<String, Object>> userMaps = userService.listMaps(); // 调用 listMaps 方法
for (Map<String, Object> userMap : userMaps) {
    System.out.println("User Map: " + userMap);
}

生成的 SQL:

1
SELECT * FROM user

listMaps QueryWrapper 形式：

1
2
3
4
5
6
7
// 假设有一个 QueryWrapper 对象，设置查询条件为 age > 25，并将结果映射为 Map
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gt("age", 25);
List<Map<String, Object>> userMaps = userService.listMaps(queryWrapper); // 调用 listMaps 方法
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
// 查询所有用户，并将结果转换为 String 列表
List<String> userNames = userService.listObjs(obj -> ((User) obj).getName()); // 调用 listObjs 方法
for (String userName : userNames) {
    System.out.println("User Name: " + userName);
}

生成的 SQL:

1
SELECT * FROM user

listObjs QueryWrapper 形式：

1
2
3
4
5
6
7
// 假设有一个 QueryWrapper 对象，设置查询条件为 age > 25，并将结果转换为 String 列表
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gt("age", 25);
List<String> userNames = userService.listObjs(queryWrapper, obj -> ((User) obj).getName()); // 调用 listObjs 方法
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
// 假设要进行无条件的分页查询，每页显示10条记录，查询第1页
IPage<User> page = new Page<>(1, 10);
IPage<User> userPage = userService.page(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
// 假设有一个 QueryWrapper 对象，设置查询条件为 age > 25，进行有条件的分页查询
IPage<User> page = new Page<>(1, 10);
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gt("age", 25);
IPage<User> userPage = userService.page(page, queryWrapper); // 调用 page 方法
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
// 假设要进行无条件的分页查询，并将结果映射为 Map，每页显示10条记录，查询第1页
IPage<Map<String, Object>> page = new Page<>(1, 10);
IPage<Map<String, Object>> userPageMaps = userService.pageMaps(page); // 调用 pageMaps 方法
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
// 假设有一个 QueryWrapper 对象，设置查询条件为 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 = userService.pageMaps(page, queryWrapper); // 调用 pageMaps 方法
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();
// 根据 Wrapper 条件，查询总记录数
int count(Wrapper<T> queryWrapper);

//自3.4.3.2开始,返回值修改为long
// 查询总记录数
long count();
// 根据 Wrapper 条件，查询总记录数
long count(Wrapper<T> queryWrapper);

功能描述

查询符合条件的记录总数。

返回值

符合条件的记录总数。

参数说明

类型参数名描述
Wrapper <T>queryWrapper实体对象封装操作类 QueryWrapper

示例

count：

1
2
3
// 查询用户表中的总记录数
int totalUsers = userService.count(); // 调用 count 方法
System.out.println("Total users: " + totalUsers);

生成的 SQL:

1
SELECT COUNT(*) FROM user

count QueryWrapper 形式：

1
2
3
4
5
// 假设有一个 QueryWrapper 对象，设置查询条件为 age > 25，查询满足条件的用户总数
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.gt("age", 25);
int totalUsers = userService.count(queryWrapper); // 调用 count 方法
System.out.println("Total users (age > 25): " + totalUsers);

生成的 SQL:

1
SELECT COUNT(*) FROM user WHERE age > 25

这些方法提供了灵活的数据统计方式，可以根据不同的条件进行记录数统计。