mybatis 分页实现方式之分页拦截器

最新推荐文章于 2024-08-16 01:10:16 发布
最新推荐文章于 2024-08-16 01:10:16 发布
阅读量1.1k 收藏 4
点赞数
分类专栏： mybatis 文章标签： mybatis java sql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43459611/article/details/105843842
版权

查看我的代码结构
**加粗样式
**

创建简单分页实体

import java.io.Serializable;
import java.util.List;

/**
 * Created by IntelliJ IDEA.
 * 简单分页对象
 * @Author : WangCong
 * @create 2020/4/21 13:09
 */
public class SimplePage implements Serializable {
    protected static final long serialVersionUID = 5136213157391895517L;
    protected int page = 1;// 页码，默认是第一页
    protected int rows = 10;// 每页显示的记录数，默认是10
    protected int totalRecord;// 总记录数
    protected List data;// 对应的当前页记录

    public int getPage() {
        return page;
    }
    public void setPage(int page) {
        this.page = page;
    }
    public int getRows() {
        return rows;
    }
    public void setRows(int rows) {
        this.rows = rows;
    }
    public int getTotalRecord() {
        return totalRecord;
    }
    public void setTotalRecord(int totalRecord) {
        this.totalRecord = totalRecord;
    }
    public List getData() {
        return data;
    }
    public SimplePage setData(List data) {
        this.data = data;
        return this;
    }

}

在创建分页实体

import java.util.List;
/**
 * Created by IntelliJ IDEA.
 *
 * @Author : WangCong
 * @create 2020/4/21 13:11
 */
public class Page extends SimplePage{
    private static final long serialVersionUID = -6190845403265328029L;

    private boolean isFirstPage = true;//是否是第一页
    private boolean isLastPage = false;//是否是最后一页
    private int pageCount = 0;//当前页总记录数
    private int totalPage = 0;//总页数
    private int prePage = 1;//上一页页码
    private int nextPage = 1;//下一页页码

    public Page() {
        super();
    }

    public Page(int page, int rows) {
        super();
        setPage(page);
        setRows(rows);
    }

    @Override
    public Page setData(List data){
        super.setData(data);
        if(data!=null && data.size()>0){
            pageCount = data.size();
            if(this.page==1){
                isFirstPage=true;
            }else{
                isFirstPage=false;
            }
            //***
            totalPage = (int)Math.ceil(totalRecord/(double)rows);
            //***
            if(page==totalPage){
                isLastPage = true;
            }else{
                isLastPage = false;
            }
            //***
            if(isFirstPage){
                prePage = 1;
            }else{
                prePage = page-1;
            }
            //***
            if(isLastPage){
                nextPage = 1;
            }else{
                nextPage = page+1;
            }
        }else{
            isLastPage = true;
        }
        return this;
    }


    /**只要get方法**/
    public boolean isFirstPage() {
        return isFirstPage;
    }

    public boolean isLastPage() {
        return isLastPage;
    }

    public int getPageCount() {
        return pageCount;
    }

    public int getTotalPage() {
        return totalPage;
    }

    public int getPrePage() {
        return prePage;
    }

    public int getNextPage() {
        return nextPage;
    }
}

创建拦截器

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import com.mk.mk.config.mybatis.domain.SimplePage;
import org.apache.ibatis.executor.parameter.ParameterHandler;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Plugin;
import org.apache.ibatis.plugin.Signature;
import org.apache.ibatis.reflection.DefaultReflectorFactory;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.ReflectorFactory;
import org.apache.ibatis.reflection.factory.DefaultObjectFactory;
import org.apache.ibatis.reflection.factory.ObjectFactory;
import org.apache.ibatis.reflection.wrapper.DefaultObjectWrapperFactory;
import org.apache.ibatis.reflection.wrapper.ObjectWrapperFactory;
import org.apache.ibatis.scripting.defaults.DefaultParameterHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.StringUtils;

//import com.lan.BootMybatis.base.model.SimplePage;

/**
 * 分页拦截器mybatis
 *
 * @author
 * @date
 */
@Intercepts({ @Signature(type = StatementHandler.class, method = "prepare", args = { Connection.class , Integer.class}) })
public class PaginationInterceptor implements Interceptor{

