Mybatis Plus 查询数据（图文讲解）

大家好，我是小哈。

本小节中，我们将学习如何通过 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);

参数说明：

类型	参数名	描述
Serializable	id	主键 ID
Wrapper<T>	queryWrapper	实体对象封装操作类（可以为 null）
Collection<? extends Serializable>	idList	主键 ID 列表(不能为 null 以及 empty)
Map<String, Object>	columnMap	表字段 map 对象
IPage<T>	page	分页查询条件（可以为 RowBounds.DEFAULT）

示例代码

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

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);

参数说明：

类型	参数名	描述
Serializable	id	主键 ID
Wrapper<T>	queryWrapper	实体对象封装操作类 QueryWrapper
boolean	throwEx	有多个 result 是否抛出异常
T	entity	实体对象
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);

参数说明：

类型	参数名	描述
Wrapper<T>	queryWrapper	实体对象封装操作类 QueryWrapper
Collection<? extends Serializable>	idList	主键 ID 列表
Map<String, Object>	columnMap	表字段 map 对象
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);