参考：MyBatis-Plus 使用详解
官方文档：https://baomidou.com/pages/49cc81/#get
MyBatis-Plus(page和pageMaps分页查询)
MyBatis-Plus 条件构造器

分页查询

1、要定义一个分页拦截器【重点】，不定义的话，无法使用

  1. package com.tj.config;
  3. import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
  4. import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  8. @Configuration
  9. public class MPConfig {
  10.     @Bean
  11.     public MybatisPlusInterceptor mybatisPlusInterceptor(){
  12.         //1.定义Mp拦截器
  13.         MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
  14.         //2.添加具体的拦截器，分页拦截器
  15.         interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
  16.         return interceptor;
  17.     }
  19. }

2、selectPage方法进行分页查询

Page(1,5)，第一个参数表示第几页，第二个参数表示共几条数据

  1.     @Test
  2.     void testGetPage() { //分页查询
  3.         IPage page = new Page(3, 5);
  4.         usersDao.selectPage(page, null);
  5.         long current = page.getCurrent();//当前页
  6.         long pages = page.getPages();//总页数        
  7.         long size = page.getSize();//每页显示几条
  8.         long total = page.getTotal();//总条数
  9.         List records = page.getRecords();//  分页对象记录列表
  10.     }

按条件查询

  1.     @Test
  2.     void testGetBy() {  //按条件查询
  3.         QueryWrapper<Users> qw = new QueryWrapper<>();
  4.         qw.like("user_name","王");
  5.         List<Users> userList = usersDao.selectList(qw);
  7.     }
  1.     @Test
  2.     void testGetBy() {  //按条件查询
  3.         LambdaQueryWrapper<Users> lqw = new LambdaQueryWrapper<>();
  4.         String name = "1";
  5.         String name2 = "2";
  6.         String name3 = "3";
  7.         lqw.like(name3 != null, Users::getUser_name, name3);
  8.         lqw.and(e -> {
  9.             e.like(name != null, Users::getUser_name, name).or();
  10.             e.like(name2 != null, Users::getUser_name, name2);
  11.         });
  12.         //等于 WHERE (user_name LIKE ? AND (user_name LIKE ? OR user_name LIKE ?))
  13.         List<Users> userList = usersDao.selectList(lqw);
  14.     }

