mybatis-plus 基于分页插件[PaginationInterceptor] 自定义[分页查询 总数查询]Sql位置

最新推荐文章于 2024-06-10 18:54:37 发布
最新推荐文章于 2024-06-10 18:54:37 发布
阅读量4.1k 收藏 2
点赞数 2
分类专栏： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zl20110000/article/details/108533672
版权

1. 场景

  1. 原有sql分页查询现在需要关联其他表格，数据结构为一对多。
    例如：一个老师有多个学生，老师列表已实现分页查询，需要关联查询一个老师下所有学生。
  2. 由于查询老师列表的sql里面有聚合函数，而且查询sql中字段还包含子查询。导致无法将关联的学生信息表做左连接查询。只能在查询出老师列表后，对结果做左连接查询
  3. 其次，对老师列表分页查询，如果关联了学生，就会导致老师列表分页不准确

2. 问题

  1. 由于mybatis plus目前实现的分页逻辑，都是在原有sql后面拼接分页逻辑。无法做到自定义分页查询逻辑拼接位置

3. 分析PaginationInterceptor源码

  1. 接口 ISqlParser 可实现自定义总数查询sql ，符合预期
  2. 数据库方言接口 IDialect 也能达到自定义分页查询sql,但是源码里面获取 IDialect实例的方法，无法利用装饰模式增强 IDialect实例的功能。
    总结：只能对整个拦截插件做修改，灵活度更高

4. 解决方案

  1. 插件源码

package xxx.xxx.xxx.xxx;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.parser.ISqlParser;
import com.baomidou.mybatisplus.core.parser.SqlInfo;
import com.baomidou.mybatisplus.core.toolkit.PluginUtils;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import com.baomidou.mybatisplus.extension.plugins.pagination.DialectFactory;
import com.baomidou.mybatisplus.extension.plugins.pagination.DialectModel;
import com.baomidou.mybatisplus.extension.toolkit.JdbcUtils;
import com.baomidou.mybatisplus.extension.toolkit.SqlParserUtils;
import lombok.Getter;
import lombok.Setter;
import lombok.experimental.Accessors;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.logging.Log;
import org.apache.ibatis.logging.LogFactory;
import org.apache.ibatis.mapping.*;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Signature;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.SystemMetaObject;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.RowBounds;
import org.springframework.util.Assert;

import java.sql.Connection;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * 分页拦截器
 *
 * @author hubin
 * @since 2016-01-23
 */
@Setter
@Accessors(chain = true)
@Intercepts({@Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class, Integer.class})})
public class CustomPaginationInterceptor extends PaginationInterceptor implements Interceptor {

    protected static final Log logger = LogFactory.getLog(CustomPaginationInterceptor.class);

    /**
     * COUNT SQL 解析
     */
    private ISqlParser countSqlParser;

    /**
     * 溢出总页数，设置第一页
     */
    private boolean overflow = false;
    /**
     * 单页限制 500 条，小于 0 如 -1 不受限制
     */
    private long limit = 500L;
    /**
     * 方言类型
     */
    private String dialectType;
    /**
     * 方言实现类<br>
     * 注意！实现 com.baomidou.mybatisplus.extension.plugins.pagination.dialects.IDialect 接口的子类
     */
    private String dialectClazz;


    /**
     * Physical Page Interceptor for all the queries with parameter {@link RowBounds}
     */
    @SuppressWarnings("unchecked")
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        StatementHandler statementHandler = PluginUtils.realTarget(invocation.getTarget());
        MetaObject metaObject = SystemMetaObject.forObject(statementHandler);


        // SQL 解析
        this.sqlParser(metaObject);

        // 先判断是不是SELECT操作  (2019-04-10 00:37:31 跳过存储过程)
        MappedStatement mappedStatement = (MappedStatement) metaObject.getValue("delegate.mappedStatement");
        if (SqlCommandType.SELECT != mappedStatement.getSqlCommandType()
                || StatementType.CALLABLE == mappedStatement.getStatementType()) {
            return invocation.proceed();
        }

