Mybatis3.4.x技術內幕（二十）：PageHelper分頁插件源碼及原理剖析

時間  2019-11-06
標籤 mybatis3.4.x mybatis 技術 內幕 二十 pagehelper 分頁 插件 源碼 原理 剖析 欄目 MyBatis 简体版
原文   原文鏈接

PageHelper是一款好用的開源免費的Mybatis第三方物理分頁插件，其實我並不想加上好用兩個字，可是爲了表揚插件做者開源免費的崇高精神，我堅決果斷的加上了好用一詞做爲讚美。java

本來覺得分頁插件，應該是很簡單的，然而PageHelper比我想象的要複雜許多，它作的很強大，也很完全，強大到使用者可能並不須要這麼多功能，完全到一參能夠兩用。可是，我認爲，做爲分頁插件，完成物理分頁任務是根本，其它的不少智能並非必要的，保持它夠傻夠憨，專業術語叫stupid，簡單就是美。mysql

咱們將簡單介紹PageHelper的基本使用和配置參數的含義，重點分析PageHelper做爲Mybatis分頁插件的實現原理。git

1. PageHelper的maven依賴及插件配置

<dependency>
	<groupId>com.github.pagehelper</groupId>
	<artifactId>pagehelper</artifactId>
	<version>4.1.6</version>
</dependency>

PageHelper除了自己的jar包外，它還依賴了一個叫jsqlparser的jar包，使用時，咱們不須要單獨指定jsqlparser的maven依賴，maven的間接依賴會幫咱們引入。github

<!-- com.github.pagehelper爲PageHelper類所在包名 -->
<plugin interceptor="com.github.pagehelper.PageHelper">
	<property name="dialect" value="mysql" />
	<!-- 該參數默認爲false -->
	<!-- 設置爲true時，會將RowBounds第一個參數offset當成pageNum頁碼使用 -->
	<!-- 和startPage中的pageNum效果同樣 -->
	<property name="offsetAsPageNum" value="false" />
	<!-- 該參數默認爲false -->
	<!-- 設置爲true時，使用RowBounds分頁會進行count查詢 -->
	<property name="rowBoundsWithCount" value="true" />

	<!-- 設置爲true時，若是pageSize=0或者RowBounds.limit = 0就會查詢出所有的結果 -->
	<!-- （至關於沒有執行分頁查詢，可是返回結果仍然是Page類型） <property name="pageSizeZero" value="true"/> -->

	<!-- 3.3.0版本可用 - 分頁參數合理化，默認false禁用 -->
	<!-- 啓用合理化時，若是pageNum<1會查詢第一頁，若是pageNum>pages會查詢最後一頁 -->
	<!-- 禁用合理化時，若是pageNum<1或pageNum>pages會返回空數據 -->
	<property name="reasonable" value="true" />
	<!-- 3.5.0版本可用 - 爲了支持startPage(Object params)方法 -->
	<!-- 增長了一個`params`參數來配置參數映射，用於從Map或ServletRequest中取值 -->
	<!-- 能夠配置pageNum,pageSize,count,pageSizeZero,reasonable,不配置映射的用默認值 -->
	<!-- 不理解該含義的前提下，不要隨便複製該配置 <property name="params" value="pageNum=start;pageSize=limit;"/> -->
</plugin>

上面是PageHelper官方給的配置和註釋，雖然寫的不少，不過確實描述的很明白。sql

dialect：標識是哪種數據庫，設計上必須。數據庫

offsetAsPageNum：將RowBounds第一個參數offset當成pageNum頁碼使用，這就是上面說的一參兩用，我的以爲徹底不必，offset = pageSize * pageNum就搞定了，何須混用參數呢？編程

rowBoundsWithCount：設置爲true時，使用RowBounds分頁會進行count查詢，我的以爲徹底不必，實際開發中，每個列表分頁查詢，都配備一個count數量查詢便可。緩存

reasonable：value=true時，pageNum小於1會查詢第一頁，若是pageNum大於pageSize會查詢最後一頁 ，我的認爲，參數校驗在進入Mybatis業務體系以前，就應該完成了，不可能到達Mybatis業務體系內參數還帶有非法的值。安全

