myBatis学习笔记（10）——使用拦截器实现分页查询

最新推荐文章于 2024-08-18 22:03:43 发布
最新推荐文章于 2024-08-18 22:03:43 发布
阅读量7k 收藏 9
点赞数 1
分类专栏： mybatis 文章标签： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010837612/article/details/47836729
版权

1. Page

package com.sm.model;

import java.util.List;

public class Page<T> {

    public static final int DEFAULT_PAGE_SIZE = 20;

    protected int pageNo = 1; // 当前页, 默认为第1页
    protected int pageSize = DEFAULT_PAGE_SIZE; // 每页记录数
    protected long totalRecord = -1; // 总记录数, 默认为-1, 表示需要查询
    protected int totalPage = -1; // 总页数, 默认为-1, 表示需要计算

    protected List<T> results; // 当前页记录List形式


    public int getPageNo() {
        return pageNo;
    }

    public void setPageNo(int pageNo) {
        this.pageNo = pageNo;
    }

    public int getPageSize() {
        return pageSize;
    }

    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
        computeTotalPage();
    }

    public long getTotalRecord() {
        return totalRecord;
    }

    public int getTotalPage() {
        return totalPage;
    }

    public void setTotalRecord(long totalRecord) {
        this.totalRecord = totalRecord;
        computeTotalPage();
    }

    protected void computeTotalPage() {
        if (getPageSize() > 0 && getTotalRecord() > -1) {
            this.totalPage = (int) (getTotalRecord() % getPageSize() == 0 ? getTotalRecord() / getPageSize() : getTotalRecord() / getPageSize() + 1);
        }
    }

    public List<T> getResults() {
        return results;
    }

    public void setResults(List<T> results) {
        this.results = results;
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder().append("Page [pageNo=").append(pageNo).append(", pageSize=").append(pageSize)
                .append(", totalRecord=").append(totalRecord < 0 ? "null" : totalRecord).append(", totalPage=")
                .append(totalPage < 0 ? "null" : totalPage).append(", results=").append(results == null ? "null" : results).append("]");
        return builder.toString();
    }

}

2. 实现拦截器

package com.sm.model;

import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.executor.parameter.DefaultParameterHandler;
import org.apache.ibatis.executor.parameter.ParameterHandler;
import org.apache.ibatis.executor.statement.RoutingStatementHandler;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ParameterMapping;
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.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Intercepts({ @Signature(method = "prepare", type = StatementHandler.class, args = { Connection.class }),
        @Signature(method = "query", type = Executor.class, args = { MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class }) })
public class PageInterceptor implements Interceptor {

    private static final Logger log = LoggerFactory.getLogger(PageInterceptor.class);

    public static final String MYSQL = "mysql";
    public static final String ORACLE = "oracle";

    protected String databaseType;// 数据库类型，不同的数据库有不同的分页方法

    protected ThreadLocal<Page> pageThreadLocal = new ThreadLocal<Page>();

    public String getDatabaseType() {
        return databaseType;
    }

    public void setDatabaseType(String databaseType) {
        if (!databaseType.equalsIgnoreCase(MYSQL) && !databaseType.equalsIgnoreCase(ORACLE)) {
            throw new PageNotSupportException("Page not support for the type of database, database type [" + databaseType + "]");
        }
        this.databaseType = databaseType;
    }

    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    @Override
    public void setProperties(Properties properties) {
        String databaseType = properties.getProperty("databaseType");
        if (databaseType != null) {
            setDatabaseType(databaseType);
        }
    }