    private static final Logger logger = LoggerFactory.getLogger(PaginationInterceptor.class);

    private static final ObjectFactory DEFAULT_OBJECT_FACTORY = new DefaultObjectFactory();
    private static final ObjectWrapperFactory DEFAULT_OBJECT_WRAPPER_FACTORY = new DefaultObjectWrapperFactory();
    private static final ReflectorFactory DEFAULT_REFLECTOR_FACTORY = new DefaultReflectorFactory();
    private static String dialect = "mysql";

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        // 获得拦截的对象
        StatementHandler statementHandler = (StatementHandler) invocation.getTarget();
        // 待执行的sql的包装对象
        BoundSql boundSql = statementHandler.getBoundSql();
        // 判断是否是查询语句
        if (isSelect(boundSql.getSql())) {
            // 获得参数集合
            Object params = boundSql.getParameterObject();

            if (params instanceof Map) { // 请求为多个参数，参数采用Map封装
                return complexParamsHandler(invocation, boundSql, (Map<?, ?>) params);
            } else if (params instanceof SimplePage) { // 单个参数且为Page，则表示该操作需要进行分页处理
                return simpleParamHandler(invocation, boundSql, (SimplePage) params);
            }
        }
        return invocation.proceed();
    }

    private Object complexParamsHandler(Invocation invocation, BoundSql boundSql, Map<?, ?> params) throws Throwable {
        //判断参数中是否指定分页
        if (containsPage(params)) {
            return pageHandlerExecutor(invocation, boundSql, (SimplePage) params.get("page"));
        } else {
            return invocation.proceed();
        }
    }

    private boolean containsPage(Map<?, ?> params) {
        if(params==null){
            return false;
        }else if(!params.containsKey("page")){
            return false;
        }
        Object page = params.get("page");
        if(page==null){
            return false;
        }else if(page instanceof SimplePage){
            return true;
        }
        return false;
    }

    private boolean isSelect(String sql) {
        if (!StringUtils.isEmpty(sql) && sql.toUpperCase().trim().startsWith("SELECT")) {
            return true;
        }
        return false;
    }

    private Object simpleParamHandler(Invocation invocation, BoundSql boundSql, SimplePage page) throws Throwable {
        return pageHandlerExecutor(invocation, boundSql, page);
    }

    private Object pageHandlerExecutor(Invocation invocation, BoundSql boundSql, SimplePage page) throws Throwable {
        // 获得数据库连接
        Connection connection = (Connection) invocation.getArgs()[0];
        // 使用Mybatis提供的MetaObject，该对象主要用于获取包装对象的属性值
        MetaObject statementHandler = MetaObject.forObject(invocation.getTarget(), DEFAULT_OBJECT_FACTORY,
                DEFAULT_OBJECT_WRAPPER_FACTORY, DEFAULT_REFLECTOR_FACTORY);

        // 获取该sql执行的结果集总数
        int maxSize = getTotalSize(connection, (MappedStatement) statementHandler.getValue("delegate.mappedStatement"),
                boundSql);

        // 生成分页sql
        page.setTotalRecord(maxSize);
        String wrapperSql = getPageSql(boundSql.getSql(), page);

        MetaObject boundSqlMeta = MetaObject.forObject(boundSql, DEFAULT_OBJECT_FACTORY, DEFAULT_OBJECT_WRAPPER_FACTORY,
                DEFAULT_REFLECTOR_FACTORY);
        // 修改boundSql的sql
        boundSqlMeta.setValue("sql", wrapperSql);
        return invocation.proceed();
    }

    private int getTotalSize(Connection connection, MappedStatement mappedStatement, BoundSql boundSql) {
        String countSql = getCountSql(boundSql.getSql());
        PreparedStatement countStmt;
        ResultSet rs;
        List<AutoCloseable> closeableList = new ArrayList<AutoCloseable>();

        try {
            countStmt = connection.prepareStatement(countSql);
            BoundSql countBS = new BoundSql(mappedStatement.getConfiguration(), countSql,
                    boundSql.getParameterMappings(), boundSql.getParameterObject());
            setParameters(countStmt, mappedStatement, countBS, boundSql.getParameterObject());
            rs = countStmt.executeQuery();

            if (rs.next()) {
                return rs.getInt(1);
            }
            closeableList.add(countStmt);
            closeableList.add(rs);
        } catch (SQLException e) {
            logger.error("append an exception[{}] when execute sql[{}] with {}", e, countSql,
                    boundSql.getParameterObject());
        } finally {
            for (AutoCloseable closeable : closeableList) {
                try {
                    if (closeable != null)
                        closeable.close();
                } catch (Exception e) {
                    logger.error("append an exception[{}] when close resource[{}] ", e, closeable);
                }
            }
        }
        return 0;
    }

    private void setParameters(PreparedStatement ps, MappedStatement mappedStatement, BoundSql boundSql,
                               Object parameterObject) throws SQLException {
        ParameterHandler parameterHandler = new DefaultParameterHandler(mappedStatement, parameterObject, boundSql);
        parameterHandler.setParameters(ps);
    }

    @Override
    public Object plugin(Object target) {
        // 当目标类是StatementHandler类型时，才包装目标类，否者直接返回目标本身,减少目标被代理的次数
        if (target instanceof StatementHandler) {
            return Plugin.wrap(target, this);
        } else {
            return target;
        }
    }

    @Override
    public void setProperties(Properties properties) {

    }

    public String getCountSql(String sql) {
        if("mysql".equals(dialect)){
            return "select count(0) from (" + sql + ") as total";
        }
        return sql;
    }

    public String getPageSql(String sql, SimplePage page) {
        if(page.getPage()<=0){
            page.setPage(1);
        }
        if(page.getRows()<=0){
            page.setRows(20);
        }
        int startRow = (page.getPage()-1)*page.getRows();

        if(startRow>=page.getTotalRecord()){
            page.setPage(1);
            startRow=0;
        }
        if("mysql".equals(dialect)){
            return sql+" limit "+startRow+", "+page.getRows();
        }
        return sql;
    }
}