這麼一來，咱們只須要記住 dialect = mysql 一個參數便可，其實，還有下面幾個相關參數能夠配置。網絡

autoDialect：true or false，是否自動檢測dialect。

autoRuntimeDialect：true or false，多數據源時，是否自動檢測dialect。

closeConn：true or false，檢測完dialect後，是否關閉Connection鏈接。

上面這3個智能參數，不到萬不得已，咱們不該該在系統中使用，咱們只須要一個dialect = mysql 或者 dialect = oracle就夠了，若是系統中須要使用，仍是得問問本身，是否真的非用不可。

2. PageHelper源碼分析

@Intercepts(@Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}))
public class PageHelper implements Interceptor {
    //sql工具類
    private SqlUtil sqlUtil;
    //屬性參數信息
    private Properties properties;
    //配置對象方式
    private SqlUtilConfig sqlUtilConfig;
    //自動獲取dialect,若是沒有setProperties或setSqlUtilConfig，也能夠正常進行
    private boolean autoDialect = true;
    //運行時自動獲取dialect
    private boolean autoRuntimeDialect;
    //多數據源時，獲取jdbcurl後是否關閉數據源
    private boolean closeConn = true;
    //緩存
    private Map<String, SqlUtil> urlSqlUtilMap = new ConcurrentHashMap<String, SqlUtil>();
    private ReentrantLock lock = new ReentrantLock();
// ...
}

上面是官方源碼以及源碼所帶的註釋，咱們再補充一下。

SqlUtil：數據庫類型專用sql工具類，一個數據庫url對應一個SqlUtil實例，SqlUtil內有一個Parser對象，若是是mysql，它是MysqlParser，若是是oracle，它是OracleParser，這個Parser對象是SqlUtil不一樣實例的主要存在價值。執行count查詢、設置Parser對象、執行分頁查詢、保存Page分頁對象等功能，均由SqlUtil來完成。

SqlUtilConfig：Spring Boot中使用，忽略。

autoRuntimeDialect：多個數據源切換時，好比mysql和oracle數據源同時存在，就不能簡單指定dialect，這個時候就須要運行時自動檢測當前的dialect。

Map<String, SqlUtil> urlSqlUtilMap：它就用來緩存autoRuntimeDialect自動檢測結果的，key是數據庫的url，value是SqlUtil。因爲這種自動檢測只須要執行1次，因此作了緩存。

ReentrantLock lock：這個lock對象是比較有意思的現象，urlSqlUtilMap明明是一個同步ConcurrentHashMap，又搞了一個lock出來同步ConcurrentHashMap作什麼呢？是不是多此一舉？在《Java併發編程實戰》一書中有詳細論述，簡單的說，ConcurrentHashMap能夠保證put或者remove方法必定是線程安全的，但它不能保證put、get、remove的組合操做是線程安全的，爲了保證組合操做也是線程安全的，因此使用了lock。

com.github.pagehelper.PageHelper.java源碼。

