mybatisPlus中 Mapper层以及Service层的方法整理分类以及代码实操

MyBatis-Plus是一个基于MyBatis的增强工具，旨在简化开发、提高效率。它提供了通用的mapper和service，可以在不编写任何SQL语句的情况下，快速实现对单表的CRUD、批量、逻辑删除、分页等操作。

功能代码测试前提：

需要对mybatisPlus，Springboot的SSM框架有些许了解，导入mybatisplus的依赖包测试都是通过前端发起请求调用接口进行测试 测试工具：PostMan 所有数据均是后端赋值操作

MybatisPlus: 简介 | MyBatis-PlusP

PostMan:https://www.getpostman.com/downloads/

 <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>最新版本</version>
    </dependency>

数据库中有一个Holiday表：字段设计如下

其中create_time update_time设置了默认值

实体类：

注解说明：在本博客测试Service以及Mapper层方法的注解已加粗,其他注解可忽略

@Data:在Lombok注解库，可以自动生成类的getter、setter、toString、hashCode、equals方法。

@EqualsAndHashCode(callSuper = false)：自动生成类的hashCode和equals方法，但不调用父类的hashCode和equals方法。

@Accessors(chain = True)：是否支持链式编程，即能不能使用链式调用的方式访问类的属性类似于如果一个类Test中有多个方法method1, method2, method3等，可以通过链式编程的方式调用它们，如`test.method1().method2().method3()`。

@TableName("holiday")：将类映射到数据库表名为"holiday"

@ApiModel(value="Holiday对象", description="请假表")：将类作为API模型，用于生成API文档，描述该类是一个"请假表"对象，Swagger测试中可以用到

@ApiModelProperty(value = "请假表id")：对应的也是SwaggerAPI文档测试

@TableId(value="h_id",type=Idtype.AUTO) :value表示数据库表中的主键字段名，type表示主键的生成策略，例如IdType.AUTO表示自增主键

@ExcelProperty("编号")：用于Excel文件导入导出

@ColumnWidth（30）:用于设置Excel文件导出时表头宽度

@JsonFormat（locale = "zh" ,timezone = "GMT+8" ,pattern = "yyyy-MM-dd HH:mm:ss"）：用于格式化日期时间字段的序列化与反序列化过程。locale = "zh"：指定日期时间格式化的区域设置（Locale），这里设置为中文环境，会影响日期、月份、星期等部分的本地化显示。timezone = "GMT+8"：指定日期时间的时区，这里设置为东八区（北京时间）。pattern = "yyyy-MM-dd HH:mm:ss"：定义日期时间字符串的具体格式，这里的格式表示年月日时分秒。

@Data
@EqualsAndHashCode(callSuper = false)
//是否支持链式编程
@Accessors(chain = true)
@TableName("holiday")
@ApiModel(value="Holiday对象", description="请假表")
public class Holiday implements Serializable {

    private static final long serialVersionUID = 1L;

    @ApiModelProperty(value = "请假表id")
    @TableId(value = "h_id", type = IdType.AUTO)
    @ExcelProperty("编号")
    private Integer hId;

    @ExcelProperty("用户id")
    @ApiModelProperty(value = "系统用户表id")
    @TableField(value = "user_id")
    private Long userId;

    @ExcelProperty(value = "请假类型",converter = ExcelHolidayTypeConverter.class)
    @ApiModelProperty(value = " 请假类型")
    @TableField(value = "type")
    private String type;

    @ExcelProperty("请假开始时间")
    @ColumnWidth(30)
    @ApiModelProperty(value = "请假开始时间")
    @JsonFormat(locale = "zh" ,timezone = "GMT+8" ,pattern = "yyyy-MM-dd HH:mm:ss")
    @TableField(value = "start_time")
    private Date startTime;



