Springboot集成mybatis-plus扩展IService

已于 2023-03-01 11:07:18 修改
阅读量1.7k 收藏 7
点赞数
分类专栏： mybatis SpringBoot 文章标签： spring boot mybatis
于 2023-03-01 10:50:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43040552/article/details/129276408
版权

注意：文中涉及到的逻辑删除填充自动填充字段不在本文中详细描述，如有需要请到http://Mybatis-plus逻辑删除更新字段icon-default.png?t=N176https://blog.csdn.net/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逻辑删除更新字段icon-default.png?t=N176https://blog.csdn.net/qq_43040552/article/details/129276903

程序猴老王
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
SpringBoot集成mybatis plus
码出精彩
02-24 1319
SpringBoot集成mybatis plus1、mybatis plus简介2、Springboot集成mybatis-plus1. 导入依赖2. 编写数据库配置3. 编写数据库对应的实体类4. 编写Mapper接口5. 在入口类Mapper开启扫描6. 测试 1、mybatis plus简介 MyBatis-Plus (opens new window)（简称 MP）是一个 MyBatis (opens new window)的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效
springboot-mybatis-plus.zip
02-04
public class MybatisPlusConfig { } ``` 5. 编写Mapper接口 创建UserMapper接口，继承BaseMapper： ```java import com.baomidou.mybatisplus.core.mapper.BaseMapper; import org.springframework.stereotype....
详解SpringBoot 解决拦截器注入Service为空问题
08-27
主要介绍了详解SpringBoot 解决拦截器注入Service为空问题的解决，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring系列之代理详解（Java动态代理&cglib代理）
azhou的代码园
04-30 2535
本文内容 为什么需要用代理 jdk动态代理玩法详解 cglib代理常见的各种玩法详解 代理spring中用到的挺多的，比如上篇文章中的lookup-method和replaced-method，以及后面我们要学的aop、spring中的事务、spring中解析@configuration注解等等，这些都是依靠代理来实现的，所以我们先把代理拿出来讲讲，有利于我们理解其他内容。 为什么要用代理 我们先来看一个案例。 有一个接口IService，如下： package.
Mybati plus 整合
最新发布
weixin_67573348的博客
06-18 207
【代码】Mybati plus 整合。
SpringBoot学习笔记 - 使用Mybatis-Plus的IService及ServiceImp使用LambdaWrapper链式操作
Marinda_Speed的博客
12-22 6655
SpringBoot学习笔记 - 使用Mybatis-Plus的IService及ServiceImp使用LambdaWrapper链式操作
【Spring项目中的Service理解】
居然天上楼的博客
11-29 1676
在项目中，关于Service的开发，通常是先定义接口，再定义类实现此接口，接口名通常使用“数据类型Service”这样格式的名称，而实现类通常是在接口名的基础上再添加。，本次的参数应该包含：相册名称、相册简介、相册的排序序号，可以将这3个数据封装到自定义的DTO类中，并使用DTO类型作为参数。，并且，在后续的编程中，当需要执行某些判断时，应该优先根据“抛出异常”或“终止当前方法的执行”来设计。通常，建议自定义异常，并且，当视为失败时，抛出此自定义异常的对象！中添加相册时，如果相册名称被使用，则抛出。
springboot整合mybatisplus实现增删改查(二)---通用 service crud 封装iservice 接口
FAIRYTAIL的博客
09-19 2752
写在前面：各位看到此博客的小伙伴，如有不对的地方请及时通过私信我或者评论此博客的方式指出，以免误人子弟。多谢！ 通过上一篇我们通过继承BaseMapper接口的形式，获得了通用的CURD能力，在没有写任何sql的情况下完成了增删改查的基本操作，但是在保存的时候我们只能单个保存，没有批量保存的方法，MyBatis-Plus还提供了IService接口，它是对CURD的进一步封装，里面提供了我们需要的一些批量操作的方法，并且MyBatis-Plus也提供了IService接口的默认实现ServiceImpl，
基于spring boot 2集成mybatis-plus的简单实例
12-18
在本文中，我们将深入探讨如何在Spring Boot 2框架中集成MyBatis-Plus，并通过一个简单的实例来演示这一过程。MyBatis-Plus是一个强大的MyBatis扩展，它简化了数据库操作，提供了诸如CRUD操作、条件查询、分页等功能...
springboot专栏 004 springboot整合mybatis-plus 增删改查 用postman测试
04-11
通过这种方式，我们可以快速地测试Spring Boot集成Mybatis-Plus后的API接口功能，确保其正确性和稳定性。在整个过程中，Spring Boot简化了项目的搭建，而Mybatis-Plus则降低了与数据库交互的复杂度，Postman则作为一...
mybatis-plus-demo.zip
07-22
MyBatis-Plus 是 MyBatis 的一个扩展，它简化了 CRUD 操作，提供了丰富的查询API，使得在基于 SpringBoot 的应用中实现数据操作变得更加便捷。在这个名为 "mybatis-plus-demo.zip" 的压缩包文件中，我们可以看到一个...
mybatis plus+springboot反向生成代码
09-05
在SpringBoot项目中集成Mybatis Plus，可以方便地进行数据库操作，同时利用其反向生成代码的能力，避免手动编写重复的代码。 反向生成代码的过程大致分为以下几个步骤： 1. **配置Mybatis Plus**：在SpringBoot的...
mybatisplus 顶级 Service扩展
qq_15596257的博客
07-18 711
mybatisplus 顶级 Service扩展，减少代码编写和入参判断
Mybatis plus 实现IService方式，使用SpringbootTest引入service 测试
yangchuang11的博客
04-02 568
说明：需要引用@SpringBootTest和RunWith,才可以在test 中引入service 使用，样例中主键id 由Mybatis plus 生成，不需要设值。说明：继承ServiceImpl、实现IService接口；继承ServiceImpl则不需要重写IService的方法。说明： 需继承BaseMapper，这里虽然引用了Mapper, 但是BaseMapper里面的方法并不能使用。说明：继承IService。
Springboot使用Mybatisplus：BaseMapper与IService
qq_42372372的博客
10-23 7933
（一）仅使用BaseMapper中提供方法 1.导入依赖：pom.xml <dependencies> <!-- springboot相关开始--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactI
Spring Boot中的service层
lgyt240054的博客
04-27 5306
【代码】Spring Boot中的service层。
Spring 中 IService 有多个实现类，它是如何知道该注入哪个 ServiceImpl 类？
Java精选
05-11 1448
>>号外：关注“Java精选”公众号，回复“2021面试题”关键词，领取全套500多份Java面试题文件。方法一：Controller中注入service的时候使用@Auto...
MyBatis-Plus中通用IService的基本使用
susu1083018911的博客
03-10 1911
项目中现在基本都是springboot+mybatis-plus的应用，一直没有注意到，基本的应用步骤是什么，我在这记录一下： 1.controller层就不多说了 2.service层的interface接口层需要继承IService public interface UserService extends IService<User> { } 3.service层的实现类需要继承ServiceImpl @Service public class UserServiceImpl
springboot集成mybatis-plus需要添加哪些依赖
05-24
在SpringBoot项目中集成MyBatis-Plus需要添加以下依赖： ```xml <!--MyBatis-Plus依赖--> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter 最新版本 <!--MyBatis依赖--> <groupId>...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值