// Mybatis攔截器方法 
   public Object intercept(Invocation invocation) throws Throwable {
        if (autoRuntimeDialect) {
            // 多數據源
            SqlUtil sqlUtil = getSqlUtil(invocation);
            return sqlUtil.processPage(invocation);
        } else {
            // 單數據源
            if (autoDialect) {
                initSqlUtil(invocation);
            }
            // 指定了dialect
            return sqlUtil.processPage(invocation);
        }
    }
    public synchronized void initSqlUtil(Invocation invocation) {
        if (this.sqlUtil == null) {
            this.sqlUtil = getSqlUtil(invocation);
            if (!autoRuntimeDialect) {
                properties = null;
                sqlUtilConfig = null;
            }
            autoDialect = false;
        }
    }
    public void setProperties(Properties p) {
        checkVersion();
        //多數據源時，獲取jdbcurl後是否關閉數據源
        String closeConn = p.getProperty("closeConn");
        //解決#97
        if(StringUtil.isNotEmpty(closeConn)){
            this.closeConn = Boolean.parseBoolean(closeConn);
        }
        //初始化SqlUtil的PARAMS
        SqlUtil.setParams(p.getProperty("params"));
        //數據庫方言
        String dialect = p.getProperty("dialect");
        String runtimeDialect = p.getProperty("autoRuntimeDialect");
        if (StringUtil.isNotEmpty(runtimeDialect) && runtimeDialect.equalsIgnoreCase("TRUE")) {
            this.autoRuntimeDialect = true;
            this.autoDialect = false;
            this.properties = p;
        } else if (StringUtil.isEmpty(dialect)) {
            autoDialect = true;
            this.properties = p;
        } else {
            autoDialect = false;
            sqlUtil = new SqlUtil(dialect);
            sqlUtil.setProperties(p);
        }
    }

    public SqlUtil getSqlUtil(Invocation invocation) {
        MappedStatement ms = (MappedStatement) invocation.getArgs()[0];
        //改成對dataSource作緩存
        DataSource dataSource = ms.getConfiguration().getEnvironment().getDataSource();
        String url = getUrl(dataSource);
        if (urlSqlUtilMap.containsKey(url)) {
            return urlSqlUtilMap.get(url);
        }
        try {
            lock.lock();
            if (urlSqlUtilMap.containsKey(url)) {
                return urlSqlUtilMap.get(url);
            }
            if (StringUtil.isEmpty(url)) {
                throw new RuntimeException("沒法自動獲取jdbcUrl，請在分頁插件中配置dialect參數!");
            }
            String dialect = Dialect.fromJdbcUrl(url);
            if (dialect == null) {
                throw new RuntimeException("沒法自動獲取數據庫類型，請經過dialect參數指定!");
            }
            SqlUtil sqlUtil = new SqlUtil(dialect);
            if (this.properties != null) {
                sqlUtil.setProperties(properties);
            } else if (this.sqlUtilConfig != null) {
                sqlUtil.setSqlUtilConfig(this.sqlUtilConfig);
            }
            urlSqlUtilMap.put(url, sqlUtil);
            return sqlUtil;
        } finally {
            lock.unlock();
        }
    }

autoRuntimeDialect：多數據源，會建立多個SqlUtil。

autoDialect：單數據源，只會建立1個SqlUtil。單數據源時，也能夠當作多數據源來使用。

指定了dialect：只會建立1個SqlUtil。

3. PageSqlSource

public abstract class PageSqlSource implements SqlSource {
 /**
     * 獲取正常的BoundSql
     *
     * @param parameterObject
     * @return
     */
    protected abstract BoundSql getDefaultBoundSql(Object parameterObject);

    /**
     * 獲取Count查詢的BoundSql
     *
     * @param parameterObject
     * @return
     */
    protected abstract BoundSql getCountBoundSql(Object parameterObject);

    /**
     * 獲取分頁查詢的BoundSql
     *
     * @param parameterObject
     * @return
     */
    protected abstract BoundSql getPageBoundSql(Object parameterObject);

    /**
     * 獲取BoundSql
     *
     * @param parameterObject
     * @return
     */
    @Override
    public BoundSql getBoundSql(Object parameterObject) {
        Boolean count = getCount();
        if (count == null) {
            return getDefaultBoundSql(parameterObject);
        } else if (count) {
            return getCountBoundSql(parameterObject);
        } else {
            return getPageBoundSql(parameterObject);
        }
    }
}

getDefaultBoundSql：獲取原始的未經改造的BoundSql。

getCountBoundSql：不須要寫count查詢，插件根據分頁查詢sql，智能的爲你生成的count查詢BoundSql。

getPageBoundSql：獲取分頁查詢的BoundSql。

舉例：

DefaultBoundSql：select  stud_id as studId , name, email, dob, phone from students

CountBoundSql：select  count(0) from students --由PageHelper智能完成

PageBoundSql：select  stud_id as studId , name, email, dob, phone from students limit ?, ?

（Made In Intellij Idea IDE）

public class PageStaticSqlSource extends PageSqlSource {
    private String sql;
    private List<ParameterMapping> parameterMappings;
    private Configuration configuration;
    private SqlSource original;
    
    @Override
    protected BoundSql getDefaultBoundSql(Object parameterObject) {
        String tempSql = sql;
        String orderBy = PageHelper.getOrderBy();
        if (orderBy != null) {
            tempSql = OrderByParser.converToOrderBySql(sql, orderBy);
        }
        return new BoundSql(configuration, tempSql, parameterMappings, parameterObject);
    }

