Springboot集成mybatis-plus扩展IService

朴灿烈づ我的快乐病毒、 2024-03-26 15:58 69阅读 0赞

#### 注意：文中涉及到的逻辑删除填充自动填充字段不在本文中详细描述，如有需要请到[http://Mybatis-plus逻辑删除更新字段![icon-default.png?t=N176][icon-default.png_t_N176]https://blog.csdn.net/qq\_43040552/article/details/129276903][http_Mybatis-plus_icon-default.png_t_N176_icon-default.png_t_N176_https_blog.csdn.net_qq_43040552_article_details_129276903] ####

## 版本 ##

<dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-dependencies</artifactId>
                    <version>2.5.14</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
     
                <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逻辑删除更新字段![icon-default.png?t=N176][icon-default.png_t_N176]https://blog.csdn.net/qq\_43040552/article/details/129276903][http_Mybatis-plus_icon-default.png_t_N176_icon-default.png_t_N176_https_blog.csdn.net_qq_43040552_article_details_129276903]

[icon-default.png_t_N176]: https://csdnimg.cn/release/blog_editor_html/release2.2.3/ckeditor/plugins/CsdnLink/icons/icon-default.png?t=N176
[http_Mybatis-plus_icon-default.png_t_N176_icon-default.png_t_N176_https_blog.csdn.net_qq_43040552_article_details_129276903]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/1bb4a4f2cbe44694ada9fbcbcb5c3c6d.png