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

news2024/11/16 8:43:12

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层：

类型 参数名描述
Tentity实体对象
Collection<T>EntityList

实体对象集合

intbatchSize插入批次数量
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);

更新

前四条在上面已有介绍  

类型 参数名描述
Tentity实体对象
Collection<T>EntityList

实体对象集合

intbatchSize插入批次数量
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)
 更多筛选条件请查看官网

条件构造器 | MyBatis-Plus

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1482665.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【重要公告】对BSV警报系统AS的释义

【重要公告】对BSV警报系统AS的释义

​​发表时间&#xff1a;2024年2月15日 由BSV区块链协会开发并管理的BSV警报系统&#xff08;Alert System&#xff0c;以下简称“AS”&#xff09;是BSV网络的重要组件。它是一个复杂的系统&#xff0c;主要职能是在BSV区块链网络内发布信息。这些信息通常与网络访问规则NAR相…
阅读更多...
java数据结构与算法刷题-----LeetCode572. 另一棵树的子树（经典题，树字符串化KMP）

java数据结构与算法刷题-----LeetCode572. 另一棵树的子树（经典题，树字符串化KMP）

java数据结构与算法刷题目录&#xff08;剑指Offer、LeetCode、ACM&#xff09;-----主目录-----持续更新(进不去说明我没写完)&#xff1a;https://blog.csdn.net/grd_java/article/details/123063846 文章目录 1. 暴力求解&#xff0c;深度优先2. KMP算法进行串匹配 1. 暴力求…
阅读更多...
Spring-web-Mvc

Spring-web-Mvc

文章目录 目录 文章目录 前言 1 . 什么是Spring MVC? 1.1 MVC定义 1.2 主要作用 2. Spring MVC 接受响应数据 2.1 RequestMapping注解配置访问路径 2.2 请求 2.2.1 传递单个参数 2.2.2 传递多个参数 2.2.3 传递对象 2.2.4 后端参数重命名&#xff08;后端参数映射…
阅读更多...
Linux技巧|centos7|重新认识和学习egrep和grep命令

Linux技巧|centos7|重新认识和学习egrep和grep命令

前言&#xff1a; 相信提高文本检索工具&#xff0c;大家脑海里肯定有很多工具会自动跳出来&#xff0c;比如&#xff0c;grep&#xff0c;egrep&#xff0c;sed&#xff0c;cat&#xff0c;more&#xff0c;less&#xff0c;cut&#xff0c;awk&#xff0c;vim&#xff0c;vi…
阅读更多...
Find My扫地机器人|苹果Find My技术与机器人结合，智能防丢，全球定位

Find My扫地机器人|苹果Find My技术与机器人结合，智能防丢，全球定位

扫地机器人又称自动打扫机、智能吸尘、机器人吸尘器等&#xff0c;是智能家电的一种&#xff0c;能凭借人工智能&#xff0c;自动在房间内完成地板清理工作。一般采用刷扫和真空方式&#xff0c;将地面杂物先吸纳进入自身的垃圾收纳盒&#xff0c;从而完成地面清理的功能。现今…
阅读更多...
【Vue3】CSS 新特性

【Vue3】CSS 新特性

:slotted <template> <!-- App.vue--><Son ><div class"a">我要插入了</div></Son> </template><script setup lang"ts"> import Son from ./components/Son.vue </script><style></sty…
阅读更多...
最佳实践：Websocket 长连接状态如何保持

最佳实践：Websocket 长连接状态如何保持

WebSocket 是一种支持通过单个 TCP 连接进行全双工通信的协议&#xff0c;相较于传统的 HTTP 协议&#xff0c;它更适合需要实时交互的应用场景。此协议在现代 Web 应用中扮演着至关重要的角色&#xff0c;尤其是在需要实时更新和通信的场合下维持持久连接。本文将探讨 WebSock…
阅读更多...
Windows系统误删文件恢复

Windows系统误删文件恢复

最近很多用户反馈误删文件的场景比较多.下面华仔将讲解数据恢复的原理和过程.以及一些注意事项。 建议的数据恢复软件 1.EaseUS Data Recovery Wizard(易我数据恢复)需要断网使用 2.Wondershare Recoverit(万兴数据恢复)&#xff0c; Windows系统删除文件原理&#xff1a;如果是…
阅读更多...
每周一算法：双向广搜

每周一算法：双向广搜

题目链接 字符串变换 题目描述 已知有两个字串 A , B A,B A,B&#xff0c;及一组字串变换的规则&#xff08;至多 6 6 6个规则&#xff09;: A 1 → B 1 A_1→B_1 A1​→B1​ A 2 → B 2 A_2→B_2 A2​→B2​ … 规则的含义为&#xff1a;在 A A A中的子串 A 1 A_1 A1​…
阅读更多...
利用FFMPEG 将RTSP流的音频G711 转码为AAC 并 推流到RTMP

利用FFMPEG 将RTSP流的音频G711 转码为AAC 并 推流到RTMP

之前我们的视频转码项目中 是没有加入音频的 现在 需要加入音频 &#xff0c;由于RTMP只支持AAC的 音频流 而有的RTSP流的音频编码并不是AAC 大多数都是G711编码 还分为G711A 和G711U 之前用ffmpeg命令行可以直接 完成转码 并推送到RTMP 但是考虑到无法获取更详细的状…
阅读更多...
操作系统—xv6内核环境配置

