Mybatis之Mybatis-Plus插件使用简述

柔光的暖阳◎ 2023-02-11 03:10 74阅读 0赞

还在为些SQL而烦恼的同学这个插件真的是好的福音，因为Mybatis-plus是真的好用。话不多说直接开整。

1.引入POM

首先说下项目背景该项目是基于JDK1.8、SpringBoot 2.0.2版本创建的，引入Mybatis-Plus插件pom，注意的是项目中集成mybatis-plus需要把mybatis、mybatis-spring去掉，避免冲突。(好的建议实体都结合lombok这个工具，添加了这个依赖，开发工具需要安装Lombok插件，最常用的用法就是在实体类中使用它的@Data注解，这样实体类就不用写set、get、toString等方法了，当然好处不止这一点点，自行百度下啊欢迎分享)。

<dependency>
 <groupId>com.baomidou</groupId>
 <artifactId>mybatis-plus-boot-starter</artifactId>
 <version>3.3.1</version>
 </dependency>

2.代码引入

引入插件pom之后需要service层和dao层需要实现baomidou下面的相关接口，具体实施如下：

public interface IService<T> {
 
 /**
 * 默认批次提交数量
 */
 int DEFAULT_BATCH_SIZE = 1000;
 
 /**
 * 插入一条记录（选择字段，策略插入）
 *
 * @param entity 实体对象
 */
 default boolean save(T entity) {
 return SqlHelper.retBool(getBaseMapper().insert(entity));
 }
 
 /**
 * 插入（批量）
 *
 * @param entityList 实体对象集合
 */
 @Transactional(rollbackFor = Exception.class)
 default boolean saveBatch(Collection<T> entityList) {
 return saveBatch(entityList, DEFAULT_BATCH_SIZE);
 }
 
 /**
 * 插入（批量）
 *
 * @param entityList 实体对象集合
 * @param batchSize 插入批次数量
 */
 boolean saveBatch(Collection<T> entityList, int batchSize);
 
 /**
 * 批量修改插入
 *
 * @param entityList 实体对象集合
 */
 @Transactional(rollbackFor = Exception.class)
 default boolean saveOrUpdateBatch(Collection<T> entityList) {
 return saveOrUpdateBatch(entityList, DEFAULT_BATCH_SIZE);
 }
 