    @ColumnWidth(30)
    @ExcelProperty("请假结束时间")
    @ApiModelProperty(value = "请假结束时间")
    @JsonFormat(locale = "zh" ,timezone = "GMT+8" ,pattern = "yyyy-MM-dd HH:mm:ss")
    @TableField(value = "end_time")
    private Date endTime;


    @ExcelProperty("请假原因")
    @ApiModelProperty(value = "请假原因")
    private String info;

    @ExcelProperty(value = "请假状态",converter = ExcelHolidayStatusConverter.class)
    @ApiModelProperty(value = "请假状态")
    private String status;


    @ExcelProperty("审批人")
    @ApiModelProperty(value = "审批人")
    @TableField(value = "approve_people")
    private String approvePeople;



    @ColumnWidth(30)
    @ExcelProperty("审批时间")
    @ApiModelProperty(value = "审批时间")
    @TableField(value = "approve_time")
    private Date approveTime;


    @ExcelProperty("驳回原因")
    @ApiModelProperty(value = "驳回原因")
    private String reason;


    @ExcelProperty("逻辑删除")
    @ApiModelProperty(value = "逻辑删除")
    @TableField(value = "is_delete")
    private Integer isDelete;



    @ColumnWidth(30)
    @ExcelProperty("创建时间")
    @ApiModelProperty(value = "创建时间")
    @TableField(value = "create_time" )
    private Date createTime;


    @ExcelProperty("创建人")
    @ApiModelProperty(value = "创建人")
    @TableField(value = "create_by")
    private String createBy;



    @ColumnWidth(30)
    @ExcelProperty("用户修改时间")
    @ApiModelProperty(value = "用户修改时间")
    @TableField(value = "update_time")
    private Date updateTime;


    @ExcelProperty("修改人")
    @ApiModelProperty(value = "修改人")
    @TableField(value = "update_by")
    private String updateBy;


}

Service层接口

IService<T>是一个泛型接口，在框架中提供CRUD的操作服务,即继承这个接口后咱就可以调用Mp当中的基础方法了

public interface IHolidayService extends IService<Holiday>

ServiceImpl实现层

@Service: 告诉Spring这是业务层同样也是继承了ServiceImpl<M extends BaseMapper<T>, T>

第一个参数是Mapper层第二个是实体类

@Service
public class HolidayServiceImpl extends ServiceImpl<HolidayDao, Holiday> implements IHolidayService

Mapper层

@Mapper：告诉Spring这是持久层框架继承了BaseMapper<T>

BaseMapper :在MyBatis-Plus框架中，BaseMapper 是一个泛型接口，提供了基本的CRUD操作方法。

@Mapper
public interface HolidayDao extends BaseMapper<Holiday>

Controller层

@RestController：这是一个复合注解，它组合了 @Controller 和 @ResponseBody。表示当前类是一个控制器

@RequestMapping("/holiday")：该注解用于映射HTTP请求到控制器中的处理方法上，这就是前端访问的路径

@Autowired：Spring框架会自动将符合类型匹配的Bean注入到该字段。自动装配后咱们就可以直接调用MP中整合的方法了

@RestController
@RequestMapping("/holiday")
public class HolidayController  {


    @Autowired
    private IHolidayService iHolidayService;
}

条件构造器

用于简化SQL查询和更新的编写过程。条件构造器主要通过Wrapper类及其子类来实现对数据库操作时复杂的动态SQL构建。在后续的方法都会用到，在条件构造器Wrapper最顶级的条件构造抽象类，主要有下述四个子类

QueryWrapper：用于封装查询条件

UpdateWrapper：用于封装更新条件

LambdaQueryWrapper：用于使用Lambda语法封装查询条件

LambdaUpdateWrapper：用于使用Lambda语法封装更新条件

功能分类

插入

Service层：

类型	参数名	描述
T	entity	实体对象
Collection<T>	EntityList	实体对象集合
int	batchSize	插入批次数量
Wrapper<T>	updateWrapper	实体对象封装操作类 UpdateWrapper

