天天看點
傳回

Mybatis通過攔截器實作分頁查詢plugin的實作

Mybatis的分頁功能很弱，它是基于記憶體的分頁（查出所有記錄再按偏移量和limit取結果），在大資料量的情況下這樣的分頁基本上是沒有用的。本文基于插件，通過攔截StatementHandler重寫sql語句，實作資料庫的實體分頁。本文适配的mybatis版本是3.2.2。

準備

為什麼在StatementHandler攔截

在

深入淺出MyBatis-Sqlsession

章節介紹了一次sqlsession的完整執行過程，從中可以知道sql的解析是在StatementHandler裡完成的，是以為了重寫sql需要攔截StatementHandler。

MetaObject簡介

在我的實作裡大量使用了MetaObject這個對象，是以有必要先介紹下它。MetaObject是Mybatis提供的一個的工具類，通過它包裝一個對象後可以擷取或設定該對象的原本不可通路的屬性（比如那些私有屬性）。它有個三個重要方法經常用到：

1)       MetaObject forObject(Object object,ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory)

2)       Object getValue(String name)

3)       void setValue(String name, Object value)

方法1)用于包裝對象；方法2)用于擷取屬性的值（支援OGNL的方法）；方法3)用于設定屬性的值（支援OGNL的方法）；

插件的原理

參見

深入淺出Mybatis-插件原理

。

有了上面這些基礎知識的準備後，就可以我們的主題了。

攔截器簽名 

@Intercepts({@Signature(type =StatementHandler.class, method = "prepare", args ={Connection.class})})  
publicclass PageInterceptor implementsInterceptor {  
...  
}

從簽名裡可以看出，要攔截的目标類型是StatementHandler（注意：type隻能配置成接口類型），攔截的方法是名稱為prepare參數為Connection類型的方法。

intercept的實作 

public Object intercept(Invocation invocation) throws Throwable {  
     StatementHandler statementHandler = (StatementHandler) invocation.getTarget();  
     MetaObject metaStatementHandler = MetaObject.forObject(statementHandler,  
     DEFAULT_OBJECT_FACTORY, DEFAULT_OBJECT_WRAPPER_FACTORY);  
     // 分離代理對象鍊(由于目标類可能被多個攔截器攔截，進而形成多次代理，通過下面的兩次循環  
     // 可以分離出最原始的的目标類)  
     while (metaStatementHandler.hasGetter("h")) {  
         Object object = metaStatementHandler.getValue("h");  
         metaStatementHandler = MetaObject.forObject(object, DEFAULT_OBJECT_FACTORY,   
         DEFAULT_OBJECT_WRAPPER_FACTORY);  
     }  
     // 分離最後一個代理對象的目标類  
     while (metaStatementHandler.hasGetter("target")) {  
         Object object = metaStatementHandler.getValue("target");  
         metaStatementHandler = MetaObject.forObject(object, DEFAULT_OBJECT_FACTORY,   
         DEFAULT_OBJECT_WRAPPER_FACTORY);  
     }  
     Configuration configuration = (Configuration) metaStatementHandler.  
     getValue("delegate.configuration");  
     dialect = configuration.getVariables().getProperty("dialect");  
     if (null == dialect || "".equals(dialect)) {  
         logger.warn("Property dialect is not setted,use default 'mysql' ");  
         dialect = defaultDialect;  
     }  
     pageSqlId = configuration.getVariables().getProperty("pageSqlId");  
     if (null == pageSqlId || "".equals(pageSqlId)) {  
         logger.warn("Property pageSqlId is not setted,use default '.*Page$' ");  
         pageSqlId = defaultPageSqlId;  
     }  
     MappedStatement mappedStatement = (MappedStatement)   
     metaStatementHandler.getValue("delegate.mappedStatement");  
     // 隻重寫需要分頁的sql語句。通過MappedStatement的ID比對，預設重寫以Page結尾的  
     //  MappedStatement的sql  
     if (mappedStatement.getId().matches(pageSqlId)) {  
         BoundSql boundSql = (BoundSql) metaStatementHandler.getValue("delegate.boundSql");  
         Object parameterObject = boundSql.getParameterObject();  
         if (parameterObject == null) {  
             throw new NullPointerException("parameterObject is null!");  
         } else {  
             // 分頁參數作為參數對象parameterObject的一個屬性  
             PageParameter page = (PageParameter) metaStatementHandler  
                     .getValue("delegate.boundSql.parameterObject.page");  
             String sql = boundSql.getSql();  
             // 重寫sql  
             String pageSql = buildPageSql(sql, page);  
             metaStatementHandler.setValue("delegate.boundSql.sql", pageSql);  
             // 采用實體分頁後，就不需要mybatis的記憶體分頁了，是以重置下面的兩個參數  
             metaStatementHandler.setValue("delegate.rowBounds.offset",   
             RowBounds.NO_ROW_OFFSET);  
             metaStatementHandler.setValue("delegate.rowBounds.limit", RowBounds.NO_ROW_LIMIT);  
             Connection connection = (Connection) invocation.getArgs()[0];  
             // 重設分頁參數裡的總頁數等  
             setPageParameter(sql, connection, mappedStatement, boundSql, page);  
         }  
     }  
     // 将執行權交給下一個攔截器  
     return invocation.proceed();  
 }

StatementHandler的預設實作類是RoutingStatementHandler，是以攔截的實際對象是它。RoutingStatementHandler的主要功能是分發，它根據配置Statement類型建立真正執行資料庫操作的StatementHandler，并将其儲存到delegate屬性裡。由于delegate是一個私有屬性并且沒有提供通路它的方法，是以需要借助MetaObject的幫忙。通過MetaObject的封裝後我們可以輕易的獲得想要的屬性。

