Mybatis Plus 查询数据(图文讲解)

更新时间 2023-01-03 16:07:12

大家好,我是小哈。

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

参数说明:

类型参数名描述
Serializableid主键 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 层定义 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);

参数说明:

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

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

  1. 根据 ID 查询
// 实际执行 SQL : SELECT id,name,age,gender FROM user WHERE id=1        
User user = userService.getById(1L);
  1. 根据 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);