// 插入一条记录（选择字段，策略插入）
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);

Save()

Holiday holidaySave=new Holiday();
        holidaySave.setUserId(5L).setStartTime(new Date()).setEndTime(new Date()).setInfo("test").setUserId(5L).setType("3");
        System.out.println(holidaySave);
        iHolidayService.save(holidaySave);

测试结果

Holiday(hId=null, userId=5, type=3, startTime=Fri Mar 01 15:58:32 CST 2024, endTime=Fri Mar 01 15:58:32 CST 2024, info=test, status=null, approvePeople=null, approveTime=null, reason=null, isDelete=null, createTime=null, createBy=null, updateTime=null, updateBy=null)

saveOrUpdate(T entity);

它会根据实体对象的@TableId注解是否存在值来决定是插入还是更新。若主键有值且数据库中有对应记录，则执行更新；否则执行插入。

无主键id

有主键id

 holidaySaveOrUpdate.setHId(77).setUserId(5L).setStartTime(new Date()).setEndTime(new Date()).setInfo("test").setUserId(5L).setType("3");

两个方法差异总结

根据情况选择调用，但saveOrUpdate方法更加的实用

boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper);

注意事项：不可以这样写根据上面的代码数据库中已经有一个 hId 为 77 的记录，则该记录的所有信息都将被传入的 holidaySaveOrUpdate 对象中的值所覆盖。我们需要通过构造器去指定更新条件和字段

iHolidayService.saveOrUpdate(holidaySaveOrUpdate,new UpdateWrapper<>());

正确写法：

 UpdateWrapper<Holiday> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("h_id", 77).set("type", "4"); // 指定只更新type字段
        iHolidayService.saveOrUpdate(holidaySaveOrUpdate, updateWrapper);

方法优缺点

boolean save(T entity);
        功能：插入一条记录，根据实体类字段插入所有非null属性。
        优点：插入操作简便快捷，无需关心主键是否已存在。
        缺点：如果实体对象主键（id）有值且数据库中已有相同主键记录时，会尝试插入新记录，可能导致主键冲突。

boolean saveBatch(Collection<T> entityList);
        功能：批量插入多条记录，适用于集合中的每个实体对象。
        优点：批量处理，提高效率。
        缺点：同样不考虑主键冲突问题，可能需要额外逻辑判断。

boolean saveBatch(Collection<T> entityList, int batchSize);
        功能：分批进行批量插入，通过指定每批大小来控制SQL执行频率，降低数据库压力。
        优点：细粒度控制批量操作，有效防止因一次性插入大量数据导致的数据库压力过大问题。
        缺点：需合理设置批次大小，否则可能影响性能或引发其他问题。

boolean saveOrUpdate(T entity);
        功能：根据实体对象的@TableId注解是否存在值来决定是插入还是更新。若主键有值且数据库中有对应记录，则执行更新；否则执行插入。
        优点：自动识别插入或更新，减少代码编写量。
        缺点：仅对具有@TableId注解的主键字段有效，对于复杂条件下的更新场景不够灵活。

boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper);
        功能：首先尝试根据updateWrapper定义的条件进行更新，如果没有匹配到记录，则执行saveOrUpdate(T entity)方法进行插入或更新。
        优点：提供更精细的更新条件控制，结合saveOrUpdate()方法实现智能插入或更新。
        缺点：需要构建UpdateWrapper，增加了编码复杂性。

boolean saveOrUpdateBatch(Collection<T> entityList);
        功能：批量执行保存或更新操作，适用于集合中的每个实体对象。
        优点：批量处理，高效便捷地同时处理多个实体对象的插入或更新。
        缺点：同saveOrUpdate()方法，仅能基于主键判断是否更新。

boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);
        功能：与saveOrUpdateBatch类似，但支持分批处理，按批次执行保存或更新操作。
        优点：在批量处理的基础上又兼顾了数据库压力控制，更加适合大数据量操作。
        缺点：需要合理设定批次大小，以及处理可能出现的异常情况。