 /**
 * 批量修改插入
 *
 * @param entityList 实体对象集合
 * @param batchSize 每次的数量
 */
 boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);
 
 /**
 * 根据 ID 删除
 *
 * @param id 主键ID
 */
 default boolean removeById(Serializable id) {
 return SqlHelper.retBool(getBaseMapper().deleteById(id));
 }
 
 /**
 * 根据 columnMap 条件，删除记录
 *
 * @param columnMap 表字段 map 对象
 */
 default boolean removeByMap(Map<String, Object> columnMap) {
 Assert.notEmpty(columnMap, "error: columnMap must not be empty");
 return SqlHelper.retBool(getBaseMapper().deleteByMap(columnMap));
 }
 
 /**
 * 根据 entity 条件，删除记录
 *
 * @param queryWrapper 实体包装类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
 */
 default boolean remove(Wrapper<T> queryWrapper) {
 return SqlHelper.retBool(getBaseMapper().delete(queryWrapper));
 }
 
 /**
 * 删除（根据ID 批量删除）
 *
 * @param idList 主键ID列表
 */
 default boolean removeByIds(Collection<? extends Serializable> idList) {
 if (CollectionUtils.isEmpty(idList)) {
 return false;
 }
 return SqlHelper.retBool(getBaseMapper().deleteBatchIds(idList));
 }
 
 /**
 * 根据 ID 选择修改
 *
 * @param entity 实体对象
 */
 default boolean updateById(T entity) {
 return SqlHelper.retBool(getBaseMapper().updateById(entity));
 }
 
 /**
 * 根据 UpdateWrapper 条件，更新记录 需要设置sqlset
 *
 * @param updateWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper}
 */
 default boolean update(Wrapper<T> updateWrapper) {
 return update(null, updateWrapper);
 }
 
 /**
 * 根据 whereEntity 条件，更新记录
 *
 * @param entity 实体对象
 * @param updateWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper}
 */
 default boolean update(T entity, Wrapper<T> updateWrapper) {
 return SqlHelper.retBool(getBaseMapper().update(entity, updateWrapper));
 }
 
 /**
 * 根据ID 批量更新
 *
 * @param entityList 实体对象集合
 */
 @Transactional(rollbackFor = Exception.class)
 default boolean updateBatchById(Collection<T> entityList) {
 return updateBatchById(entityList, DEFAULT_BATCH_SIZE);
 }
 
 /**
 * 根据ID 批量更新
 *
 * @param entityList 实体对象集合
 * @param batchSize 更新批次数量
 */
 boolean updateBatchById(Collection<T> entityList, int batchSize);
 
 /**
 * TableId 注解存在更新记录，否插入一条记录
 *
 * @param entity 实体对象
 */
 boolean saveOrUpdate(T entity);
 
 /**
 * 根据 ID 查询
 *
 * @param id 主键ID
 */
 default T getById(Serializable id) {
 return getBaseMapper().selectById(id);
 }
 
 /**
 * 查询（根据ID 批量查询）
 *
 * @param idList 主键ID列表
 */
 default List<T> listByIds(Collection<? extends Serializable> idList) {
 return getBaseMapper().selectBatchIds(idList);
 }
 
 /**
 * 查询（根据 columnMap 条件）
 *
 * @param columnMap 表字段 map 对象
 */
 default List<T> listByMap(Map<String, Object> columnMap) {
 return getBaseMapper().selectByMap(columnMap);
 }
 
 /**
 * 根据 Wrapper，查询一条记录 
 * 结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")
 *
 * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
 */
 default T getOne(Wrapper<T> queryWrapper) {
 return getOne(queryWrapper, true);
 }
 
 /**
 * 根据 Wrapper，查询一条记录
 *
 * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
 * @param throwEx 有多个 result 是否抛出异常
 */
 T getOne(Wrapper<T> queryWrapper, boolean throwEx);
 
 /**
 * 根据 Wrapper，查询一条记录
 *
 * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
 */
 Map<String, Object> getMap(Wrapper<T> queryWrapper);
 
 /**
 * 根据 Wrapper，查询一条记录
 *
 * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
 * @param mapper 转换函数
 */
 <V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);
 
 /**
 * 查询总记录数
 *
 * @see Wrappers#emptyWrapper()
 */
 default int count() {
 return count(Wrappers.emptyWrapper());
 }
 
 /**
 * 根据 Wrapper 条件，查询总记录数
 *
 * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
 */
 default int count(Wrapper<T> queryWrapper) {
 return SqlHelper.retCount(getBaseMapper().selectCount(queryWrapper));
 }
 
 /**
 * 查询列表
 *
 * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
 */
 default List<T> list(Wrapper<T> queryWrapper) {
 return getBaseMapper().selectList(queryWrapper);
 }
 
 /**
 * 查询所有
 *
 * @see Wrappers#emptyWrapper()
 */
 default List<T> list() {
 return list(Wrappers.emptyWrapper());
 }
 
 /**
 * 翻页查询
 *
 * @param page 翻页对象
 * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
 */
 default <E extends IPage<T>> E page(E page, Wrapper<T> queryWrapper) {
 return getBaseMapper().selectPage(page, queryWrapper);
 }
 
 /**
 * 无条件翻页查询
 *
 * @param page 翻页对象
 * @see Wrappers#emptyWrapper()
 */
 default <E extends IPage<T>> E page(E page) {
 return page(page, Wrappers.emptyWrapper());
 }
 
 /**
 * 查询列表
 *
 * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
 */
 default List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper) {
 return getBaseMapper().selectMaps(queryWrapper);
 }
 
 /**
 * 查询所有列表
 *
 * @see Wrappers#emptyWrapper()
 */
 default List<Map<String, Object>> listMaps() {
 return listMaps(Wrappers.emptyWrapper());
 }
 
 /**
 * 查询全部记录
 */
 default List<Object> listObjs() {
 return listObjs(Function.identity());
 }
 
 /**
 * 查询全部记录
 *
 * @param mapper 转换函数
 */
 default <V> List<V> listObjs(Function<? super Object, V> mapper) {
 return listObjs(Wrappers.emptyWrapper(), mapper);
 }
 
 /**
 * 根据 Wrapper 条件，查询全部记录
 *
 * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
 */
 default List<Object> listObjs(Wrapper<T> queryWrapper) {
 return listObjs(queryWrapper, Function.identity());
 }
 
 /**
 * 根据 Wrapper 条件，查询全部记录
 *
 * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
 * @param mapper 转换函数
 */
 default <V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper) {
 return getBaseMapper().selectObjs(queryWrapper).stream().filter(Objects::nonNull).map(mapper).collect(Collectors.toList());
 }
 
 /**
 * 翻页查询
 *
 * @param page 翻页对象
 * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
 */
 default <E extends IPage<Map<String, Object>>> E pageMaps(E page, Wrapper<T> queryWrapper) {
 return getBaseMapper().selectMapsPage(page, queryWrapper);
 }
 
 /**
 * 无条件翻页查询
 *
 * @param page 翻页对象
 * @see Wrappers#emptyWrapper()
 */
 default <E extends IPage<Map<String, Object>>> E pageMaps(E page) {
 return pageMaps(page, Wrappers.emptyWrapper());
 }
 
 /**
 * 获取对应 entity 的 BaseMapper
 *
 * @return BaseMapper
 */
 BaseMapper<T> getBaseMapper();
 
 /**
 * 以下的方法使用介绍:
 *
 * 一. 名称介绍
 * 1. 方法名带有 query 的为对数据的查询操作, 方法名带有 update 的为对数据的修改操作
 * 2. 方法名带有 lambda 的为内部方法入参 column 支持函数式的
 *
 * 二. 支持介绍
 * 1. 方法名带有 query 的支持以 {@link ChainQuery} 内部的方法名结尾进行数据查询操作
 * 2. 方法名带有 update 的支持以 {@link ChainUpdate} 内部的方法名为结尾进行数据修改操作
 *
 * 三. 使用示例,只用不带 lambda 的方法各展示一个例子,其他类推
 * 1. 根据条件获取一条数据: `query().eq("column", value).one()`
 * 2. 根据条件删除一条数据: `update().eq("column", value).remove()`
 *
 */
 
 /**
 * 链式查询 普通
 *
 * @return QueryWrapper 的包装类
 */
 default QueryChainWrapper<T> query() {
 return ChainWrappers.queryChain(getBaseMapper());
 }
 
 /**
 * 链式查询 lambda 式
 * 注意：不支持 Kotlin 
 *
 * @return LambdaQueryWrapper 的包装类
 */
 default LambdaQueryChainWrapper<T> lambdaQuery() {
 return ChainWrappers.lambdaQueryChain(getBaseMapper());
 }
 
 /**
 * 链式更改 普通
 *
 * @return UpdateWrapper 的包装类
 */
 default UpdateChainWrapper<T> update() {
 return ChainWrappers.updateChain(getBaseMapper());
 }
 
 /**
 * 链式更改 lambda 式
 * 注意：不支持 Kotlin 
 *
 * @return LambdaUpdateWrapper 的包装类
 */
 default LambdaUpdateChainWrapper<T> lambdaUpdate() {
 return ChainWrappers.lambdaUpdateChain(getBaseMapper());
 }
 
 /**
 * 
 * 根据updateWrapper尝试更新，否继续执行saveOrUpdate(T)方法
 * 此次修改主要是减少了此项业务代码的代码量（存在性验证之后的saveOrUpdate操作）
 * 
 *
 * @param entity 实体对象
 */
 default boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper) {
 return update(entity, updateWrapper) || saveOrUpdate(entity);
 }
 }

