Springboot集成mybatis-plus扩展IService

程序猴老王

已于 2023-03-01 11:07:18 修改

阅读量2k

点赞数

于 2023-03-01 10:50:19 首次发布

本文链接：https://blog.youkuaiyun.com/qq_43040552/article/details/129276408

版权

SpringBoot 同时被 2 个专栏收录

12 篇文章

订阅专栏

mybatis

5 篇文章

订阅专栏

注意：文中涉及到的逻辑删除填充自动填充字段不在本文中详细描述，如有需要请到http://Mybatis-plus逻辑删除更新字段https://blog.youkuaiyun.com/qq_43040552/article/details/129276903

版本

  <!-- SpringBoot的依赖配置-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.5.14</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
 <!-- mybatis增强插件-->
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>${mybatis-plus.version}</version>
            </dependency>
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-extension</artifactId>
                <version>${mybatis-plus.version}</version>
            </dependency>

创建自定义MybaseMapper

public interface MyBaseMapper<T> extends BaseMapper<T> {
    /**
     * 根据id逻辑删除并填充字段
     * @param entity
     * @return
     */
    int deleteByIdWithFill(T entity );

    /**
     * 批量逻辑删除并填充字段
     * @param entity
     * @param wrapper
     * @return
     */
    int batchDeleteWithFill(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> wrapper);
}

创建BaseService

public interface BaseService<T> extends IService<T> {

    /**
     * 获取 QueryWrapper
     *
     * @return
     */
    QueryWrapper<T> getWarpper();

    /**
     * 获取 QueryWrapper
     *
     * @param condition 查询条件对象的JSON字符串
     * @return
     */
    QueryWrapper<T> getWarpper(String condition);

    /**
     * 获取 QueryWrapper
     *
     * @param condition   查询条件对象的JSON字符串
     * @param isCamelCase 是否进行驼峰命名转下划线
     * @return
     */
    QueryWrapper<T> getWarpper(String condition, boolean isCamelCase);

    /**
     * 获取 LambdaQueryWrapper
     *
     * @param condition 查询条件对象的JSON字符串
     * @return
     */
    LambdaQueryWrapper<T> getLambda(String condition);

    /**
     * 获取 LambdaQueryWrapper
     *
     * @param condition   查询条件对象的JSON字符串
     * @param isCamelCase 是否进行驼峰命名转下划线
     * @return
     */
    LambdaQueryWrapper<T> getLambda(String condition, boolean isCamelCase);

    /**
     * 获取 LambdaQueryWrapper
     *
     * @return
     */
    LambdaQueryWrapper<T> getLambda();

    /**
     * 获取排序字段
     * 获取请求参数 orderBy
     *
     * @return
     */
    List<OrderBy> getOrderBys();

    /**
     * 获取排序字段
     * 获取请求参数 orderBy
     *
     * @return
     */
    List<OrderItem> getOrderItems();


    /**
     * 获取排序字段
     * 获取请求参数 orderBy
     *
     * @return
     */
    List<OrderItem> getOrderItemsByJson(String orderJson);

    /**
     * 根据排序的json字符串获取排序
     *
     * @param orderStr json map类型 key 排序字段 value 排序类型
     * @return
     */
    List<OrderItem> getOrderItemsByMap(String orderStr);

    /**
     * 根据map生成排序
     *
     * @param map key 排序字段 value 排序类型
     * @return
     */
    List<OrderItem> getOrderItems(Map<String, String> map);

    /**
     * 排序
     * 如果column 为空 返回 null
     *
     * @param column 排序字段，默认进行驼峰转化
     * @param isAsc  是否ase 排序
     * @return
     */
    OrderItem getOrderItem(String column, boolean isAsc);

    /**
     * 获取 QueryWrapper
     *
     * @param condition 查询条件对象的JSON字符串
     * @return
     */
    QueryWrapper<T> getWarpper(String condition, String orderJson);

    /**
     * 根据 entity 条件，逻辑删除记录
     * 根据 {@link TableField} 中 fill 属性自动填充
     *
     * @param queryWrapper 实体包装类 {@link QueryWrapper}
     */
    boolean removeLogic(Wrapper<T> queryWrapper);

    /**
     * 删除（根据ID 逻辑删除）
     * 根据 {@link TableField} 中 fill 属性自动填充
     *
     * @param id 主键ID
     */
    boolean removeLogicById(Serializable id);

    /**
     * 删除（根据ID 批量逻辑删除）
     * 根据 {@link TableField} 中 fill 属性自动填充
     *
     * @param idList 主键ID列表
     */
    boolean removeLogicByIds(Collection<? extends Serializable> idList);
}

创建BaseServiceImpl