总结：在调用方法时根据自己的实际业务来进行选择，简单的就可以直接选择实体类对象，需要对条件进行筛选构造复杂条件时使用构造器，SaveOrUpdate相较于会更加适合一些，不用考虑主键冲突问题，但在实体类需要记得加上主键注解

Mapper层：

insert():将给定的实体类对象 entity 的所有非null属性作为新行数据插入到对应的数据库表中,还是会存在主键冲突的问题

int insert(T entity);

更新

前四条在上面已有介绍

类型	参数名	描述
T	entity	实体对象
Collection<T>	EntityList	实体对象集合
int	batchSize	插入批次数量
Wrapper<T>	updateWrapper	实体对象封装操作类 UpdateWrapper

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


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

Update():

         UpdateWrapper<Holiday> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("h_id", 77).set("type", "5"); // 指定只更新type字段
     iHolidayService.update(holidayUpdate, updateWrapper);
        iHolidayService.update(updateWrapper);

UpdateByid():

 Holiday holidayUpdate=new Holiday();
        holidayUpdate.setType("6").setHId(77);
        iHolidayService.updateById(holidayUpdate);

根据 UpdateWrapper 条件更新记录
        方法：boolean update(Wrapper<T> updateWrapper);
        优点：
         高度灵活，可以自定义复杂的更新条件和需要更新的字段。可以精确控制哪些数据会被修改，无需提供实体对象。
缺点：
        必须手动构建UpdateWrapper，编码工作量相对较大，尤其是当更新涉及多个字段时。

根据 whereWrapper 条件更新记录（同时提供了更新实体）
方法：boolean update(T updateEntity, Wrapper<T> whereWrapper);
        优点：
        结合了UpdateWrapper的灵活性和实体对象的便捷性，通过whereWrapper设置筛选条件,updateEntity中非null属性作为待更新字段。
        缺点：
        如果只是简单地基于主键进行更新，使用此方法可能过于复杂。

根据ID选择修改
方法：boolean updateById(T entity);
        优点：
        简单易用，仅需一个实体对象，框架会自动根据实体类中的@TableId注解找到主键，并基于主键值执行更新操作。
        缺点：
        更新范围受限于主键，无法实现更复杂的条件更新。

根据ID批量更新
方法：boolean updateBatchById(Collection<T> entityList);
        优点：
        批量处理提高效率，适用于大批量、相同类型实体对象的更新操作。
        缺点：
        同样只能基于主键进行更新，且不能指定额外的更新条件。

根据ID批量更新并指定批次大小
方法：boolean updateBatchById(Collection<T> entityList, int batchSize);
        优点：
        在批量更新的基础上，支持分批处理，可降低数据库压力，防止因一次性执行大量SQL语句导致的问题。
        缺点：
        需要开发者合理设定批次大小，对性能调优有一定的要求

Mapper层

int update(@Param(Constants.ENTITY) T updateEntity, @Param(Constants.WRAPPER) Wrapper<T> whereWrapper);
// 根据 ID 修改
int updateById(@Param(Constants.ENTITY) T entity);

// 更新操作示例：
Holiday holidayToUpdate = new Holiday();
holidayToUpdate.setId(1L); // 设置要更新的Holiday的ID
holidayToUpdate.setName("New Year's Day"); // 要更新的字段

// 根据ID更新
int rowsAffectedById = this.BaseMapper.updateById(holidayToUpdate);

// 或者根据自定义条件更新
Wrapper<Holiday> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(Holiday::getType, "6");
holidayToUpdate.setStartDate(new Date()); // 更新开始日期
int rowsAffectedByWrapper = this.BaseMapper.update(holidayToUpdate, wrapper);

删除

Service层：