        // 针对定义了rowBounds，做为mapper接口方法的参数
        BoundSql boundSql = (BoundSql) metaObject.getValue("delegate.boundSql");
        Object paramObj = boundSql.getParameterObject();

        // 判断参数里是否有page对象
        IPage<?> page = null;
        if (paramObj instanceof IPage) {
            page = (IPage<?>) paramObj;
        } else if (paramObj instanceof Map) {
            for (Object arg : ((Map<?, ?>) paramObj).values()) {
                if (arg instanceof IPage) {
                    page = (IPage<?>) arg;
                    break;
                }
            }
        }

        /*
         * 不需要分页的场合，如果 size 小于 0 返回结果集
         */
        if (null == page || page.getSize() < 0) {
            String sql = boundSql.getSql();
            boolean isReplaceSql=false;
            if(sql.contains(CustomPaginationPosition.startIdentify)){
                sql=sql.replaceAll(CustomPaginationPosition.startIdentifyPattern, "");
                isReplaceSql=true;
            }
            if(sql.contains(CustomPaginationPosition.endIdentify)){
                sql=sql.replaceAll(CustomPaginationPosition.endIdentifyPattern, "");
                isReplaceSql=true;
            }
            if (isReplaceSql) {
                metaObject.setValue("delegate.boundSql.sql", sql);
            }
            return invocation.proceed();
        }

        /*
         * 处理单页条数限制
         */
        if (limit > 0 && limit <= page.getSize()) {
            page.setSize(limit);
        }


        Connection connection = (Connection) invocation.getArgs()[0];
        DbType dbType = StringUtils.isNotEmpty(dialectType) ? DbType.getDbType(dialectType)
                : JdbcUtils.getDbType(connection.getMetaData().getURL());
        Configuration configuration = mappedStatement.getConfiguration();
        CustomPaginationPosition customPaginationPosition = new CustomPaginationPosition(configuration,boundSql, page, dbType);


        String pageSql = customPaginationPosition.getPageSql();
        if (page.isSearchCount()) {
            SqlInfo sqlInfo = SqlParserUtils.getOptimizeCountSql(page.optimizeCountSql(), countSqlParser, pageSql);
            this.queryTotal(overflow, sqlInfo.getSql(), mappedStatement, customPaginationPosition.getPageBoundSql(), page, connection);
            if (page.getTotal() <= 0) {
                return null;
            }
        }

        DialectModel model = customPaginationPosition.parseDialectModel();