操作系统—xv6内核环境配置

文章目录 xv6内核环境配置1.开发环境的准备(1).如果日常用Linux(2).Windows的回合#1.两个常见方法#2.wsl的一点安装细节#3.记得升级成wsl-2 (3).如果你是macOS#1.一些起因#2.最乐的一集#3.Homebrew的配置#4.mac用户的特权 2.先换apt源3.安装xv6的依赖4.克隆RISC-V GNU 编译器工…
阅读更多...
在Centos中用Docker部署oracle-12c

在Centos中用Docker部署oracle-12c

一、介绍 Oracle 12c是Oracle 11g的后续版本。12c代表云计算&#xff08;Cloud Computing&#xff09;&#xff0c;这是Oracle在该版本中强调的一个关键概念。它具有多租户架构、数据库内存、安全增强、大数据管理和自动化管理等功能。它被广泛应用于企业级应用程序和大型数据…
阅读更多...
加密与安全_深入了解Hmac算法（消息认证码）

加密与安全_深入了解Hmac算法（消息认证码）

文章目录 PreHMAC概述常见的Hmac算法Code随机的key的生成 KeyGeneratorHmacMD5用Hmac算法取代原有的自定义的加盐算法 HmacMD5 VS MD5HmacSHA256 Pre 加密与安全_深入了解哈希算法中我们提到&#xff0c; 存储用户的哈希口令时&#xff0c;要加盐存储&#xff0c;目的就在于抵…
阅读更多...
Zabbix 系统告警“More than 75% used in the configuration cache”处理办法

Zabbix 系统告警“More than 75% used in the configuration cache”处理办法

Zabbix系统报错提示 Zabbix 系统告警“More than 75% used in the configuration cache”&#xff0c;看了一下意思是可用的配置缓存超过75%。 修改缓存大小 vim /etc/zabbix/zabbix_server.confesc : /CacheSize 找到配置 将64M改大一点&#xff0c;保存退出。 重启zabbix…
阅读更多...
14.网络游戏逆向分析与漏洞攻防-网络通信数据包分析工具-数据包分析工具界面与通信设计

14.网络游戏逆向分析与漏洞攻防-网络通信数据包分析工具-数据包分析工具界面与通信设计

内容参考于&#xff1a; 易道云信息技术研究院VIP课 上一个内容&#xff1a;13.如果没有工具就创造工具 码云地址&#xff08;master 分支&#xff09;&#xff1a;https://gitee.com/dye_your_fingers/titan 码云版本号&#xff1a;fef5089bd11dfb86ae8b4e26f25cf59e85f896…
阅读更多...
练习 3 Web [ACTF2020 新生赛]Upload

练习 3 Web [ACTF2020 新生赛]Upload

[ACTF2020 新生赛]Upload1 中间有上传文件的地方&#xff0c;试一下一句话木马 txt 不让传txt 另存为tlyjpg&#xff0c;木马文件上传成功 给出了存放目录&#xff1a; Upload Success! Look here~ ./uplo4d/06a9d80f64fded1e542a95e6d530c70a.jpg 下一步尝试改木马文件后缀…
阅读更多...
Qt应用软件【测试篇】vargrid内存检查工具

Qt应用软件【测试篇】vargrid内存检查工具

文章目录 vargrid介绍vargrid官网vargrid安装常用命令Valgrind的主要命令vargrid介绍 Valgrind是一个用于构建动态分析工具的框架，能自动检测许多内存管理和线程错误，并详细分析程序性能。Valgrind发行版包括七个成熟工具：内存错误检测器、两个线程错误检测器、缓存和分支预…
阅读更多...
autoware.universe中跟踪模块详解，一看就懂！

autoware.universe中跟踪模块详解，一看就懂！

目录 问题：阅读关键点:总结问题： 根据对预测模块代码的分析，发现预测框出现在点云前方的原因在于跟踪框出现在点云前方 对rviz上的目标进行观察后发现 车辆的检测框先出来一段时间后，跟踪框和预测框同步一块出来 跟踪框总是超出点云一部分 阅读关键点: 每个跟踪器最少要统计…
阅读更多...
【JSON2WEB】07 Amis可视化设计器CRUD增删改查

【JSON2WEB】07 Amis可视化设计器CRUD增删改查

总算到重点中的核心内容&#xff0c;CRUD也就是增删改查&#xff0c;一个设计科学合理的管理信息系统&#xff0c;95%的就是CRUD&#xff0c;达不到这个比例要重新考虑一下你的数据库设计了。 1 新增页面 Step 1 启动amis-editor Setp 2 新增页面 名称和路径随便命名&#xf…
阅读更多...
网络安全、信息安全、计算机安全，有何区别？

网络安全、信息安全、计算机安全，有何区别？

这三个概念都存在&#xff0c;一般人可能会混为一谈。 究竟它们之间是什么关系&#xff1f;并列&#xff1f;交叉&#xff1f; 可能从广义上来说它们都可以用来表示安全security这样一个笼统的概念。 但如果从狭义上理解&#xff0c;它们应该是有区别的&#xff0c;区别在哪呢&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023