// 根据 queryWrapper 设置的条件，删除记录
boolean remove(Wrapper<T> queryWrapper);
// 根据 ID 删除
boolean removeById(Serializable id);
// 根据 columnMap 条件，删除记录
boolean removeByMap(Map<String, Object> columnMap);
// 删除（根据ID 批量删除）
boolean removeByIds(Collection<? extends Serializable> idList);

boolean remove(Wrapper<T> queryWrapper);
使用自定义查询条件删除记录：

   LambdaQueryWrapper<Holiday> wrapper = new LambdaQueryWrapper<>();
   wrapper.eq(Holiday::getType, "6"); // 删除Type为"6"的所有假期记录
   boolean result = iHolidayService.remove(wrapper);

boolean removeById(Serializable id);
根据主键ID删除单个记录。

   Long holidayIdToDelete = 1L; // 要删除的假期ID
   boolean result = iHolidayService.removeById(holidayIdToDelete);

boolean removeByMap(Map<String, Object> columnMap);
根据列名和值的映射关系删除记录

   Map<String, Object> condition = new HashMap<>();
   condition.put("Type", "5");
   condition.put("info", "test");
   boolean result =iHolidayService.removeByMap(condition);

boolean removeByIds(Collection<? extends Serializable> idList);
根据ID列表批量删除多个记录。

   List<Long> holidayIdsToDelete = Arrays.asList(1L, 2L, 3L); // 要删除的假期ID集合
   boolean result = iHolidayService.removeByIds(holidayIdsToDelete);

Mapper层

// 根据 entity 条件，删除记录
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
// 删除（根据ID 批量删除）
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
// 根据 ID 删除
int deleteById(Serializable id);
// 根据 columnMap 条件，删除记录
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

查询

get方法

// 根据 ID 查询
T getById(Serializable id);
// 根据 Wrapper，查询一条记录。结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")
T getOne(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
T getOne(Wrapper<T> queryWrapper, boolean throwEx);
// 根据 Wrapper，查询一条记录
Map<String, Object> getMap(Wrapper<T> queryWrapper);
// 根据 Wrapper，查询一条记录
<V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

T getById(Serializable id);
根据主键ID查询单个记录。

   Long holidayId = 1L; // 要查询的假期ID
   Holiday holiday = iHolidayService.getById(holidayId);

T getOne(Wrapper<T> queryWrapper);
根据自定义条件查询一条记录。如果结果集包含多条记录，则会抛出异常。最好加上.last("limit 1")先保证不会出错

   LambdaQueryWrapper<Holiday> wrapper = new LambdaQueryWrapper<>();
   wrapper.eq(Holiday::getHid, 44L); // 查询Hid为44的一条假期记录
   Holiday holiday = iHolidayService.getOne(wrapper);

T getOne(Wrapper<T> queryWrapper, boolean throwEx);
同样根据自定义条件查询一条记录，但可以通过参数throwEx控制是否在结果集有多条时抛出异常。

 LambdaQueryWrapper<Holiday> wrapper = new LambdaQueryWrapper<>();
   wrapper.eq(Holiday::getHid, 44L); 
   Holiday holiday = iHolidayService.getOne(wrapper, true); // 如果有多条记录则抛出异常

Map<String, Object> getMap(Wrapper<T> queryWrapper);
根据自定义条件查询一条记录，并以字段名-值的形式返回一个Map对象。

   LambdaQueryWrapper<Holiday> wrapper = new LambdaQueryWrapper<>();
   wrapper.eq(Holiday::getHid, 1L);
   Map<String, Object> holidayMap = iHolidayService.getMap(wrapper);

<V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);
根据自定义条件查询一条记录，并通过提供的函数mapper将查询结果映射到指定类型的对象

// 定义一个转换函数，将查询结果映射到自定义对象中
Function<Holiday, CustomHolidayVO> mapper = holiday -> {
    CustomHolidayVO vo = new CustomHolidayVO();
    vo.setHId(holiday.getHId());
    vo.setUserId(holiday.getUserId());
    vo.setType(holiday.getType());
    // ... 其他字段的映射
    return vo;
};