dao层实现的接口

public interface BaseMapper<T> extends Mapper<T> {
 int insert(T entity);
 
 int deleteById(Serializable id);
 
 int deleteByMap(@Param("cm") Map<String, Object> columnMap);
 
 int delete(@Param("ew") Wrapper<T> wrapper);
 
 int deleteBatchIds(@Param("coll") Collection<? extends Serializable> idList);
 
 int updateById(@Param("et") T entity);
 
 int update(@Param("et") T entity, @Param("ew") Wrapper<T> updateWrapper);
 
 T selectById(Serializable id);
 
 List<T> selectBatchIds(@Param("coll") Collection<? extends Serializable> idList);
 
 List<T> selectByMap(@Param("cm") Map<String, Object> columnMap);
 
 T selectOne(@Param("ew") Wrapper<T> queryWrapper);
 
 Integer selectCount(@Param("ew") Wrapper<T> queryWrapper);
 
 List<T> selectList(@Param("ew") Wrapper<T> queryWrapper);
 
 List<Map<String, Object>> selectMaps(@Param("ew") Wrapper<T> queryWrapper);
 
 List<Object> selectObjs(@Param("ew") Wrapper<T> queryWrapper);
 
 <E extends IPage<T>> E selectPage(E page, @Param("ew") Wrapper<T> queryWrapper);
 
 <E extends IPage<Map<String, Object>>> E selectMapsPage(E page, @Param("ew") Wrapper<T> queryWrapper);
 }

虽然service和dao提供的方法大致相同但是里面的执行者不太一样造成部分结果可能也不相同。各位使用的时候能稍加注意即可。

3.mybatis-plus的 or 语句写法

这里使用的是lambda写法 ，需要注意的是后面拼接的 and 方法把 or 包括在里面。

basicMapper.selectList(new QueryWrapper<BasicInfo>().lambda()
 .le(BasicInfo::getMonth, endTime)
 .ge(BasicInfo::getMonth, startTime)
 .and(v -> v.eq(BonusPlanInfo::getStatus, BonusPlanStatus.VALID.getCode())
 .or()
 .eq(BonusPlanInfo::getStatus, BonusPlanStatus.FINISH.getCode())));

**如有披露或问题欢迎留言或者入群探讨**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NDcwNzMz_size_16_color_FFFFFF_t_70][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NDcwNzMz_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200521160806979.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NDcwNzMz,size_16,color_FFFFFF,t_70