分页原理

自定义 mybatis 分页插件，通过拦截 StatementHandler 的 prepare() 方法来实现。

说的详细一点就是，在编译 SQL 时，通过 java 反射查询参数列表中是否存在 PageView 类型的参数。如果存在，则根据参数重新包装 SQL 并执行 自定义的 count 语句。如果不存在，则不作任何处理。

StatementHandler

public interface StatementHandler {

    // 预编译SQL
    Statement prepare(Connection var1) throws SQLException;

    // 设置SQL中的参数
    void parameterize(Statement var1) throws SQLException;

    void batch(Statement var1) throws SQLException;

    // 执行更新
    int update(Statement var1) throws SQLException;

    // 执行查询
    <E> List<E> query(Statement var1, ResultHandler var2) throws SQLException;

    BoundSql getBoundSql();

    // 处理用户设置的参数，parameterize 的实现
    ParameterHandler getParameterHandler();
}

从上面的源代码能看出，prepare() 方法负责预编译 SQL，所以实现自定义分页就是在预编译时对 SQL 语句重新包装（自动加上 limit 语句）。

StatementHandler 的负责处理 Mybatis 与 JDBC 之间 Statement 的交互，JDBC 中的 Statement 负责与数据库进行交互。

PagePlugin

自定义分页插件的具体代码如下：

@Intercepts({ @Signature(type = StatementHandler.class, method = "prepare", args = { Connection.class }) })
public class PagePlugin implements Interceptor {

    private static Dialect dialectObject = null; // 数据库方言
    private static String pageSqlId = ""; //mybaits的数据库xml映射文件中需要拦截的ID(正则匹配)

    public Object intercept(Invocation ivk) throws Throwable {
        // RoutingStatementHandler 负责创建、调用 SimpleStatementHandler、PreparedStatementHandler、CallableStatementHandler
        if (ivk.getTarget() instanceof RoutingStatementHandler) {
            RoutingStatementHandler statementHandler = (RoutingStatementHandler) ivk
                    .getTarget();
            // 拿到实际执行的StatementHandler（SimpleStatementHandler、PreparedStatementHandler、CallableStatementHandler其中一个）
            BaseStatementHandler delegate = (BaseStatementHandler) ReflectHelper
                    .getValueByFieldName(statementHandler, "delegate");
            // 拿到Mapper.xml文件中对应的select/update/insert/delete节点信息
            MappedStatement mappedStatement = (MappedStatement) ReflectHelper
                    .getValueByFieldName(delegate, "mappedStatement");
            /**
             * 方法1：通过ＩＤ来区分是否需要分页．.*query.*
             * 方法2：传入的参数是否有page参数，如果有，则分页，
             */
            // if (mappedStatement.getId().matches(pageSqlId)) { // 拦截需要分页的SQL
            BoundSql boundSql = delegate.getBoundSql();
            // 分页SQL<select>中parameterType属性对应的实体参数，即Mapper接口中执行分页方法的参数,该参数不得为空
            Object parameterObject = boundSql.getParameterObject();
            if (parameterObject == null) {// 忽略参数为null的情况（检测不到PageView实例对象）
                // throw new
                // NullPointerException("boundSql.getParameterObject() is null!");
                return ivk.proceed();
            } 

            PageView pageView = null;
            if (parameterObject instanceof PageView) { // 参数就是Page实体
                pageView = (PageView) parameterObject;
            } else if (parameterObject instanceof Map) {// 参数为MAP，该MAP拥有Page属性
                for (Entry entry : (Set<Entry>) ((Map) parameterObject).entrySet()) {
                    if (entry.getValue() instanceof PageView) {
                        pageView = (PageView) entry.getValue();
                        break;
                    }
                }               
            } else { // 参数为某个实体，该实体拥有Page属性
                pageView = ReflectHelper.getValueByFieldType(parameterObject, PageView.class);
            }

            // 忽略参数不包含Page对象
            if (pageView == null) {
                return ivk.proceed();
            }

            String sql = boundSql.getSql();
            PreparedStatement countStmt = null;
            ResultSet rs = null;
            try {
                Connection connection = (Connection) ivk.getArgs()[0];
                // 统计符合条件的总记录数
                String countSql = "select count(1) from (" + sql + ") tmp_count"; 
                countStmt = connection.prepareStatement(countSql);
                ReflectHelper.setValueByFieldName(boundSql, "sql", countSql);
                DefaultParameterHandler parameterHandler = new DefaultParameterHandler(
                        mappedStatement, parameterObject, boundSql);
                parameterHandler.setParameters(countStmt);
                rs = countStmt.executeQuery();
                int count = 0;
                if (rs.next()) {
                    count = ((Number) rs.getObject(1)).intValue();
                }
                pageView.setRowCount(count);
            } finally {
                try {
                    rs.close();
                } catch (Exception e) {
                }
                try {
                    countStmt.close();
                } catch (Exception e) {
                }
            }
            // 根据 PageView，组装sql
            String pageSql = generatePagesSql(sql, pageView);
            // 将分页sql语句反射回BoundSql
            ReflectHelper.setValueByFieldName(boundSql, "sql", pageSql);
            // }
        }
        return ivk.proceed();
    }

    /**
     * 根据数据库方言，生成特定的分页sql
     * 
     * @param sql sql语句
     * @param page 分页对象
     */
    private String generatePagesSql(String sql, PageView page) {
        if (page != null && dialectObject != null) {
            // pageNow默认是从1，而已数据库是从0开始计算的，所以(page.getPageNow()-1)
            int pageNow = page.getPageNow();
            return dialectObject.getLimitString(sql, (pageNow <= 0 ? 0
                    : pageNow - 1) * page.getPageSize(), page.getPageSize());
        }
        return sql;
    }

}