// 创建一个Wrapper用于查询
LambdaQueryWrapper<Holiday> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(Holiday::getHId, 1); // 假设查询编号为1的请假记录

// 调用getObj方法并传递查询条件和转换函数
CustomHolidayVO customHoliday = iHolidayService.getObj(wrapper, mapper);

List（）

List方法和get方法差别在于一个是拿全部一个是只拿一条数据

// 查询所有
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 条件，查询全部记录
<V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

List<T> list();
查询所有Holiday记录，并将结果以Holiday对象列表的形式返回。

List<Holiday> allHolidays = iHolidayService.list();

List<T> list(Wrapper<T> queryWrapper);
根据传入的自定义条件查询Holiday记录。例如，查找特定时间段内的请假记录：

LambdaQueryWrapper<Holiday> wrapper = new LambdaQueryWrapper<>();
wrapper.between(Holiday::getStartTime, startDate, endDate);
List<Holiday> filteredHolidays = iHolidayService.list(wrapper);

Collection<T> listByIds(Collection<? extends Serializable> idList);
根据ID列表批量查询Holiday记录。

List<Long> holidayIds = Arrays.asList(1L, 2L, 3L);
Collection<Holiday> holidaysByIds = iHolidayService.listByIds(holidayIds);

Collection<T> listByMap(Map<String, Object> columnMap);
根据列名和值的映射关系查询Holiday记录。

Map<String, Object> condition = new HashMap<>();
condition.put("user_id", 5);
condition.put("status", "0");
Collection<Holiday> approvedHolidaysForUser = iHolidayService.listByMap(condition);

List<Map<String, Object>> listMaps();
查询所有Holiday记录并以字段名-值形式存储到Map中，然后将这些Map组成一个列表返回。

List<Map<String, Object>> holidayMaps = iHolidayService.listMaps();

List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper);
同上，但会先应用自定义查询条件。

LambdaQueryWrapper<Holiday> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(Holiday::getStatus, "5");
List<Map<String, Object>> approvedHolidayMaps = iHolidayService.listMaps(wrapper);

List<Object> listObjs();
查询所有Holiday记录并以Object列表的形式返回（通常不推荐这样使用）。

List<Object> holidayObjects = iHolidayService.listObjs();

<V> List<V> listObjs(Function<? super Object, V> mapper);
查询所有Holiday记录，并通过函数mapper将每个记录转换为指定类型V的对象后放入列表中。

Function<Holiday, CustomVO> voMapper = holiday -> {
    // ... 实现转换逻辑
};
List<CustomVO> customVOs = iHolidayService.listObjs(voMapper);

List<Object> listObjs(Wrapper<T> queryWrapper);
根据自定义条件查询所有Holiday记录，并以Object列表的形式返回。

LambdaQueryWrapper<Holiday> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(Holiday::getType, "5");
List<Object> annualLeaveObjects = iHolidayService.listObjs(wrapper);

<V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);
根据自定义条件查询所有Holiday记录，然后通过函数mapper将每个记录转换为指定类型V的对象后放入列表中。

LambdaQueryWrapper<Holiday> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(Holiday::getType, "3");

Function<Holiday, AnnualLeaveVO> voMapper = holiday -> {
    // ... 实现转换逻辑
};
List<AnnualLeaveVO> annualLeaveVOs = iHolidayService.listObjs(wrapper, voMapper);

QueryMapper构造器

select(String... sqlSelect)
select(Predicate<TableFieldInfo> predicate)
select(Class<T> entityClass, Predicate<TableFieldInfo> predicate)

select(String... sqlSelect)
该方法允许您传入一系列SQL字段名作为字符串数组。这些字段将被包含在生成的SQL查询语句的SELECT部分，仅返回指定的列。

   List<Holiday> holidays = this.baseMapper.select("h_id", "user_id", "type", "start_time", "end_time");