    @Override
    protected BoundSql getCountBoundSql(Object parameterObject) {
        // localParser指的就是MysqlParser或者OracleParser
        // localParser.get().getCountSql(sql)，能夠根據原始的sql，生成一個count查詢的sql
        return new BoundSql(configuration, localParser.get().getCountSql(sql), parameterMappings, parameterObject);
    }

    @Override
    protected BoundSql getPageBoundSql(Object parameterObject) {
        String tempSql = sql;
        String orderBy = PageHelper.getOrderBy();
        if (orderBy != null) {
            tempSql = OrderByParser.converToOrderBySql(sql, orderBy);
        }
        // getPageSql能夠根據原始的sql，生成一個帶有分頁參數信息的sql，好比 limit ?, ?
        tempSql = localParser.get().getPageSql(tempSql);
        // 因爲sql增長了分頁參數的？號佔位符，getPageParameterMapping()就是在原有List<ParameterMapping>基礎上，增長兩個分頁參數對應的ParameterMapping對象，爲分頁參數賦值使用
        return new BoundSql(configuration, tempSql, localParser.get().getPageParameterMapping(configuration, original.getBoundSql(parameterObject)), parameterObject);
    }
}

假設List<ParameterMapping>原來的size=2，添加分頁參數後，其size=4，具體增長多少個，看分頁參數的？號數量。

其餘PageSqlSource，原理和PageStaticSqlSource如出一轍。

解析sql，並增長分頁參數佔位符，或者生成count查詢的sql，都依靠Parser來完成。

4. com.github.pagehelper.parser.Parser

（Made In Intellij Idea IDE）

public class MysqlParser extends AbstractParser {
    @Override
    public String getPageSql(String sql) {
        StringBuilder sqlBuilder = new StringBuilder(sql.length() + 14);
        sqlBuilder.append(sql);
        sqlBuilder.append(" limit ?,?");
        return sqlBuilder.toString();
    }

    @Override
    public Map<String, Object> setPageParameter(MappedStatement ms, Object parameterObject, BoundSql boundSql, Page<?> page) {
        Map<String, Object> paramMap = super.setPageParameter(ms, parameterObject, boundSql, page);
        paramMap.put(PAGEPARAMETER_FIRST, page.getStartRow());
        paramMap.put(PAGEPARAMETER_SECOND, page.getPageSize());
        return paramMap;
    }
}

咱們能夠清楚的看到，MysqlParser是如何添加分頁佔位符和分頁參數的。

public abstract class AbstractParser implements Parser, Constant {
    public String getCountSql(final String sql) {
        return sqlParser.getSmartCountSql(sql);
    }
}

生成count sql，則是前文提到的jsqlparser工具包來完成的，是另一個開源的sql解析工具包。

5. SqlUtil.doProcessPage()分頁查詢

// PageSqlSource裝飾原SqlSource   
public void processMappedStatement(MappedStatement ms) throws Throwable {
        SqlSource sqlSource = ms.getSqlSource();
        MetaObject msObject = SystemMetaObject.forObject(ms);
        SqlSource pageSqlSource;
        if (sqlSource instanceof StaticSqlSource) {
            pageSqlSource = new PageStaticSqlSource((StaticSqlSource) sqlSource);
        } else if (sqlSource instanceof RawSqlSource) {
            pageSqlSource = new PageRawSqlSource((RawSqlSource) sqlSource);
        } else if (sqlSource instanceof ProviderSqlSource) {
            pageSqlSource = new PageProviderSqlSource((ProviderSqlSource) sqlSource);
        } else if (sqlSource instanceof DynamicSqlSource) {
            pageSqlSource = new PageDynamicSqlSource((DynamicSqlSource) sqlSource);
        } else {
            throw new RuntimeException("沒法處理該類型[" + sqlSource.getClass() + "]的SqlSource");
        }
        msObject.setValue("sqlSource", pageSqlSource);
        //因爲count查詢須要修改返回值，所以這裏要建立一個Count查詢的MS
        msCountMap.put(ms.getId(), MSUtils.newCountMappedStatement(ms));
    }

