大家好，我是小哈。

本小节中，我们将学习如何通过 Mybatis Plus 查询数据库表中的数据。

表结构

在前面小节中，我们已经定义好了一个用于测试的用户表， 执行脚本如下：

DROP TABLE IF EXISTS user; CREATE TABLE `user` ( `id` bigint(20) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '主键ID', `name` varchar(30) NOT NULL DEFAULT '' COMMENT '姓名', `age` int(11) NULL DEFAULT NULL COMMENT '年龄', `gender` tinyint(2) NOT NULL DEFAULT 0 COMMENT '性别，0：女 1：男', PRIMARY KEY (`id`) ) COMMENT = '用户表'; 

定义实体类

定义一个名为 User 实体类：

@TableName("user")
public class User {
    /** * 主键 ID, @TableId 注解定义字段为表的主键，type 表示主键类型，IdType.AUTO 表示随着数据库 ID 自增 */ @TableId(type = IdType.AUTO) private Long id; /** * 姓名 */ private String name; /** * 年龄 */ private Integer age; /** * 性别 */ private Integer gender; } 

不明白 Mybatis Plus 实体类注解的小伙伴，可参考前面小节 , 有详细解释。

开始查询数据

Mybatis Plus 对 Mapper 层和 Service 层都将常见的增删改查操作封装好了，只需简单的继承，即可轻松搞定对数据的增删改查，本文重点讲解查询相关的部分。

Mapper 层

定义一个 UserMapper , 让其继承自 BaseMapper :

public interface UserMapper extends BaseMapper<User> { } 

然后，注入 Mapper :

@Autowired
private UserMapper userMapper;

BaseMapper 提供的查询相关的方法如下：

解释一下每个方法的作用：

// 根据 ID 查询
T selectById(Serializable id);
// 通过 Wrapper 组装查询条件，查询一条记录
T selectOne(Wrapper<T> queryWrapper);

// 查询(根据ID 批量查询)
List<T> selectBatchIds(Collection<? extends Serializable> idList);
// 通过 Wrapper 组装查询条件，查询全部记录
List<T> selectList(Wrapper<T> queryWrapper);
// 查询(根据 columnMap 来设置条件) List<T> selectByMap(Map<String, Object> columnMap); // 根据 Wrapper 组装查询条件，查询全部记录，并以 map 的形式返回 List<Map<String, Object>> selectMaps(Wrapper<T> queryWrapper); // 根据 Wrapper 条件，查询全部记录。注意： 只返回第一个字段的值 List<Object> selectObjs(Wrapper<T> queryWrapper); // =========================== 分页相关 =========================== // 根据 entity 条件，查询全部记录(并翻页) IPage<T> selectPage(IPage<T> page, Wrapper<T> queryWrapper); // 根据 Wrapper 条件，查询全部记录(并翻页) IPage<Map<String, Object>> selectMapsPage(IPage<T> page, Wrapper<T> queryWrapper); // 根据 Wrapper 条件，查询总记录数 Integer selectCount(Wrapper<T> queryWrapper); 

参数说明：

示例代码

接下来，小哈来演示一些示例代码以便你快速了解如何使用，注意，分页相关的方法暂不做讲解，后面会单独开一篇来详细讲解。

1、根据 ID 查询：

// 实际执行 SQL :SELECT id,name,age,gender FROM user WHERE id=1 User user = userMapper.selectById(1L); 

2、通过 Wrapper 组装查询条件，查询一条记录:

QueryWrapper<User> queryWrapper =new QueryWrapper<>();
// 仅查询 id, name 字段
queryWrapper.select("id", "name"); // where id = 1 queryWrapper.eq("id", 1L); // 实际执行 SQL : SELECT id,name,age,gender FROM user WHERE (id = 1) User user = userMapper.selectOne(queryWrapper); 

注意： selectOne 方法期望仅返回一条数据，若实际查询到多条数据，会主动抛出异常，内部源码如下：

2、查询(根据ID 批量查询)：

// 实际执行 SQL :SELECT id,name,age,gender FROM user WHERE id IN ( 1 , 2 , 3 ) List<User> users = userMapper.selectBatchIds(Arrays.asList(1L, 2L, 3L)); 

3、通过 Wrapper 组装查询条件，查询全部记录:

QueryWrapper<User> queryWrapper =new QueryWrapper<>();
// 仅查询 id, name 字段
queryWrapper.select("id", "name"); // where age = 30 queryWrapper.eq("age", 30); // 实际执行 SQL : SELECT id,name FROM user WHERE (age = 30) List<User> users = userMapper.selectList(queryWrapper); 

4、查询(根据 columnMap 来设置条件)：

// 通过 map 来设置查询条件
Map<String, Object> columnMap = new HashMap<>(); columnMap.put("name", "犬小哈"); columnMap.put("age", 30); // 实际执行 SQL : SELECT id,name,age,gender FROM user WHERE name = '犬小哈' AND age = 30 List<User> users = userMapper.selectByMap(columnMap); 