        List<ParameterMapping> mappings = new ArrayList<>(boundSql.getParameterMappings());
        Map<String, Object> additionalParameters = (Map<String, Object>) metaObject.getValue("delegate.boundSql.additionalParameters");
        model.consumers(mappings, configuration, additionalParameters);
        metaObject.setValue("delegate.boundSql.sql", customPaginationPosition.getPaginationSql());
        metaObject.setValue("delegate.boundSql.parameterMappings", mappings);
        return invocation.proceed();
    }

    private class CustomPaginationPosition {
        private static final String startIdentifyPattern = "\\^\\^\\{CustomPaginationPositionStartIdentify\\}\\^\\^";
        private static final String startIdentify = "^^{CustomPaginationPositionStartIdentify}^^";
        private static final String endIdentifyPattern = "\\^\\^\\{CustomPaginationPositionEndIdentify\\}\\^\\^";
        private static final String endIdentify = "^^{CustomPaginationPositionEndIdentify}^^";
        /**
         * 原始boundSql
         */
        private BoundSql boundSql;
        /**
         * 构造PageBoundSql 需要
         */
        private Configuration configuration;
        /**
         * 截取自定义分页开始位置 之前的sql
         */
        private String startSql;
        /**
         * 之前sql中有多少个 '?' 参数
         */
        private int startSqlParameterNum;
        /**
         * 自定义的 分页sql
         */
        @Getter
        private String pageSql;
        /**
         * 分页sql中参数个数
         */
        private int pageSqlParameterNum;
        /**
         * 同理 同上
         */
        private String endSql;
        /**
         * 同理 同上
         */
        private int endSqlParameterNum;

        /**
         * 构造分页sql对象 借助原始boundSql
         * 1.分页时
         * 2.不分页时
         */
        @Getter
        private BoundSql pageBoundSql;

        /**
         * 分页参数
         */
        private IPage<?> page;
        /**
         * sql方言类型
         */
        private DbType dbType;

        @Getter
        private DialectModel model;

        /**
         * 是否为分页sql  true 分页 false 不分页
         */
        @Getter
        private boolean isPaging;

        public CustomPaginationPosition(Configuration configuration,BoundSql boundSql, IPage<?> page, DbType dbType) {
            Assert.notNull(boundSql, "boundSql not null");
            Assert.notNull(boundSql, "configuration not null");
            this.boundSql = boundSql;
            this.configuration = configuration;
            String originalSql = boundSql.getSql();
            Assert.isTrue(org.apache.commons.lang3.StringUtils.isNotBlank(originalSql), "sql not null");
            int startIdentifyIndex = originalSql.indexOf(startIdentify);
            int endIdentifyIndex = originalSql.indexOf(endIdentify);

            Assert.isTrue((startIdentifyIndex == -1 && endIdentifyIndex == -1)
                    || (startIdentifyIndex != -1 && endIdentifyIndex != -1), String.format("自定义分页标识必须成对出现[(%s) - (%s)]", startIdentify, endIdentify));

            if (startIdentifyIndex != -1 && endIdentifyIndex != -1) {
                Assert.isTrue(startIdentifyIndex < endIdentifyIndex, String.format("[%s]标签必须在[%s]标签前面", startIdentify, endIdentify));
                this.startSql = originalSql.substring(0, startIdentifyIndex);
                this.pageSql = originalSql.substring(startIdentifyIndex + startIdentify.length(), endIdentifyIndex);
                this.endSql = originalSql.substring(endIdentifyIndex + endIdentify.length());
            } else {
                this.pageSql = originalSql;
            }
            if (org.apache.commons.lang3.StringUtils.isBlank(this.startSql)) {
                this.startSql = "";
            }
            if (org.apache.commons.lang3.StringUtils.isBlank(this.endSql)) {
                this.endSql = "";
            }
            //是否分页
            this.isPaging=!(null == page || page.getSize() < 0);

            if (this.isPaging) {
                this.startSqlParameterNum = org.apache.commons.lang3.StringUtils.countMatches(this.startSql, "?");
                this.pageSqlParameterNum = org.apache.commons.lang3.StringUtils.countMatches(this.pageSql, "?");
                this.endSqlParameterNum = org.apache.commons.lang3.StringUtils.countMatches(this.endSql, "?");

                this.pageBoundSql=new BoundSql(this.configuration,this.pageSql,this.boundSql.getParameterMappings(),this.boundSql.getParameterObject()){
                    BoundSql boundSql=CustomPaginationPosition.this.boundSql;
                    @Override
                    public String getSql() {
                        return boundSql.getSql();
                    }

                    @Override
                    public List<ParameterMapping> getParameterMappings() {
                        return boundSql.getParameterMappings().subList(CustomPaginationPosition.this.startSqlParameterNum
                                ,CustomPaginationPosition.this.startSqlParameterNum+CustomPaginationPosition.this.pageSqlParameterNum);
                    }

                    @Override
                    public Object getParameterObject() {
                        return boundSql.getParameterObject();
                    }

                    @Override
                    public boolean hasAdditionalParameter(String name) {
                        return boundSql.hasAdditionalParameter(name);
                    }

                    @Override
                    public void setAdditionalParameter(String name, Object value) {
                        boundSql.setAdditionalParameter(name, value);
                    }

                    @Override
                    public Object getAdditionalParameter(String name) {
                        return boundSql.getAdditionalParameter(name);
                    }
                };

            }else{
                this.pageBoundSql=new BoundSql(this.configuration,this.startSql+this.pageSql+this.endSql,this.boundSql.getParameterMappings(),this.boundSql.getParameterObject()){
                    BoundSql boundSql=CustomPaginationPosition.this.boundSql;

                    @Override
                    public List<ParameterMapping> getParameterMappings() {
                        return boundSql.getParameterMappings();
                    }

                    @Override
                    public Object getParameterObject() {
                        return boundSql.getParameterObject();
                    }

                    @Override
                    public boolean hasAdditionalParameter(String name) {
                        return boundSql.hasAdditionalParameter(name);
                    }

                    @Override
                    public void setAdditionalParameter(String name, Object value) {
                        boundSql.setAdditionalParameter(name, value);
                    }

                    @Override
                    public Object getAdditionalParameter(String name) {
                        return boundSql.getAdditionalParameter(name);
                    }
                };
            }

            this.page = page;
            this.dbType = dbType;


        }


        public String getPaginationSql() {
            return this.startSql + model.getDialectSql() + this.endSql;
        }

        public DialectModel parseDialectModel(){
            this.pageSql=concatOrderBy(this.pageSql, page);
            this.model = DialectFactory.buildPaginationSql(page, this.pageSql, dbType, dialectClazz);
            return this.model;
        }


    }



}

  1. 使用示例
    2.1 通过如下方式，即可在查询老师的列表信息中实现分页 总数 查询，并获取每个老师下所有学生

    <select id="xxx" resultMap="xxx">
    select
    *
    from 
    (
	    ^^{CustomPaginationPositionStartIdentify}^^
	    SELECT
		*
	    FROM teacher
	    ${ew.customSqlSegment}
	    ^^{CustomPaginationPositionEndIdentify}^^
    ) t

    LEFT JOIN student on s.tid= t.id
