MybatisPlus IService接口功能介绍

 public interface UserService extends IService<User> {}

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

// 插入一条记录（选择字段，策略插入）
boolean save(T entity);

// 插入（批量）
boolean saveBatch(Collection<T> entityList);

// 插入（批量，限制数量）
boolean saveBatch(Collection<T> entityList, int batchSize);

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

// 根据 entity 条件，删除记录
boolean remove(Wrapper<T> queryWrapper);

// 根据 ID 删除
boolean removeById(Serializable id);

// 根据 columnMap 条件，删除记录
boolean removeByMap(Map<String, Object> columnMap);

// 删除（根据ID 批量删除）
boolean removeByIds(Collection<? extends Serializable> idList);

// 根据 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);

// 根据 ID 查询
T getById(Serializable id);

// 根据 Wrapper，查询一条记录。结果集如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")
T getOne(Wrapper<T> queryWrapper);

// 根据 Wrapper，查询一条记录，这个是方法返回结果不止一条则会抛出异常，如果想默认取第一条结果，可以给这方法传第二个参数为false。
T getOne(Wrapper<T> queryWrapper, boolean throwEx);

// 根据 Wrapper，查询一条记录
Map<String, Object> getMap(Wrapper<T> queryWrapper);

// 根据 Wrapper，查询一条记录
// mapper：转换函数，用于将查询结果中的每个对象转换为指定的对象类型。
<V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

// 查询所有
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 条件，查询全部记录
// mapper：转换函数，用于将查询结果中的每个对象转换为指定的对象类型。
<V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

// 查询总记录数
int count();

// 根据 Wrapper 条件，查询总记录数
int count(Wrapper<T> queryWrapper);

// 无条件分页查询
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);

public class Page<T> implements IPage<T> {
    private static final long serialVersionUID = 8545996863226528798L;
    protected List<T> records;
    protected long total;
    protected long size;
    protected long current;
    protected List<OrderItem> orders;
    protected boolean optimizeCountSql;
    protected boolean searchCount;
    protected boolean optimizeJoinOfCountSql;
    protected String countId;
    protected Long maxLimit;
/* 以下省略 */
}

@SpringBootTest
public class ProductMapperTest {
    // 自动注入 productMapper 接口对应的实现类对象
    @Autowired
    private ProductMapper productMapper;
    @Test
    public void testPageQuery(){
        // 创建分页查询相关参数 page，泛型为 Product，表示查询到的结果对应的实体类为Product
        Page<Product> page = new Page<>();
        // 设置分页查询显示第二页的数据，实际开发过程中该参数有前端传递
        page.setCurrent(2);
        // 设置分页查询每页显示四条数据，实际开发过程中该参数有前端传递
        page.setSize(4);
        // 创建排序字段集合，不想排序不加即可，实际开发过程中一般都会要求按照时间降序排序
        List<OrderItem> orders = new ArrayList<>();
        // 按照价格排序，排序方式为降序，ASC为True表示升序，false表示降序，第一个参数表示数据库中的列名
        orders.add(new OrderItem("price",false));
        // 按照生产时间排序，排序方式为降序
        orders.add(new OrderItem("production_date",false));
        // 将排序对象集合加入分页查询对象Page中
        page.setOrders(orders);
        // 执行分页查询，可以创建一个Page对象接受查询结果，
        // 也可以用查询条件参数page，但其实最后结果都是同一个
        page = productMapper.selectPage(page, null);
        // 可以新创建一个Page对象，就像下面这样
        Page<Product> productPage = productMapper.selectPage(page,null);
        // 输出分页查询结果显示当前的哪一页
        System.out.println(page.getCurrent());
        // 输出分页查询结果的总数据条数
        System.out.println(page.getTotal());
        // 输出分页查询结果的数据集合
        System.out.println(page.getRecords());
        // 输出分页查询结果的每页显示条数
        System.out.println(page.getSize());
        // 判断刚才分页查询的两个结果对象是否为同一个
        System.out.println(page == productPage);
        // 输出第一个分页查询对象内存地址
        System.out.println(page);
        // 输出第二个分页查询对象内存地址
        System.out.println(productPage);
    }
}

// 链式查询 普通
QueryChainWrapper<T> query();

// 链式查询 lambda 式。注意：不支持 Kotlin
LambdaQueryChainWrapper<T> lambdaQuery();

// 示例：
// eq 指定条件
query().eq("column", value).one();
lambdaQuery().eq(Entity::getId, value).list();

// 链式更改 普通
UpdateChainWrapper<T> update();

// 链式更改 lambda 式。注意：不支持 Kotlin
LambdaUpdateChainWrapper<T> lambdaUpdate();

// 示例：
// eq 指定条件
update().eq("column", value).remove();
lambdaUpdate().eq(Entity::getId, value).update(entity);