在把拦截器放到mybatis-config.xml中

在这里插入图片描述

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
        <setting name="cacheEnabled" value="false" /><!-- 暂时禁用缓存 -->
    </settings>
    <plugins>
        <plugin interceptor="com.mk.mk.config.mybatis.interceptor.PaginationInterceptor"></plugin>
    </plugins>
</configuration>

最后再把mybatis-config.xml 配置文件加载进去

在application.peoperties中
在这里插入图片描述

实验结果

在这里插入图片描述

在这里插入图片描述

在service 实现类中
在这里插入图片描述
在controller 中

在这里插入图片描述
在浏览器中执行
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
控制台显示的sql
在这里插入图片描述

大功告成！！！！！记得收藏点赞

从放弃到放弃
关注
专栏目录
mybatis分页拦截器（自动封装版）
04-14
近期由于工作需要，想要开发一版能够满足多数人员使用的mybatis分页拦截器，在网上查找了很多资料并结合自己的一些理解，开发出了以下一版简单的代码。 起初想要遵循江湖惯例，通过各个层级间传递分页参数来实现目标，但开发过程中发现这样针对已开发好的代码影响较大（需要修改前端到后端的所有代码），成本较高。然后在此基础上提升了目标 1、降低业务代码侵入性。 2、减少原有代码的修改。 3、减少调用人员开发量。 虽然最终版本在初次配置使用时会有一些繁琐，但后续扩展非常有优势。废话少说，上配置过程和代码。
MyBatis拦截器实现分页功能的实现方法
09-09
分页拦截器需要实现MyBatis提供的Interceptor接口，并重写intercept方法，以便在SQL执行前进行拦截。在intercept方法中，需要根据Page对象计算出的参数（dbIndex和dbNumber）来修改原始的SQL语句，添加分页逻辑。...
MyBatis实现拦截器分页功能
Yoroshiku IT
03-09 1774
1.原理 在mybatis使用拦截器（interceptor），截获所执行方法的sql语句与参数。 （1）修改sql的查询结果：将原sql改为查询count(*) 也就是条数 （2）将语句sql进行拼接 limit(MySql)或rownum(Oracle)语句达到分页效果 制作分页Page类，需要分页的bean继承分页Page类。 jsp界面通过Page类的属性参数实现对页数控
mybatisplus分页查询拦截器
最新发布
2301_79693537的博客
08-16 298
【代码】mybatisplus分页查询拦截器。
Mybatis - 分页拦截器
让人生充满永动的势能
08-17 776
package com.mgear.samering.util; import java.lang.reflect.Field; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.sq
mybatis分页拦截器
胡子哥
01-06 1182
利用拦截器实现Mybatis分页的原理：   要利用JDBC对数据库进行操作就必须要有一个对应的Statement对象 ,Mybatis在执行Sql语句前就会产生一个包含Sql语句的Statement对象，  而且对应的Sql语句  是在Statement之前产生的，所以我们就可以在它生成Statement之前对用来生成Statement的Sql语句下手 .  在Mybatis中Statem
Mybatis分页拦截器介绍
m0_66572126的博客
05-15 462
在进行数据查询时，经常需要使用分页功能，MyBatis 通过拦截器（Interceptor）提供了方便的分页功能。其原理是在查询数据之前，拦截 SQL，动态地修改 SQL 语句，加入分页的逻辑。2. 在 `intercept` 方法中，通过 `Invocation` 参数获取到 `MappedStatement` 对象，然后通过该对象获取到原始的 SQL 语句。1. 实现 `Interceptor` 接口，重写 `intercept` 方法，这是拦截器的核心方法。
mybatis分页拦截器(自动封装版)剖析.pdf
06-24
MyBatis 分页拦截器是一种优化数据库操作的技术，它的主要目的是在不修改大量现有业务代码的情况下，实现对数据库查询结果的自动分页。在自动封装版的MyBatis分页拦截器中，开发者通常会创建一个拦截器类，该类会...
Mybatis拦截器实现分页
08-31
通过这种方式，我们可以在不修改原有DAO层接口的情况下，利用Mybatis拦截器实现高效的分页功能。这种方法避免了对每个分页查询都编写相同的分页逻辑，降低了代码的复杂度，提高了开发效率。同时，由于分页逻辑集中...
mybatis使用拦截器实现分页操作
08-12
以下是实现分页拦截器的基本步骤： 1. **创建拦截器类**：首先，我们需要创建一个实现了`Interceptor`接口的类，例如`PageInterceptor`。在该类中，我们需要重写`intercept`方法，此方法会在每次执行SQL语句之前被...
MyBatis拦截器分页与动态修改SQL及其参数值
10-09
在某些场景下，我们可能需要对SQL进行动态修改或者实现分页功能，这时MyBatis的拦截器机制就显得尤为重要。拦截器允许我们在SQL执行前后插入自定义的行为，例如添加分页条件、修改SQL参数等。 在"MyBatis拦截器分页...
Mybatis分页拦截器
06-21
Mybatis分页拦截器,mybatis-3.1.1和mybatis-3.0.4版本下测试通过。
mybatis 分页 拦截器
@jrong
07-11 262
使用Interceptor来做分页1.
mybatis拦截器分页学习
qq_34590943的博客
07-05 696
1、引入pagination inteceptor拦截器和分页page package cn.itcast.jk.pagination; import java.util.HashMap; import java.util.List; import java.util.Map; /** * 对分页的基本数据进行一个简单的封装 */ public class Page { priv
mysql分页拦截器_Mybatis分页拦截器
weixin_33026067的博客
02-18 158
1 package ssm.utils;23 import java.lang.reflect.Field;4 import java.sql.Connection;5 import java.sql.PreparedStatement;6 import java.sql.ResultSet;7 import java.sql.SQLException;8 import java.util.Lis...
【Mybatis分页拦截器使用】
dangkei 的专栏
06-20 1480
使用mybatis后，很多增删改查，编写一些crud之类的mapper.xml mapperDao.java的代码基本都形成套路的模式。这时使用mybatis-plus就是简化这一工作量的好方法。
MyBatis拦截器实现分页
wqh8522的博客
01-04 1900
原文地址：MyBatis拦截器实现分页 拦截器的作用就是拦截某些方法的调用，我们可以在方法执行前后为方法加上某些逻辑，也可以只执行拦截的逻辑代码而不执行被拦截的方法。Mybatis拦截器设计的一个初衷就是为了供用户在某些时候可以实现自己的逻辑而不必去动Mybatis固有的逻辑。 拦截器分页原理 Mybatis拦截器常常会被用来进行分页处理。我们知道要利用JDBC对数据库进行操作就必须要
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值