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.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.scripting.defaults.DefaultParameterHandler;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import utn.app.daobase.model.PageInfo;

/**  
 *  
 * 分頁攔截器，用於攔截需要進行分頁查詢的操作，然後對其進行分頁處理。  
 * 利用攔截器實現Mybatis分頁的原理：  
 * 要利用JDBC對資料庫進行操作就必須要有一個對應的Statement物件，Mybatis在執行Sql語句前就會產生一個包含Sql語句的Statement物件，而且對應的Sql語句  
 * 是在Statement之前產生的，所以我們就可以在它生成Statement之前對用來生成Statement的Sql語句下手。在Mybatis中Statement語句是通過RoutingStatementHandler物件的  
 * prepare方法生成的。所以利用攔截器實現Mybatis分頁的一個思路就是攔截StatementHandler介面的prepare方法，然後在攔截器方法中把Sql語句改成對應的分頁查詢Sql語句，之後再呼叫  
 * StatementHandler物件的prepare方法，即呼叫invocation.proceed()。  
 * 對於分頁而言，在攔截器裡面我們還需要做的一個操作就是統計滿足當前條件的記錄一共有多少，這是通過獲取到了原始的Sql語句後，把它改為對應的統計語句再利用Mybatis封裝好的引數和設  
 * 置引數的功能把Sql語句中的引數進行替換，之後再執行查詢記錄數的Sql語句進行總記錄數的統計。  
 *  
 */    
@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 MybatisSpringPageInterceptor implements Interceptor {
    private static final Logger log = LoggerFactory.getLogger(MybatisSpringPageInterceptor.class);

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

    protected String databaseType;// 資料庫型別，不同的資料庫有不同的分頁方法

    @SuppressWarnings("rawtypes")
    protected ThreadLocal<PageInfo> pageThreadLocal = new ThreadLocal<PageInfo>();

    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;
    }

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

    public void setProperties(Properties properties) {
        String databaseType = properties.getProperty("databaseType");
        if (databaseType != null) {
            setDatabaseType(databaseType);
        }
    }
    /*對於StatementHandler其實只有兩個實現類，一個是RoutingStatementHandler，另一個是抽象類BaseStatementHandler，    
        BaseStatementHandler有三個子類，分別是SimpleStatementHandler，PreparedStatementHandler和CallableStatementHandler，    
        SimpleStatementHandler是用於處理Statement的，PreparedStatementHandler是處理PreparedStatement的，而CallableStatementHandler是    
        處理CallableStatement的。Mybatis在進行Sql語句處理的時候都是建立的RoutingStatementHandler，而在RoutingStatementHandler裡面擁有一個    
        StatementHandler型別的delegate屬性，RoutingStatementHandler會依據Statement的不同建立對應的BaseStatementHandler，即SimpleStatementHandler    
        PreparedStatementHandler或CallableStatementHandler，在RoutingStatementHandler裡面所有StatementHandler介面方法的實現都是呼叫的delegate對應的方法*/
    @SuppressWarnings({ "unchecked", "rawtypes" })
    public Object intercept(Invocation invocation) throws Throwable {
        if (invocation.getTarget() instanceof StatementHandler) { // 控制SQL和查詢總數的地方
            PageInfo 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物件
            PageInfo<?> 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 PageInfo<?> findPageObject(Object parameterObj) {
        if (parameterObj instanceof PageInfo<?>) {
            return (PageInfo<?>) parameterObj;
        } else if (parameterObj instanceof Map) {
            for (Object val : ((Map<?, ?>) parameterObj).values()) {
                if (val instanceof PageInfo<?>) {
                    return (PageInfo<?>) val;
                }
            }
        }
        return null;
    }

    /**
     * <pre>
     * 把真正的引數物件解析出來
     * Spring會自動封裝zhe這個引數物件為Map<String, Object>物件
     * 對於通過@Param指定key值引數我們不做處理，因為XML檔案需要該KEY值
     * 而對於沒有@Param指定時，Spring會使用0,1作為主鍵
     * 對於沒有@Param指定名稱的引數,一般XML檔案會直接對真正的引數物件解析，
     * 此時解析出真正的引數作為根物件
     * </pre>
     * @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 PageInfo<?>)) {
                            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>
     *
     * @param page
     * @param sql
     * @return
     */
    protected String buildPageSql(PageInfo<?> 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>
     *
     * @param page
     * @param sql
     * @return
     */
    protected String buildMysqlPageSql(PageInfo<?> 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>
     *
     * @param page
     * @param sql
     * @return
     */
    protected String buildOraclePageSql(PageInfo<?> 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>
     *
     * @param page
     * @param parameterObject
     * @param mappedStatement
     * @param connection
     * @throws SQLException
     */
    protected void queryTotalRecord(PageInfo<?> page, Object parameterObject, MappedStatement mappedStatement, Connection connection) throws SQLException {
        BoundSql boundSql = mappedStatement.getBoundSql(page);
        //獲取到我們自己寫在Mapper對映語句中對應的Sql語句 
        String sql = boundSql.getSql();
        //通過查詢Sql語句獲取到對應的計算總記錄數的sql語句  
        String countSql = this.buildCountSql(sql);
        if (log.isDebugEnabled()) {
            log.debug("分頁時, 生成countSql: " + countSql);
        }
        //通過BoundSql獲取對應的引數對映
        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
        //利用Configuration、查詢記錄數的Sql語句countSql、引數對映關係parameterMappings和引數物件page建立查詢記錄數對應的BoundSql物件。
        BoundSql countBoundSql = new BoundSql(mappedStatement.getConfiguration(), countSql, parameterMappings, parameterObject);
        //通過mappedStatement、引數物件page和BoundSql物件countBoundSql建立一個用於設定引數的ParameterHandler物件
        ParameterHandler parameterHandler = new DefaultParameterHandler(mappedStatement, parameterObject, countBoundSql);
        //通過connection建立一個countSql對應的PreparedStatement物件。
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        try {
            pstmt = connection.prepareStatement(countSql);
            //通過parameterHandler給PreparedStatement物件設定引數 
            parameterHandler.setParameters(pstmt);
           //執行獲取總記錄數的Sql語句和獲取結果了。
            rs = pstmt.executeQuery();
            if (rs.next()) {
                long totalRecord = rs.getLong(1);
                //給當前的引數page物件設定總記錄數 
                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.toLowerCase().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 {

        /** serialVersionUID*/
        private static final long serialVersionUID = 1L;

        public PageNotSupportException() {
            super();
        }

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

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

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

 

別忘了在mybatis配置檔案中這個配置
<!-- 配置管理器 -->
<configuration>
	<properties>  
        <property name="dialect" value="mysql" />  
    </properties>
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING" />
    </settings>
	<plugins>  
        <plugin interceptor="utn.app.daobase.interceptor.MybatisSpringPageInterceptor"></plugin>
    </plugins>
</configuration>