select(Predicate<TableFieldInfo> predicate)
这个方法接受一个谓词（Predicate）参数，用于筛选实体类T的字段信息。如果给定的谓词对实体类中的某个字段返回true，则该字段会被包含在查询结果中。

   Predicate<TableFieldInfo> keepOnlyDateFields = field -> 
       field.getColumn().matches("(start_time|end_time)");
   
   List<Holiday> dateRangeHolidays = this.baseMapper.select(keepOnlyDateFields);

select(Class<T> entityClass, Predicate<TableFieldInfo> predicate)
此版本的方法与上一个类似，但同时要求显式提供实体类类型T，以便MyBatis-Plus能够正确解析和处理实体类的字段信息。

   List<Holiday> filteredHolidays = this.baseMapper.select(Holiday.class, field -> 
       !field.getColumn().equals("reason")); // 不包含"reason"字段

Mapper层

基本上会搭着条件构造器一起使用

// 根据 ID 查询
T selectById(Serializable id);
// 根据 entity 条件，查询一条记录
T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

// 查询（根据ID 批量查询）
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
// 根据 entity 条件，查询全部记录
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 查询（根据 columnMap 条件）
List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
// 根据 Wrapper 条件，查询全部记录
List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录。注意： 只返回第一个字段的值
List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

// 根据 entity 条件，查询全部记录（并翻页）
IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录（并翻页）
IPage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询总记录数
Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

常用方法

查询条数

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

int count();
此方法返回实体类T的总记录数，即不带任何条件的全部记录数量。

   int totalHolidayCount = this.baseMapper.count();
   // 上述代码将返回数据库中所有Holiday记录的总数。

int count(Wrapper<T> queryWrapper);
此方法接受一个Wrapper<T>对象作为参数，它封装了SQL查询的条件。返回值是满足这些条件的记录总数。

   LambdaQueryWrapper<Holiday> wrapper = new LambdaQueryWrapper<>();
   wrapper.eq(Holiday::getStatus, "5").ge(Holiday::getStartTime, new Date());
   
   int approvedHolidayCount = this.baseMapper.count(wrapper);
   // 上述代码将返回数据库中状态为"5"且开始时间大于等于当前时间的所有Holiday记录的数量。

分页

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

条件筛选

eq 等于

eq(R column, Object val)
eq(boolean condition, R column, Object val)

eq(R column, Object val)
此方法根据实体类中的字段名和对应的值创建一个等于（equal to）的查询条件。

   LambdaQueryWrapper<Holiday> wrapper = new LambdaQueryWrapper<>();
   wrapper.eq(Holiday::getStatus, "5"); // 查询状态为"approved"的所有请假记录

   List<Holiday> approvedHolidays = this.baseMapper.selectList(wrapper);

eq(boolean condition, R column, Object val)
这个版本的方法允许您根据布尔条件决定是否添加等值查询条件。当condition为true时，将添加等于条件；否则不添加。

   boolean includeApprovedOnly = true;
   LambdaQueryWrapper<Holiday> wrapper = new LambdaQueryWrapper<>();
   wrapper.eq(includeApprovedOnly, Holiday::getStatus, "5"); // 如果includeApprovedOnly为true，则只查询状态为"5"的记录

   List<Holiday> holidays = this.baseMapper.selectList(wrapper);

ne 不等于

ne(R column, Object val)
ne(boolean condition, R column, Object val)

gt 大于 ge大于等于

gt(R column, Object val)
gt(boolean condition, R column, Object val)

lt 小于 le 小于等于

lt(R column, Object val)
lt(boolean condition, R column, Object val)

between

between(R column, Object val1, Object val2)
between(boolean condition, R column, Object val1, Object val2)

like 模糊查询

like(R column, Object val)
like(boolean condition, R column, Object val)

子查询 in

in(R column, Collection<?> value)
in(boolean condition, R column, Collection<?> value)