    @Override
    @SuppressWarnings({ "unchecked", "rawtypes" })
    public Object intercept(Invocation invocation) throws Throwable {
        if (invocation.getTarget() instanceof StatementHandler) {// 控制SQL和查询总数的地方
            Page page = pageThreadLocal.get();
            if (page == null) { //不是分页查询
                return invocation.proceed();
            }

            RoutingStatementHandler handler = (RoutingStatementHandler) invocation.getTarget();
            StatementHandler delegate = (StatementHandler) ReflectUtil.getFieldValue(handler, "delegate");
            BoundSql boundSql = delegate.getBoundSql();
            Connection connection = (Connection) invocation.getArgs()[0];
            prepareAndCheckDatabaseType(connection); // 准备数据库类型

            if (page.getTotalPage() > -1) {
                if (log.isTraceEnabled()) {
                    log.trace("已经设置了总页数, 不需要再查询总数.");
                }
            } else {
                Object parameterObj = boundSql.getParameterObject();
                MappedStatement mappedStatement = (MappedStatement) ReflectUtil.getFieldValue(delegate, "mappedStatement");
                queryTotalRecord(page, parameterObj, mappedStatement, connection);
            }

            String sql = boundSql.getSql();
            String pageSql = buildPageSql(page, sql);
            if (log.isDebugEnabled()) {
                log.debug("分页时, 生成分页pageSql: " + pageSql);
            }
            ReflectUtil.setFieldValue(boundSql, "sql", pageSql);

            return invocation.proceed();
        } else { // 查询结果的地方
            // 获取是否有分页Page对象
            Page<?> page = findPageObject(invocation.getArgs()[1]);
            if (page == null) {
                if (log.isTraceEnabled()) {
                    log.trace("没有Page对象作为参数, 不是分页查询.");
                }
                return invocation.proceed();
            } else {
                if (log.isTraceEnabled()) {
                    log.trace("检测到分页Page对象, 使用分页查询.");
                }
            }
            //设置真正的parameterObj
            invocation.getArgs()[1] = extractRealParameterObject(invocation.getArgs()[1]);

            pageThreadLocal.set(page);
            try {
                Object resultObj = invocation.proceed(); // Executor.query(..)
                if (resultObj instanceof List) {
                    /* @SuppressWarnings({ "unchecked", "rawtypes" }) */
                    page.setResults((List) resultObj);
                }
                return resultObj;
            } finally {
                pageThreadLocal.remove();
            }
        }
    }

    protected Page<?> findPageObject(Object parameterObj) {
        if (parameterObj instanceof Page<?>) {
            return (Page<?>) parameterObj;
        } else if (parameterObj instanceof Map) {
            for (Object val : ((Map<?, ?>) parameterObj).values()) {
                if (val instanceof Page<?>) {
                    return (Page<?>) val;
                }
            }
        }
        return null;
    }

    /**
     * <pre>
     * 把真正的参数对象解析出来
     * Spring会自动封装对个参数对象为Map<String, Object>对象
     * 对于通过@Param指定key值参数我们不做处理，因为XML文件需要该KEY值
     * 而对于没有@Param指定时，Spring会使用0,1作为主键
     * 对于没有@Param指定名称的参数,一般XML文件会直接对真正的参数对象解析，
     * 此时解析出真正的参数作为根对象
     * </pre>
     * @author jundong.xu_C
     * @param parameterObj
     * @return
     */
    protected Object extractRealParameterObject(Object parameterObj) {
        if (parameterObj instanceof Map<?, ?>) {
            Map<?, ?> parameterMap = (Map<?, ?>) parameterObj;
            if (parameterMap.size() == 2) {
                boolean springMapWithNoParamName = true;
                for (Object key : parameterMap.keySet()) {
                    if (!(key instanceof String)) {
                        springMapWithNoParamName = false;
                        break;
                    }
                    String keyStr = (String) key;
                    if (!"0".equals(keyStr) && !"1".equals(keyStr)) {
                        springMapWithNoParamName = false;
                        break;
                    }
                }
                if (springMapWithNoParamName) {
                    for (Object value : parameterMap.values()) {
                        if (!(value instanceof Page<?>)) {
                            return value;
                        }
                    }
                }
            }
        }
        return parameterObj;
    }

    protected void prepareAndCheckDatabaseType(Connection connection) throws SQLException {
        if (databaseType == null) {
            String productName = connection.getMetaData().getDatabaseProductName();
            if (log.isTraceEnabled()) {
                log.trace("Database productName: " + productName);
            }
            productName = productName.toLowerCase();
            if (productName.indexOf(MYSQL) != -1) {
                databaseType = MYSQL;
            } else if (productName.indexOf(ORACLE) != -1) {
                databaseType = ORACLE;
            } else {
                throw new PageNotSupportException("Page not support for the type of database, database product name [" + productName + "]");
            }
            if (log.isInfoEnabled()) {
                log.info("自动检测到的数据库类型为: " + databaseType);
            }
        }
    }