public abstract class BaseServiceImpl<M extends BaseMapper<T>, T>
        extends ServiceImpl<M, T>
        implements BaseService<T> {
    /**
     * 获取页数 默认1
     *
     * @return
     */
    public Integer getPageNum() {
        return ServletUtils.getParameterToInt(PageConstants.PAGE_NUM, PageConstants.PAGE_NUM_DEF);
    }

    /**
     * 获取每页条数 默认10
     *
     * @return
     */
    public Integer getPageSize() {
        return ServletUtils.getParameterToInt(PageConstants.PAGE_SIZE, PageConstants.PAGE_SIZE_DEF);
    }

    /**
     * 获取 page 对象
     *
     * @return
     */
    public Page<T> getPage() {
        Integer current = getPageNum();
        Integer size = getPageSize();
        return getPage(current, size);
    }

    /**
     * 获取 page 对象
     *
     * @param pageNum  页数 默认 1
     * @param pageSize 条目数 默认 10
     * @return
     */
    public Page<T> getPage(Integer pageNum, Integer pageSize) {
        Page<T> page = new Page<>();
        page.setCurrent(ObjectUtil.isEmpty(pageNum) ? PageConstants.PAGE_NUM_DEF : pageNum);
        page.setSize(ObjectUtil.isEmpty(pageSize) ? PageConstants.PAGE_SIZE_DEF : pageSize);
        return page;
    }

    /**
     * 根据页数和条目数翻页查询
     *
     * @see Wrappers#emptyWrapper()
     */
    public <E extends IPage<T>> E page() {
        return (E) super.page(getPage());
    }

    /**
     * 翻页查询
     *
     * @param queryWrapper 实体对象封装操作类 {@link QueryWrapper}
     */
    public <E extends IPage<T>> E page(Wrapper<T> queryWrapper) {
        return (E) super.page(getPage(), queryWrapper);
    }


    /**
     * 根据条件获取 QueryWrapper
     *
     * @param condition 查询条件对象的JSON字符串
     * @return
     * @see
     */
    @Override
    public QueryWrapper<T> getWarpper(String condition) {
        if (StringUtils.isNotBlank(condition)) {
            return SearchUtils.parseWhereSql(condition);
        } else {
            return Wrappers.query();
        }
    }

    /**
     * 根据条件获取 QueryWrapper
     *
     * @param condition   查询条件对象的JSON字符串 {@link Condition}
     * @param isCamelCase 是否进行驼峰命名转下划线
     * @return
     * @see
     */
    @Override
    public QueryWrapper<T> getWarpper(String condition, boolean isCamelCase) {
        if (StringUtils.isNotBlank(condition)) {
            return SearchUtils.parseWhereSql(condition, isCamelCase);
        } else {
            return Wrappers.query();
        }
    }

    /**
     * 获取 QueryWrapper
     *
     * @return
     */
    @Override
    public QueryWrapper<T> getWarpper() {
        return getWarpper(null);
    }


    /**
     * 获取 LambdaQueryWrapper
     *
     * @return
     */
    @Override
    public LambdaQueryWrapper<T> getLambda(String condition) {
        return getWarpper(condition).lambda();
    }

    /**
     * 获取 LambdaQueryWrapper
     *
     * @param condition   查询条件对象的JSON字符串
     * @param isCamelCase 是否进行驼峰命名转下划线
     * @return
     */
    @Override
    public LambdaQueryWrapper<T> getLambda(String condition, boolean isCamelCase) {
        return getWarpper(condition, isCamelCase).lambda();
    }

    /**
     * 获取 LambdaQueryWrapper
     *
     * @return
     */
    @Override
    public LambdaQueryWrapper<T> getLambda() {
        return Wrappers.lambdaQuery();
    }

    /**
     * 获取排序字段
     * 获取请求参数 orderBy
     *
     * @return
     */
    @Override
    public List<OrderBy> getOrderBys() {
        String order = ServletUtils.getParameter(PageConstants.ORDER);
        if (ObjectUtil.isEmpty(order)) {
            return null;
        }
        List<OrderBy> orderByList = new ArrayList<>();
        if (JsonUtil.isTypeJSONArray(order)) {
            orderByList.addAll(JsonUtil.toList(order, OrderBy.class));
        } else {
            orderByList.add(JsonUtil.parse(order, OrderBy.class));
        }
        return orderByList;
    }

    /**
     * 获取排序字段
     * 获取请求参数 orderBy
     * 数据类型{@link OrderBy}
     *
     * @return
     */
    @Override
    public List<OrderItem> getOrderItems() {
        String order = ServletUtils.getParameter(PageConstants.ORDER);
        return OrderItemUtils.getOrder(order);
    }

    /**
     * 获取排序字段
     * 获取请求参数 orderBy
     * 数据类型{@link OrderBy}
     *
     * @return
     */
    @Override
    public List<OrderItem> getOrderItemsByJson(String orderJson) {
        return OrderItemUtils.getOrder(orderJson);
    }

    /**
     * 根据排序的json字符串获取排序
     *
     * @param orderStr json map类型 key 排序字段 value 排序类型
     * @return
     */
    @Override
    public List<OrderItem> getOrderItemsByMap(String orderStr) {
        if (StrUtil.isNotBlank(orderStr)) {
            return OrderItemUtils.getOrder(orderStr);
        }
        return null;
    }

    /**
     * 根据map生成排序
     *
     * @param map key 排序字段 value 排序类型
     * @return
     */
    @Override
    public List<OrderItem> getOrderItems(Map<String, String> map) {
        return OrderItemUtils.getOrder(map);
    }

    /**
     * 排序
     * 如果column 为空 返回 null
     *
     * @param column 排序字段，默认进行驼峰转化
     * @param isAsc  是否ase 排序
     * @return
     */
    @Override
    public OrderItem getOrderItem(String column, boolean isAsc) {
        return OrderItemUtils.getOrder(column, isAsc);
    }

    /**
     * 获取 QueryWrapper
     *
     * @param condition 查询条件对象的JSON字符串
     * @param orderJson
     * @return
     */
    @Override
    public QueryWrapper<T> getWarpper(String condition, String orderJson) {
        QueryWrapper<T> warpper = getWarpper(condition);
        List<OrderItem> orderItems = getOrderItemsByJson(orderJson);
        if (orderItems != null) {
            for (OrderItem orderItem : orderItems) {
                if (orderItem.isAsc()) {
                    warpper.orderByAsc(orderItem.getColumn());
                } else {
                    warpper.orderByDesc(orderItem.getColumn());
                }
            }
        }
        return warpper;
    }

    /**
     * 根据 entity 条件，逻辑删除记录
     * 根据注解自动更新字段值
     * Mapper 必须继承 MyBaseMapper
     * 根据 {@link com.baomidou.mybatisplus.annotation.TableField} 中 fill 属性自动填充
     *
     * @param queryWrapper 实体包装类 {@link QueryWrapper}
     */
    @Override
    public boolean removeLogic(Wrapper<T> queryWrapper) {
        MyBaseMapper myBaseMapper = getMyBaseMapper();
        if (myBaseMapper == null) {
            return remove(queryWrapper);
        } else {
            T instance = ReflectUtil.newInstance(getEntityClass());
            return SqlHelper.retBool(myBaseMapper.batchDeleteWithFill(instance, queryWrapper));
        }

    }

    /**
     * 删除（根据ID 逻辑删除）
     * 根据注解自动更新字段值
     * Mapper 必须继承 MyBaseMapper
     * 根据 {@link com.baomidou.mybatisplus.annotation.TableField} 中 fill 属性自动填充
     *
     * @param id 主键ID
     */
    @Override
    public boolean removeLogicById(Serializable id) {
        if (ObjectUtil.isEmpty(id)) {
            return false;
        }
        MyBaseMapper myBaseMapper = getMyBaseMapper();
        if (myBaseMapper == null) {
            return removeById(id);
        } else {
            T instance = ReflectUtil.newInstance(getEntityClass());
            ReflectUtil.setFieldValue(instance, "id", id);
            return SqlHelper.retBool(myBaseMapper.deleteByIdWithFill(instance));
        }
    }

    /**
     * 删除（根据ID 批量逻辑删除）
     * 根据注解自动更新字段值
     * Mapper 必须继承 MyBaseMapper
     * 根据 {@link com.baomidou.mybatisplus.annotation.TableField} 中 fill 属性自动填充
     *
     * @param idList 主键ID列表
     */
    @Override
    public boolean removeLogicByIds(Collection<? extends Serializable> idList) {
        if (ObjectUtil.isEmpty(idList)) {
            return false;
        }
        MyBaseMapper myBaseMapper = getMyBaseMapper();
        if (myBaseMapper == null) {
            return removeByIds(idList);
        } else {
            LambdaQueryWrapper<T> lambda = getLambda();
            String idsStr = idList.toString();
            lambda.apply("id in (" + idsStr.substring(1, idsStr.length() - 1) + ")");
            T instance = ReflectUtil.newInstance(getEntityClass());
            return SqlHelper.retBool(myBaseMapper.batchDeleteWithFill(instance, lambda));
        }
    }

    /**
     * 获取 MyBaseMapper
     *
     * @return
     */
    public MyBaseMapper getMyBaseMapper() {
        if (baseMapper instanceof MyBaseMapper) {
            return (MyBaseMapper) baseMapper;
        }
        return null;
    }
}

使用

1、mapper继承MyBaseMapper

public interface SysOperLogMapper extends BaseMapper<SysOperLog> {
}

2、service继承BaseService

public interface SysOperLogService extends BaseService<SysOperLog> {

}

3、serviceImpl继承BaseServiceImpl

@Service
public class SysOperLogServiceImpl extends BaseServiceImpl<SysOperLogMapper, SysOperLog> implements SysOperLogService {
    
}

至此扩展完成，在调用service中时，可以同时使用扩展方法及mybatis-plus自带的方法

注意：文中涉及到的逻辑删除填充自动填充字段不在本文中详细描述，如有需要请到

Mybatis-plus逻辑删除更新字段https://blog.youkuaiyun.com/qq_43040552/article/details/129276903