</select>

5. 总结

  1. 当前插件的实现方式可能存在BUG，留待以后解决。欢迎各位探讨
    1.1 2020年9月23日17:43:38 更新自定义总数sql中存在参数时，参数位置不一致
    1.2 2020年10月23日09:22:35 更新分页sql在不执行分页查询时【例如：Page.size<0】，由于定义了标识符导致sql执行失败
  2. 官方能实现分页逻辑位置可自定义
zl20110000
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
自定义Mybatis分页插件
珍惜
04-18 1万+
自定义Mybatis分页插件目标：实现：一、前期准备1、加入依赖2、定义Country 类3、定义CountryMapper类4、定义CountryMapper.xml配置文件5、定义log4j配置文件6、定义mybatis-config配置文件7、定义PageUtil8、定义MyPageHelper9、定义测试类总结重点及易错点1、一定要放行 目标：   使用自定义插件完成分页功能。 实现： 一...
MyBatisPlus插件扩展_PaginationInterceptor分页插件的使用示例代码
04-27
MyBatis插件扩展_PaginationInterceptor分页插件的使用示例代码
【微服务】第4节：MybatisPlus的分页插件
最新发布
m0_46013789的博客
06-10 1591
大家在日常开发中应该能发现，单表的CRUD功能代码重复度很高，也没有什么难度。而这部分代码量往往比较大，开发起来比较费时。因此，目前企业中都会使用一些组件来简化或省略单表的CRUD开发工作。目前在国内使用较多的一个组件就是MybatisPlus。
MyBatisPlus插件扩展_PaginationInterceptor分页插件的使用
JavaAlliance
09-30 2万+
实现 配置插件 来到项目下的applicationContext.xml中配置sqlSessionFactoryBean的地方。 <!-- 配置SqlSessionFactoryBean Mybatis提供的: org.mybatis.spring.SqlSessionFactoryBean MP提供的:com.baomidou.mybatisplus.spring.Mybatis...
mybatis IDEA——自定义分页和分页插件的使用
Bruce_Json的博客
09-07 3067
PageHelper实现了通用的分页查询，其支持的数据有，mysql、Oracle、DB2、PostgreSQL等主流的数据库。 使用说明：https://github.com/pagehelper/Mybatis-PageHelper/blob/master/wikis/en/HowToUse.md 导入依赖 &lt;dependency&gt; &lt;...
MybatisPlus实现分页功能
m0_50217592的博客
07-29 760
MybatisPlus实现分页功能
mybatis分页插件PaginationInterceptor示例代码下载
06-12
mybatis分页插件PaginationInterceptor代码示例 dialect目录下是各种数据方言的实现类 interceptor目录下是拦截StatementHandler的prepare方法的拦截器类及父类 mybatis的配置文件中需要加入以下代码，路劲换成自己的 <!-- 插件配置 -->
MyBatis-Plus 分页查询以及自定义sql分页的实现
09-07
在 MyBatis-Plus 中，实现分页查询需要配置分页插件 `PaginationInterceptor`。以下是一个 Spring Boot 配置示例： ```java @Configuration public class MyBatisPlusConfig { @Bean public ...
mybatis-plus分页查询的实现示例.docx
04-19
MyBatis-Plus 是一个基于 ...当执行分页查询的方法时，`PaginationInterceptor` 插件会自动处理 SQL，计算总数并分页，最后将分页后的结果返回给业务代码。这种方式极大地简化了开发过程，提高了代码的可读性和维护性。
MyBatis-Plus多表联合查询并且分页(3表联合)
08-24
MyBatis-Plus 是一个基于 MyBatis 的增强型 ORM 框架，提供了很多实用的功能，例如多表联合查询和分页等。下面我们将详细介绍如何使用 MyBatis-Plus 实现多表联合查询并且分页（3 表联合）。 首先，让我们看一下...
mybatis-plus分页查询的实现示例
09-07
MyBatis-Plus 是 MyBatis 的一个扩展，它提供了许多增强功能，包括简化 CRUD 操作、支持 Lambda 形式编写 SQL 查询以及便捷的分页功能。本示例将详细介绍如何在实际项目中使用 MyBatis-Plus 实现分页查询。 首先，...
SpringBoot整合mybatis-plus实现多数据源的动态切换且支持分页查询.pdf
10-07
public class MybatisPlusConfig { @Bean public PaginationInterceptor paginationInterceptor() { return new PaginationInterceptor(); } @Bean public PageInterceptor pageInterceptor() { ...
mybatis 自定义插件实现Interceptor
sinat_34338162的博客
03-30 1039
github：https://github.com/nlxs0511/springmybatisplus.git 1.新建MybatisInterceptor package com.test.mybatisplus.Interceptor; import com.baomidou.mybatisplus.core.toolkit.PluginUtils; import org.apache.ibatis.executor.statement.StatementHandler; import or.
Mybatis 分页插件 PageHelper 的使用
程序员学习圈
09-18 815
在MySQL中，分页的sql是使用limit来做，如果我们自己写sql，那分页肯定是没有任何问题的。但是一旦model多了起来，复杂了起来，我们很自然的想到使用mybatis的逆向工程来生成相应的po和mapper，但是同时也会带来弊端，比如这里的分页问题就不好解决了。 可能有人会说，我可以修改生成的文件，没错，这是可行的，但是一般我们通过逆向工程生成的文件，都不会去动它，所以这个时候，就需要使用分页插件来解决了。PageHelper 插件目前支持Oracle,Mysql,MariaDB,SQLit
MyBatis-Plus 分页查询以及自定义sql分页
weixin_42030357的博客
02-22 1万+
文章目录一、引言二、配置三、具体分页实现四、自定义sql分页查询五、多表sql分页查询 原博文，点击这里进行实现 一、引言 分页查询每个人程序猿几乎都使用过，但是有部分同学不懂什么是物理分页和逻辑分页。 物理分页：相当于执行了limit分页语句，返回部分数据。物理分页只返回部分数据占用内存小，能够获取数据库最新的状态，实施性比较强，一般适用于数据量比较大，数据更新比较频繁的场景。 逻辑分页：一次性把全部的数据取出来，通过程序进行筛选数据。如果数据量大的情况下会消耗大量的内存，由于逻辑分页只需要读取数据库一次
Mybatis-plus学习（三）——MybatiPlus的分页插件PaginationInnerInterceptor详解以及测试
热门推荐
陌意随影的博客
12-06 2万+
3.分页插件(PaginationInnerInterceptor) 3.1属性介绍 属性名 类型 默认值 描述 overflow boolean false 溢出总页数后是否进行处理(默认不处理,参见 插件#continuePage 方法) maxLimit Long 单页分页条数限制(默认无限制,参见 插件#handlerLimit 方法) dbType DbType 数据库类型(根据类型获取应使用的分页方言,参见 插件#findIDialect 方法) dialect
Spring Boot学习随笔- 集成MyBatis-Plus（三）自定义SQL、分页实现（PaginationInterceptor ）、更新和删除详细方法
rookies99的博客
01-03 1432
这篇文章涵盖了自定义SQL、分页、更新和删除等操作。在自定义SQL部分，提及了配置mapper文件的路径以及对应的XML配置文件示例，以及如何在测试中调用自定义的方法。分页部分介绍了MyBatis-Plus中的物理分页和内存分页的区别，以及如何配置分页插件和进行分页查询。更新方法详解部分演示了不同方式的更新操作，包括根据ID更新、条件构造器更新、快速更新少量字段以及使用Lambda表达式进行更新等。最后，删除操作展示了根据ID删除、根据Map条件删除、批量删除以及根据条件构造器删除等操作方法。
java中分页计数_详解分页组件中查count总记录优化
weixin_28904055的博客
02-24 1185
1 背景研究mybatis-plus(以下简称mbp)，使用其分页功能时。发现了一个jsqlparsercountoptimize的分页优化处理类，官方对其未做详细介绍，网上也未找到分析该类逻辑的只言片语，这情况咱也不敢用呀，索性深度剖析一下，也方便他人。2 原理首先paginationinterceptor分页拦截器的原理这里不累述(mybatis通用分页封装的实现原理挺简单的，也就那么回事)，...
mybatis（三）：mybatis自定义分页
xby7437的博客
07-05 778
由于之前mybatis的版本较低，以至于在自定义分页的时候，只能返回列表，总量还是得自己调用count方法，现在升级了mybatis版本之后，对自定义分页进行改造，让其能返回page，代码如下： pom依赖，mybatis版本在3.1.1 <dependencies> <dependency> <groupId>com.baomidou</groupId> <artif.
mybatis-plus的分页插件
10-15
mybatis-plus的分页插件是一个基于MyBatis的分页插件，可以方便地实现分页查询功能。它提供了两种分页方式：基于物理分页和基于逻辑分页。其中，基于物理分页是通过在SQL语句中添加LIMIT或者ROWNUM来实现的，而基于逻辑分页则是通过查询所有数据，然后在内存中进行分页处理。 使用mybatis-plus的分页插件，需要在配置文件中添加如下配置： ```xml <!-- 开启分页插件 --> <plugins> <plugin interceptor="com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor"/> </plugins> ``` 然后在Mapper接口中定义分页查询方法，例如： ```java @Select("select * from user") IPage<User> selectUserPage(Page<User> page); ``` 其中，Page是mybatis-plus提供的分页对象，IPage是mybatis-plus提供的分页结果对象。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值