1、Mapper 接口方法（CRUD）

  1. 【添加数据：（增）】
  2.     int insert(T entity);              // 插入一条记录
  3. 注：
  4.     T         表示任意实体类型
  5.     entity    表示实体对象
  7. 【删除数据：（删）】
  8.     int deleteById(Serializable id);    // 根据主键 ID 删除
  9.     int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);  // 根据 map 定义字段的条件删除
  10.     int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper); // 根据实体类定义的 条件删除对象
  11.     int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList); // 进行批量删除
  12. 注：
  13.     id        表示 主键 ID
  14.     columnMap 表示表字段的 map 对象
  15.     wrapper   表示实体对象封装操作类，可以为 null。
  16.     idList    表示 主键 ID 集合（列表、数组），不能为 null 或 empty
  18. 【修改数据：（改）】
  19.     int updateById(@Param(Constants.ENTITY) T entity); // 根据 ID 修改实体对象。
  20.     int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper); // 根据 updateWrapper 条件修改实体对象
  21. 注：
  22.     update 中的 entity 为 set 条件，可以为 null。
  23.     updateWrapper 表示实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
  25. 【查询数据：（查）】
  26.     T selectById(Serializable id); // 根据 主键 ID 查询数据
  27.     List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList); // 进行批量查询
  28.     List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap); // 根据表字段条件查询
  29.     T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 根据实体类封装对象 查询一条记录
  30.     Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询记录的总条数
  31.     List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（返回 entity 集合）
  32.     List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（返回 map 集合）
  33.     List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（但只保存第一个字段的值）
  34.     <E extends IPage<T>> E selectPage(E page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（返回 entity 集合），分页
  35.     <E extends IPage<Map<String, Object>>> E selectMapsPage(E page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper); // 查询所有记录（返回 map 集合），分页
  36. 注：
  37.     queryWrapper 表示实体对象封装操作类（可以为 null）
  38.     page 表示分页查询条件

2、Service 接口方法（CRUD）

  1. 【添加数据：（增）】
  2.     default boolean save(T entity); // 调用 BaseMapper 的 insert 方法，用于添加一条数据。
  3.     boolean saveBatch(Collection<T> entityList, int batchSize); // 批量插入数据
  4. 注：
  5.     entityList 表示实体对象集合 
  6.     batchSize 表示一次批量插入的数据量，默认为 1000
  8. 【添加或修改数据：（增或改）】
  9.     boolean saveOrUpdate(T entity); // id 若存在，则修改， id 不存在则新增数据
  10.    default boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper); // 先根据条件尝试更新，然后再执行 saveOrUpdate 操作
  11.    boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize); // 批量插入并修改数据 
  13. 【删除数据：（删）】
  14.     default boolean removeById(Serializable id); // 调用 BaseMapper 的 deleteById 方法，根据 id 删除数据。
  15.     default boolean removeByMap(Map<String, Object> columnMap); // 调用 BaseMapper 的 deleteByMap 方法，根据 map 定义字段的条件删除
  16.     default boolean remove(Wrapper<T> queryWrapper); // 调用 BaseMapper 的 delete 方法，根据实体类定义的 条件删除对象。
  17.     default boolean removeByIds(Collection<? extends Serializable> idList); // 用 BaseMapper 的 deleteBatchIds 方法, 进行批量删除。
  19. 【修改数据：（改）】
  20.     default boolean updateById(T entity); // 调用 BaseMapper 的 updateById 方法，根据 ID 选择修改。
  21.     default boolean update(T entity, Wrapper<T> updateWrapper); // 调用 BaseMapper 的 update 方法，根据 updateWrapper 条件修改实体对象。
  22.     boolean updateBatchById(Collection<T> entityList, int batchSize); // 批量更新数据
  24. 【查找数据：（查）】
  25.     default T getById(Serializable id); // 调用 BaseMapper 的 selectById 方法，根据 主键 ID 返回数据。
  26.     default List<T> listByIds(Collection<? extends Serializable> idList); // 调用 BaseMapper 的 selectBatchIds 方法，批量查询数据。
  27.     default List<T> listByMap(Map<String, Object> columnMap); // 调用 BaseMapper 的 selectByMap 方法，根据表字段条件查询
  28.     default T getOne(Wrapper<T> queryWrapper); // 返回一条记录（实体类保存）。
  29.     Map<String, Object> getMap(Wrapper<T> queryWrapper); // 返回一条记录（map 保存）。
  30.     default int count(Wrapper<T> queryWrapper); // 根据条件返回 记录数。
  31.     default List<T> list(); // 返回所有数据。
  32.     default List<T> list(Wrapper<T> queryWrapper); // 调用 BaseMapper 的 selectList 方法，查询所有记录（返回 entity 集合）。
  33.     default List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper); // 调用 BaseMapper 的 selectMaps 方法，查询所有记录（返回 map 集合）。
  34.     default List<Object> listObjs(); // 返回全部记录，但只返回第一个字段的值。
  35.     default <E extends IPage<T>> E page(E page, Wrapper<T> queryWrapper); // 调用 BaseMapper 的 selectPage 方法，分页查询
  36.     default <E extends IPage<Map<String, Object>>> E pageMaps(E page, Wrapper<T> queryWrapper); // 调用 BaseMapper 的 selectMapsPage 方法，分页查询
  37. 注：
  38.     get 用于返回一条记录。
  39.     list 用于返回多条记录。
  40.     count 用于返回记录总数。
  41.     page 用于分页查询。
  43. 【链式调用：】
  44.     default QueryChainWrapper<T> query(); // 普通链式查询
  45.     default LambdaQueryChainWrapper<T> lambdaQuery(); // 支持 Lambda 表达式的修改
  46.     default UpdateChainWrapper<T> update(); // 普通链式修改
  47.     default LambdaUpdateChainWrapper<T> lambdaUpdate(); // 支持 Lambda 表达式的修改
  48. 注：
  49.     query 表示查询
  50.     update 表示修改
  51.     Lambda 表示内部支持 Lambda 写法。
  52. 形如：
  53.     query().eq("column", value).one();
  54.     lambdaQuery().eq(Entity::getId, value).list();
  55.     update().eq("column", value).remove();
  56.     lambdaUpdate().eq(Entity::getId, value).update(entity);