5、根据 Wrapper 组装查询条件，查询全部记录，并以 map 的形式返回：

QueryWrapper<User> queryWrapper =new QueryWrapper<>();
// 仅查询 id, name 字段
queryWrapper.select("id", "name");
// where age = 30 queryWrapper.eq("age", 30); // 实际执行 SQL : SELECT id,name FROM user WHERE (age = 30) List<Map<String,Object>> users = userMapper.selectMaps(queryWrapper); 

6、根据 Wrapper 条件，查询全部记录。注意： 只返回第一个字段的值：

QueryWrapper<User> queryWrapper =new QueryWrapper<>();
// where age = 30
queryWrapper.eq("age", 30);

// 实际执行 SQL : SELECT id,name FROM user WHERE (age = 30) List<Object> ids = userMapper.selectObjs(queryWrapper); 

7、根据 Wrapper 条件，查询总记录数：

// 组装查询条件
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("name", "犬小哈").eq("age", 30);

// 实际执行 SQL : SELECT COUNT( * ) FROM user WHERE (name = '犬小哈' AND age = 30) long count = userMapper.selectCount(queryWrapper); System.out.println("总记录数：" + count); 

Service 层

Mybatis Plus 同样也封装了通用的 Service 层 CRUD 操作，并且提供了更丰富的方法。接下来，我们上手看 Service 层的代码结构，如下图：

定义 Service 层

先定义 UserService 接口 ，让其继承自 IService:

public interface UserService extends IService<User> { } 

再定义实现类 UserServiceImpl，让其继承自 ServiceImpl, 同时实现 UserService 接口，这样就可以让 UserService 拥有了基础通用的 CRUD 功能，当然，实际开发中，业务会更加复杂，就需要向 IService 接口自定义方法并实现:

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService { } 

注入 UserService :

@Autowired
private UserService userService;

Service 层封装的查询方法注意分为 4 块：

• getXXX : get 开头的方法；
• listXXX : list 开头的方法，用于查询多条数据；
• pageXXX : page 开头的方法，用于分页查询；
• count : 用于查询总记录数；

接下来，我们一一讲解。

get 相关方法

get 开头的相关方法用于查询一条记录，方法如下：

// 根据 ID 查询
T getById(Serializable id);
// 根据 Wrapper，查询一条记录。如果结果集是多个会抛出异常 T getOne(Wrapper<T> queryWrapper); // 根据 Wrapper，查询一条记录 T getOne(Wrapper<T> queryWrapper, boolean throwEx); // 根据 Wrapper，查询一条记录，以 map 的形式返回数据 Map<String, Object> getMap(Wrapper<T> queryWrapper); // 根据 Wrapper，查询一条记录 <V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper); 

参数说明：

示例代码

这里挑两个具有代表性的方法：

1. 根据 ID 查询

// 实际执行 SQL :SELECT id,name,age,gender FROM user WHERE id=1 User user = userService.getById(1L); 

2. 根据 Wrapper，查询一条记录。如果结果集是多个会抛出异常：

// 组装查询条件
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("id", 1L).eq("name", "犬小哈");

// 实际执行 SQL : SELECT id,name,age,gender FROM user WHERE (id = 1 AND name = '犬小哈') User user = userService.getOne(queryWrapper); 

list 相关方法

list 开头的相关方法用于查询多条记录，方法如下：

// 查询所有
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); // 查询所有列表, 以 map 的形式返回 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); 

参数说明：

示例代码

这里挑几个具有代表性的方法：

// 组装查询条件
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
// where name = '犬小哈' and age >= 20
queryWrapper.eq("name", "犬小哈").ge("age", 20); // 实际执行 SQL : SELECT id,name,age,gender FROM user WHERE (name = '犬小哈' AND age >= 20) List<User> users = userService.list(queryWrapper); 

// 实际执行 SQL :SELECT id,name,age,gender FROM user WHERE id IN ( 1 , 2 , 3 ) List<User> users = userService.listByIds(Arrays.asList(1L, 2L, 3L)); 

Map<String , Object> columnMap = new HashMap<>();
columnMap.put("name", "犬小哈"); columnMap.put("age", 30L); // 实际执行 SQL : SELECT id,name,age,gender FROM user WHERE name = '犬小哈' AND age = 30 List<User> users = userService.listByMap(columnMap); 

page 分页相关方法

放到后面《分页查询》 小节统一讲解；

count 查询总记录数

查询总记录数 count 相关方法如下：

// 查询总记录数(不带查询条件)
count();
// 查询总记录数(可以带查询条件)
count(Wrapper<T>)

示例代码

// 组装查询条件
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
// where age = 30 queryWrapper.eq("age", 30); // 实际执行 SQL : SELECT COUNT( * ) FROM user WHERE (age = 30) long count = userService.count(queryWrapper); System.out.println("总记录数：" + count);