在上面的方法裡有個兩個循環，通過他們可以分離出原始的RoutingStatementHandler（而不是代理對象）。

前面提到，簽名裡配置的要攔截的目标類型是StatementHandler攔截的方法是名稱為prepare參數為Connection類型的方法，而這個方法是每次資料庫通路都要執行的。因為我是通過重寫sql的方式實作分頁，為了不影響其他sql（update或不需要分頁的query），我采用了通過ID比對的方式過濾。預設的過濾方式隻對id以Page結尾的進行攔截（注意區分大小寫），如下：

<select id="queryUserByPage" parameterType="UserDto" resultType="UserDto">  
 <![CDATA[ 
    select * from t_user t where t.username = #{username} 
    ]]>  
</select>

當然，也可以自定義攔截模式，在mybatis的配置檔案裡加入以下配置項：

[html] view plaincopy

    <properties>  
        <property name="dialect" value="mysql" />  
        <property name="pageSqlId" value=".*Page$" />  
    </properties>

其中，屬性dialect訓示資料庫類型，目前隻支援mysql和oracle兩種資料庫。其中，屬性pageSqlId訓示攔截的規則，以正則方式比對。

sql重寫

sql重寫其實在原始的sql語句上加入分頁的參數，目前支援mysql和oracle兩種資料庫的分頁。

private String buildPageSql(String sql, PageParameter page) {  
    if (page != null) {  
        StringBuilder pageSql = new StringBuilder();  
        if ("mysql".equals(dialect)) {  
            pageSql = buildPageSqlForMysql(sql, page);  
        } else if ("oracle".equals(dialect)) {  
            pageSql = buildPageSqlForOracle(sql, page);  
        } else {  
            return sql;  
        }  
        return pageSql.toString();  
    } else {  
        return sql;  
    }  
}

 mysql的分頁實作：

public StringBuilder buildPageSqlForMysql(String sql, PageParameter page) {  
    StringBuilder pageSql = new StringBuilder(100);  
    String beginrow = String.valueOf((page.getCurrentPage() - 1) * page.getPageSize());  
    pageSql.append(sql);  
    pageSql.append(" limit " + beginrow + "," + page.getPageSize());  
    return pageSql;  
}

oracle的分頁實作：

public StringBuilder buildPageSqlForOracle(String sql, PageParameter page) {  
        StringBuilder pageSql = new StringBuilder(100);  
        String beginrow = String.valueOf((page.getCurrentPage() - 1) * page.getPageSize());  
        String endrow = String.valueOf(page.getCurrentPage() * page.getPageSize());  
        pageSql.append("select * from ( select temp.*, rownum row_id from ( ");  
        pageSql.append(sql);  
        pageSql.append(" ) temp where rownum <= ").append(endrow);  
        pageSql.append(") where row_id > ").append(beginrow);  
        return pageSql;  
    }

分頁參數重寫

有時候會有這種需求，就是不但要查出指定頁的結果，還需要知道總的記錄數和頁數。我通過重寫分頁參數的方式提供了一種解決方案：

/** 
 * 從資料庫裡查詢總的記錄數并計算總頁數，回寫進分頁參數<code>PageParameter</code>,這樣調用  
 * 者就可用通過 分頁參數<code>PageParameter</code>獲得相關資訊。 
 *  
 * @param sql 
 * @param connection 
 * @param mappedStatement 
 * @param boundSql 
 * @param page 
 */  
private void setPageParameter(String sql, Connection connection, MappedStatement mappedStatement,  
        BoundSql boundSql, PageParameter page) {  
    // 記錄總記錄數  
    String countSql = "select count(0) from (" + sql + ") as total";  
    PreparedStatement countStmt = null;  
    ResultSet rs = null;  
    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();  
        int totalCount = 0;  
        if (rs.next()) {  
            totalCount = rs.getInt(1);  
        }  
        page.setTotalCount(totalCount);  
        int totalPage = totalCount / page.getPageSize() + ((totalCount % page.getPageSize() == 0) ? 0 : 1);  
        page.setTotalPage(totalPage);  
    } catch (SQLException e) {  
        logger.error("Ignore this exception", e);  
    } finally {  
        try {  
            rs.close();  
        } catch (SQLException e) {  
            logger.error("Ignore this exception", e);  
        }  
        try {  
            countStmt.close();  
        } catch (SQLException e) {  
            logger.error("Ignore this exception", e);  
        }  
    }  
}  
  
/** 
 * 對SQL參數(?)設值 
 *  
 * @param ps 
 * @param mappedStatement 
 * @param boundSql 
 * @param parameterObject 
 * @throws SQLException 
 */  
private void setParameters(PreparedStatement ps, MappedStatement mappedStatement, BoundSql boundSql,  
        Object parameterObject) throws SQLException {  
    ParameterHandler parameterHandler = new DefaultParameterHandler(mappedStatement, parameterObject, boundSql);  
    parameterHandler.setParameters(ps);  
}

plugin的實作 

public Object plugin(Object target) {  
    // 當目标類是StatementHandler類型時，才包裝目标類，否者直接傳回目标本身,減少目标被代理的  
    // 次數  
    if (target instanceof StatementHandler) {  
        return Plugin.wrap(target, this);  
    } else {  
        return target;  
    }  
}
sql 關系型資料庫 java 資料庫 mybatis 資料庫連接配接 mysql Oracle mybatis實作分頁查詢 mybatis分頁查詢 mybatis實作分頁 mybatis查詢sql mybatis中級查詢
上一篇: jdbc_分頁查詢，大資料，批處理，存儲過程
下一篇: SpringMVC整合Shiro

繼續閱讀