// 執行分頁查詢
private Page doProcessPage(Invocation invocation, Page page, Object[] args) throws Throwable {
        //保存RowBounds狀態
        RowBounds rowBounds = (RowBounds) args[2];
        //獲取原始的ms
        MappedStatement ms = (MappedStatement) args[0];
        //判斷並處理爲PageSqlSource
        if (!isPageSqlSource(ms)) {
            processMappedStatement(ms);
        }
        //設置當前的parser，後面每次使用前都會set，ThreadLocal的值不會產生不良影響
        ((PageSqlSource)ms.getSqlSource()).setParser(parser);
        try {
            //忽略RowBounds-不然會進行Mybatis自帶的內存分頁
            args[2] = RowBounds.DEFAULT;
            //若是隻進行排序 或 pageSizeZero的判斷
            if (isQueryOnly(page)) {
                return doQueryOnly(page, invocation);
            }

            //簡單的經過total的值來判斷是否進行count查詢
            if (page.isCount()) {
                page.setCountSignal(Boolean.TRUE);
                //替換MS
                args[0] = msCountMap.get(ms.getId());
                //查詢總數
                Object result = invocation.proceed();
                //還原ms
                args[0] = ms;
                //設置總數
                page.setTotal((Integer) ((List) result).get(0));
                if (page.getTotal() == 0) {
                    return page;
                }
            } else {
                page.setTotal(-1l);
            }
            //pageSize>0的時候執行分頁查詢，pageSize<=0的時候不執行至關於可能只返回了一個count
            if (page.getPageSize() > 0 &&
                    ((rowBounds == RowBounds.DEFAULT && page.getPageNum() > 0)
                            || rowBounds != RowBounds.DEFAULT)) {
                //將參數中的MappedStatement替換爲新的qs
                page.setCountSignal(null);
                BoundSql boundSql = ms.getBoundSql(args[1]);
                args[1] = parser.setPageParameter(ms, args[1], boundSql, page);
                page.setCountSignal(Boolean.FALSE);
                //執行分頁查詢
                Object result = invocation.proceed();
                //獲得處理結果
                page.addAll((List) result);
            }
        } finally {
            ((PageSqlSource)ms.getSqlSource()).removeParser();
        }

        //返回結果
        return page;
    }

源碼中注意關鍵的四點便可：

一、msCountMap.put(ms.getId(), MSUtils.newCountMappedStatement(ms))，建立count查詢的MappedStatement對象，並緩存於msCountMap。

二、若是count=true，則執行count查詢，結果total值保存於page對象中，繼續執行分頁查詢。

三、執行分頁查詢，將查詢結果保存於page對象中，page是一個ArrayList對象。

四、
args[2] = RowBounds.DEFAULT，改變Mybatis原有分頁行爲；

args[1] = parser.setPageParameter(ms, args[1], boundSql, page)，改變原有參數列表（增長分頁參數）。

6. PageHelper的兩種使用方式

第一種、直接經過RowBounds參數完成分頁查詢 。

List<Student> list = studentMapper.find(new RowBounds(0, 10));
Page page = ((Page) list;

第二種、PageHelper.startPage()靜態方法

//獲取第1頁，10條內容，默認查詢總數count
    PageHelper.startPage(1, 10);
//緊跟着的第一個select方法會被分頁
    List<Country> list = studentMapper.find();
    Page page = ((Page) list;

注：返回結果list，已是Page對象，Page對象是一個ArrayList。

原理：使用ThreadLocal來傳遞和保存Page對象，每次查詢，都須要單獨設置PageHelper.startPage()方法。

public class SqlUtil implements Constant {
    private static final ThreadLocal<Page> LOCAL_PAGE = new ThreadLocal<Page>();
}

 

本文中常常提到的count查詢，實際上是PageHelper幫助咱們生成的一個MappedStatement內存對象，它能夠免去咱們在XXXMapper.xml內單獨聲明一個sql count查詢，咱們只須要寫一個sql分頁業務查詢便可。

PageHelper使用建議（性能最好）：

一、明確指定dialect。二、明確編寫sql分頁業務和與它對應的count查詢，別圖省事。

 

版權提示：文章出自開源中國社區，若對文章感興趣，可關注個人開源中國社區博客（http://my.oschina.net/zudajun）。（通過網絡爬蟲或轉載的文章，常常丟失流程圖、時序圖，格式錯亂等，仍是看原版的比較好）

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程