    /**
     * <pre>
     * 生成分页SQL
     * </pre>
     * 
     * @author jundong.xu_C
     * @param page
     * @param sql
     * @return
     */
    protected String buildPageSql(Page<?> page, String sql) {
        if (MYSQL.equalsIgnoreCase(databaseType)) {
            return buildMysqlPageSql(page, sql);
        } else if (ORACLE.equalsIgnoreCase(databaseType)) {
            return buildOraclePageSql(page, sql);
        }
        return sql;
    }

    /**
     * <pre>
     * 生成Mysql分页查询SQL
     * </pre>
     * 
     * @author jundong.xu_C
     * @param page
     * @param sql
     * @return
     */
    protected String buildMysqlPageSql(Page<?> page, String sql) {
        // 计算第一条记录的位置，Mysql中记录的位置是从0开始的。
        int offset = (page.getPageNo() - 1) * page.getPageSize();
        return new StringBuilder(sql).append(" limit ").append(offset).append(",").append(page.getPageSize()).toString();
    }

    /**
     * <pre>
     * 生成Oracle分页查询SQL
     * </pre>
     * 
     * @author jundong.xu_C
     * @param page
     * @param sql
     * @return
     */
    protected String buildOraclePageSql(Page<?> page, String sql) {
        // 计算第一条记录的位置，Oracle分页是通过rownum进行的，而rownum是从1开始的
        int offset = (page.getPageNo() - 1) * page.getPageSize() + 1;
        StringBuilder sb = new StringBuilder(sql);
        sb.insert(0, "select u.*, rownum r from (").append(") u where rownum < ").append(offset + page.getPageSize());
        sb.insert(0, "select * from (").append(") where r >= ").append(offset);
        return sb.toString();
    }

    /**
     * <pre>
     * 查询总数
     * </pre>
     * 
     * @author jundong.xu_C
     * @param page
     * @param parameterObject
     * @param mappedStatement
     * @param connection
     * @throws SQLException
     */
    protected void queryTotalRecord(Page<?> page, Object parameterObject, MappedStatement mappedStatement, Connection connection) throws SQLException {
        BoundSql boundSql = mappedStatement.getBoundSql(page);
        String sql = boundSql.getSql();
        String countSql = this.buildCountSql(sql);
        if (log.isDebugEnabled()) {
            log.debug("分页时, 生成countSql: " + countSql);
        }

        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
        BoundSql countBoundSql = new BoundSql(mappedStatement.getConfiguration(), countSql, parameterMappings, parameterObject);
        ParameterHandler parameterHandler = new DefaultParameterHandler(mappedStatement, parameterObject, countBoundSql);
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        try {
            pstmt = connection.prepareStatement(countSql);
            parameterHandler.setParameters(pstmt);
            rs = pstmt.executeQuery();
            if (rs.next()) {
                long totalRecord = rs.getLong(1);
                page.setTotalRecord(totalRecord);
            }
        } finally {
            if (rs != null)
                try {
                    rs.close();
                } catch (Exception e) {
                    if (log.isWarnEnabled()) {
                        log.warn("关闭ResultSet时异常.", e);
                    }
                }
            if (pstmt != null)
                try {
                    pstmt.close();
                } catch (Exception e) {
                    if (log.isWarnEnabled()) {
                        log.warn("关闭PreparedStatement时异常.", e);
                    }
                }
        }
    }

    /**
     * 根据原Sql语句获取对应的查询总记录数的Sql语句
     * 
     * @param sql
     * @return
     */
    protected String buildCountSql(String sql) {
        int index = sql.indexOf("from");
        return "select count(*) " + sql.substring(index);
    }

    /**
     * 利用反射进行操作的一个工具类
     * 
     */
    private static class ReflectUtil {
        /**
         * 利用反射获取指定对象的指定属性
         * 
         * @param obj 目标对象
         * @param fieldName 目标属性
         * @return 目标属性的值
         */
        public static Object getFieldValue(Object obj, String fieldName) {
            Object result = null;
            Field field = ReflectUtil.getField(obj, fieldName);
            if (field != null) {
                field.setAccessible(true);
                try {
                    result = field.get(obj);
                } catch (IllegalArgumentException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            return result;
        }

        /**
         * 利用反射获取指定对象里面的指定属性
         * 
         * @param obj 目标对象
         * @param fieldName 目标属性
         * @return 目标字段
         */
        private static Field getField(Object obj, String fieldName) {
            Field field = null;
            for (Class<?> clazz = obj.getClass(); clazz != Object.class; clazz = clazz.getSuperclass()) {
                try {
                    field = clazz.getDeclaredField(fieldName);
                    break;
                } catch (NoSuchFieldException e) {
                    // 杩欓噷涓嶇敤鍋氬鐞嗭紝瀛愮被娌℃湁璇ュ瓧娈靛彲鑳藉搴旂殑鐖剁被鏈夛紝閮芥病鏈夊氨杩斿洖null銆�
                }
            }
            return field;
        }

        /**
         * 利用反射设置指定对象的指定属性为指定的值
         * 
         * @param obj 目标对象
         * @param fieldName 目标属性
         * @param fieldValue 目标值
         */
        public static void setFieldValue(Object obj, String fieldName, String fieldValue) {
            Field field = ReflectUtil.getField(obj, fieldName);
            if (field != null) {
                try {
                    field.setAccessible(true);
                    field.set(obj, fieldValue);
                } catch (IllegalArgumentException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }

    public static class PageNotSupportException extends RuntimeException {

        public PageNotSupportException() {
            super();
        }

        public PageNotSupportException(String message, Throwable cause) {
            super(message, cause);
        }

        public PageNotSupportException(String message) {
            super(message);
        }

        public PageNotSupportException(Throwable cause) {
            super(cause);
        }
    }

}

3. spring配置文件（mybatis已和spring整合）

    <!-- 配置mybatis的sqlSessionFactory -->
    <bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <!-- 配置了typeAliasesPackage之后，在映射文件中，这个包下的实体类可以不写全名 -->
        <property name="typeAliasesPackage" value="com.sm.model"></property>
        <!-- 配置映射映射文件的位置 -->
        <property name="mapperLocations" value="classpath:resources/mapper/*.xml"></property>
        <property name="plugins">
            <!-- 分页拦截器 -->
            <bean class="com.sm.model.PageInterceptor"></bean>
        </property>
    </bean>

4. mapper.xml

<select id="getUsers" resultType="User" parameterType="Map">
    select * from user where username=#{user.username}
</select>

6. DAO

List<User> getUsers(Map map);

7. 测试

Page page = new Page();
//配置分页参数
page.setPageNo(1);
page.setPageSize(3);
//条件查询，传参
User user = new User();
user.setUsername("2");

Map map = new HashMap<>();
map.put("user", user);
map.put("page", page);

List<User> list = userDAO.getUsers(map);
System.out.println(list);
System.out.println(page);

这里写图片描述

8. 总结

上面的分页拦截器，拷下来直接用就好了。如果想了解实现原理，可以看慕课网的视频通过自动回复机器人学Mybatis—加强版

君君要上天
关注
专栏目录
MyBatis--拦截器实现分页
Java小白的自学之路
05-08 725
主要内容： MyBatis四大对象及插件原理： MyBatis插件开发： 测试：定义一个插件类： MyFirstInterceptor ：一定继承自Interceptor类，重写里面的方法 package com.mooc.mybatis.interceptor; import org.apache.ibatis.executor.resultset....
MyBatis拦截器分页
talk is cheap
09-27 359
使用Mybatis拦截器实现分页,类似aop的效果.拦截sql语句,修改为分页查询语句. 1、引入pagination inteceptor拦截器和分页page 2、在sqlMapConfig.xml中配置拦截器插件<!-- 分页拦截器，拦截用户提交的查询，只查询当前页数据；提高响应速度。 --> <plugins> <plugin interceptor="cn.itcas
mybatis使用拦截器实现分页操作
08-12
使用mybatis的拦截器功能实现分页操作，使分页代码在整个项目中通用，减少代码冗余。
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类的属性参数实现对页数控
Mybatis的分页，延迟加载和缓存
最新发布
2301_78494721的博客
08-18 1381
不管信息用不用，只要调用，马上发起查询并进行加载比如：当我们查询学生信息时，就需要知道学生在哪个班级中，所以就需要立马去查询班级的信息通常：当 一对一或者 多对一的时候需要立即加载什么是延迟加载在真正使用数据时才发起查询，不用的时候不查询比如：在查询班级信息，每个班级都会有很多的学生（假如每个班有100个学生），如果我们只是查看班级信息，但是学生对象也会加载到内存中，会造成浪费。所以我门需要进行懒加载，当确实需要查看班级中的学生信息，我门在进行加载班级中的学生信息。
Mybatis拦截器实现分页
weixin_30571465的博客
01-24 178
本文介绍使用Mybatis拦截器，实现分页；并且在dao层，直接返回自定义的分页对象。 2017-09-29修改：添加Mybatis拦截器分页对oracle、sqlServer的支持 最终dao层结果： public interface ModelMapper { Page<Model> pageByConditions(RowBounds rowBounds, Mode...
long mode 分页_Mybatis拦截器实现分页
weixin_39576066的博客
12-21 59
packagecn.com.common.page;importjava.sql.Connection;importjava.sql.PreparedStatement;importjava.sql.ResultSet;importjava.sql.SQLException;importjava.util.List;importjava.util.regex.Matcher;importjava....
【MyBatis学习笔记四】——MyBatis分页.zip
05-30
本篇笔记主要围绕MyBatis如何实现分页查询进行深入探讨。 在传统的SQL查询中，我们通常会使用LIMIT和OFFSET来实现分页，但在大数据量的场景下，这种方式效率较低，因为OFFSET会扫描大量无用的数据。MyBatis提供了更...
MyBatis-Plus 学习笔记.pdf
08-30
MyBatis-Plus 学习笔记 MyBatis-Plus 是一个基于 MyBatis 的增强工具，旨在简化开发、提高效率。它提供了许多实用的特性和功能，例如无侵入、损耗小、强大的 CRUD 操作、支持 Lambda 形式调用、支持多种数据库、...
MyBatis学习笔记.zip
06-09
9. **插件机制**：MyBatis允许开发者自定义插件，实现拦截器，如PageHelper分页插件，提高开发效率。 10. **最佳实践**：笔记可能会提供一些MyBatis的使用技巧，如如何优化SQL，如何避免内存溢出等问题。 每个HTML...
Mybatis分页拦截器
06-21
Mybatis分页拦截器,mybatis-3.1.1和mybatis-3.0.4版本下测试通过。
mybatis分页拦截器
04-29
给你源码(很详细的注释)，看不看无所谓(建议看【技多不压身不是】)，反正让你会用(了解原理更好)
Mybatis学习笔记+狂神说
01-17
Mybatis支持自定义插件，如PageHelper分页插件，通过拦截器机制，实现SQL的自动分页。 通过这份笔记，你可以深入理解Mybatis的基本概念和核心功能，掌握其配置、SQL执行、对象映射等关键点，为进一步深入学习和...
Mybatis 学习笔记
weixin_42274562的博客
11-21 645
。
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
MyBatis拦截器实现分页
wqh8522的博客
01-04 1897
原文地址：MyBatis拦截器实现分页 拦截器的作用就是拦截某些方法的调用，我们可以在方法执行前后为方法加上某些逻辑，也可以只执行拦截的逻辑代码而不执行被拦截的方法。Mybatis拦截器设计的一个初衷就是为了供用户在某些时候可以实现自己的逻辑而不必去动Mybatis固有的逻辑。 拦截器分页原理 Mybatis拦截器常常会被用来进行分页处理。我们知道要利用JDBC对数据库进行操作就必须要
SpringBoot: 自定义MyBatis拦截器来实现分页
amadeus_liu2的博客
06-07 1834
springboot mybatis
MyBatis拦截器实现分页功能详解
在MyBatis框架中，为了实现分页功能，我们可以利用拦截器机制来拦截原始的SQL查询，动态地添加分页相关的条件，然后生成带有分页信息的新SQL语句进行执行。这种方式避免了在每个查询方法中手动添加分页参数，提高了...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值