比較適用於在分頁時候進行攔截。對分頁的SQL語句通過封裝處理，處理成不同的分頁sql。

實用性比較強。

1. import java.sql.Connection;  
2. import java.sql.PreparedStatement;  
3. import java.sql.ResultSet;  
4. import java.sql.SQLException;  
5. import java.util.List;  
6. import java.util.Properties;  
7. import org.apache.ibatis.executor.parameter.ParameterHandler;  
8. import org.apache.ibatis.executor.statement.RoutingStatementHandler;  
9. import org.apache.ibatis.executor.statement.StatementHandler;  
10. import org.apache.ibatis.mapping.BoundSql;  
11. import org.apache.ibatis.mapping.MappedStatement;  
12. import org.apache.ibatis.mapping.ParameterMapping;  
13. import org.apache.ibatis.plugin.Interceptor;  
14. import org.apache.ibatis.plugin.Intercepts;  
15. import org.apache.ibatis.plugin.Invocation;  
16. import org.apache.ibatis.plugin.Plugin;  
17. import org.apache.ibatis.plugin.Signature;  
18. import org.apache.ibatis.scripting.defaults.DefaultParameterHandler;  
19. import com.yidao.utils.Page;  
20. import com.yidao.utils.ReflectHelper;  
21. /**  
22.  *  
23.  * 分頁攔截器，用於攔截需要進行分頁查詢的操作，然後對其進行分頁處理。  
24.  * 利用攔截器實現Mybatis分頁的原理：  
25.  * 要利用JDBC對資料庫進行操作就必須要有一個對應的Statement物件，Mybatis在執行Sql語句前就會產生一個包含Sql語句的Statement物件，而且對應的Sql語句  
26.  * 是在Statement之前產生的，所以我們就可以在它生成Statement之前對用來生成Statement的Sql語句下手。在Mybatis中Statement語句是通過RoutingStatementHandler物件的  
27.  * prepare方法生成的。所以利用攔截器實現Mybatis分頁的一個思路就是攔截StatementHandler介面的prepare方法，然後在攔截器方法中把Sql語句改成對應的分頁查詢Sql語句，之後再呼叫  
28.  * StatementHandler物件的prepare方法，即呼叫invocation.proceed()。  
29.  * 對於分頁而言，在攔截器裡面我們還需要做的一個操作就是統計滿足當前條件的記錄一共有多少，這是通過獲取到了原始的Sql語句後，把它改為對應的統計語句再利用Mybatis封裝好的引數和設  
30.  * 置引數的功能把Sql語句中的引數進行替換，之後再執行查詢記錄數的Sql語句進行總記錄數的統計。  
31.  *  
32.  */
33. @Intercepts({@Signature(type=StatementHandler.class,method="prepare",args={Connection.class})})  
34. publicclass PageInterceptor implements Interceptor {  
35.     private String dialect = ""; //資料庫方言  
36.     private String pageSqlId = ""; //mapper.xml中需要攔截的ID(正則匹配)  
37.     public Object intercept(Invocation invocation) throws Throwable {  
38.         //對於StatementHandler其實只有兩個實現類，一個是RoutingStatementHandler，另一個是抽象類BaseStatementHandler，  
39.         //BaseStatementHandler有三個子類，分別是SimpleStatementHandler，PreparedStatementHandler和CallableStatementHandler，  
40.         //SimpleStatementHandler是用於處理Statement的，PreparedStatementHandler是處理PreparedStatement的，而CallableStatementHandler是  
41.         //處理CallableStatement的。Mybatis在進行Sql語句處理的時候都是建立的RoutingStatementHandler，而在RoutingStatementHandler裡面擁有一個  
42.         //StatementHandler型別的delegate屬性，RoutingStatementHandler會依據Statement的不同建立對應的BaseStatementHandler，即SimpleStatementHandler、  
43.         //PreparedStatementHandler或CallableStatementHandler，在RoutingStatementHandler裡面所有StatementHandler介面方法的實現都是呼叫的delegate對應的方法。  
44.         //我們在PageInterceptor類上已經用@Signature標記了該Interceptor只攔截StatementHandler介面的prepare方法，又因為Mybatis只有在建立RoutingStatementHandler的時候  
45.         //是通過Interceptor的plugin方法進行包裹的，所以我們這裡攔截到的目標物件肯定是RoutingStatementHandler物件。
46.         if(invocation.getTarget() instanceof RoutingStatementHandler){    
47.             RoutingStatementHandler statementHandler = (RoutingStatementHandler)invocation.getTarget();    
48.             StatementHandler delegate = (StatementHandler) ReflectHelper.getFieldValue(statementHandler, "delegate");    
49.             BoundSql boundSql = delegate.getBoundSql();  
50.             Object obj = boundSql.getParameterObject();  
51.             if (obj instanceof Page<?>) {    
52.                 Page<?> page = (Page<?>) obj;    
53.                 //通過反射獲取delegate父類BaseStatementHandler的mappedStatement屬性  
54.                 MappedStatement mappedStatement = (MappedStatement)ReflectHelper.getFieldValue(delegate, "mappedStatement");    
55.                 //攔截到的prepare方法引數是一個Connection物件  
56.                 Connection connection = (Connection)invocation.getArgs()[0];    
57.                 //獲取當前要執行的Sql語句，也就是我們直接在Mapper對映語句中寫的Sql語句  
58.                 String sql = boundSql.getSql();    
59.                 //給當前的page引數物件設定總記錄數  
60.                 this.setTotalRecord(page,    
61.                        mappedStatement, connection);    
62.                 //獲取分頁Sql語句  
63.                 String pageSql = this.getPageSql(page, sql);    
64.                 //利用反射設定當前BoundSql對應的sql屬性為我們建立好的分頁Sql語句  
65.                 ReflectHelper.setFieldValue(boundSql, "sql", pageSql);    
66.             }   
67.         }    
68.         return invocation.proceed();    
69.     }  
70.     /**  
71.      * 給當前的引數物件page設定總記錄數  
72.      *  
73.      * @param page Mapper對映語句對應的引數物件  
74.      * @param mappedStatement Mapper對映語句  
75.      * @param connection 當前的資料庫連線  
76.      */
77.     privatevoid setTotalRecord(Page<?> page,    
78.            MappedStatement mappedStatement, Connection connection) {    
79.        //獲取對應的BoundSql，這個BoundSql其實跟我們利用StatementHandler獲取到的BoundSql是同一個物件。  
80.        //delegate裡面的boundSql也是通過mappedStatement.getBoundSql(paramObj)方法獲取到的。  
81.        BoundSql boundSql = mappedStatement.getBoundSql(page);    
82.        //獲取到我們自己寫在Mapper對映語句中對應的Sql語句  
83.        String sql = boundSql.getSql();    
84.        //通過查詢Sql語句獲取到對應的計算總記錄數的sql語句  
85.        String countSql = this.getCountSql(sql);    
86.        //通過BoundSql獲取對應的引數對映  
87.        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();    
88.        //利用Configuration、查詢記錄數的Sql語句countSql、引數對映關係parameterMappings和引數物件page建立查詢記錄數對應的BoundSql物件。  
89.        BoundSql countBoundSql = new BoundSql(mappedStatement.getConfiguration(), countSql, parameterMappings, page);    
90.        //通過mappedStatement、引數物件page和BoundSql物件countBoundSql建立一個用於設定引數的ParameterHandler物件  
91.        ParameterHandler parameterHandler = new DefaultParameterHandler(mappedStatement, page, countBoundSql);    
92.        //通過connection建立一個countSql對應的PreparedStatement物件。  
93.        PreparedStatement pstmt = null;    
94.        ResultSet rs = null;    
95.        try {    
96.            pstmt = connection.prepareStatement(countSql);    
97.            //通過parameterHandler給PreparedStatement物件設定引數  
98.            parameterHandler.setParameters(pstmt);    
99.            //之後就是執行獲取總記錄數的Sql語句和獲取結果了。  
100.            rs = pstmt.executeQuery();    
101.            if (rs.next()) {    
102.               int totalRecord = rs.getInt(1);    
103.               //給當前的引數page物件設定總記錄數  
104.               page.setTotalRecord(totalRecord);    
105.            }    
106.        } catch (SQLException e) {    
107.            e.printStackTrace();    
108.        } finally {    
109.            try {    
110.               if (rs != null)    
111.                   rs.close();    
112.                if (pstmt != null)    
113.                   pstmt.close();    
114.            } catch (SQLException e) {    
115.               e.printStackTrace();    
116.            }    
117.        }    
118.     }    
119.     /**  
120.      * 根據原Sql語句獲取對應的查詢總記錄數的Sql語句  
121.      * @param sql  
122.      * @return  
123.      */
124.     private String getCountSql(String sql) {    
125.        int index = sql.indexOf("from");    
126.        return"select count(*) " + sql.substring(index);    
127.     }    
128.     /**  
129.      * 根據page物件獲取對應的分頁查詢Sql語句，這裡只做了兩種資料庫型別，Mysql和Oracle  
130.      * 其它的資料庫都 沒有進行分頁  
131.      *  
132.      * @param page 分頁物件  
133.      * @param sql 原sql語句  
134.      * @return  
135.      */
136.     private String getPageSql(Page<?> page, String sql) {    
137.        StringBuffer sqlBuffer = new StringBuffer(sql);    
138.        if ("mysql".equalsIgnoreCase(dialect)) {    
139.            return getMysqlPageSql(page, sqlBuffer);    
140.        } elseif ("oracle".equalsIgnoreCase(dialect)) {    
141.            return getOraclePageSql(page, sqlBuffer);    
142.        }    
143.        return sqlBuffer.toString();    
144.     }    
145.     /**  
146.     * 獲取Mysql資料庫的分頁查詢語句  
147.     * @param page 分頁物件  
148.     * @param sqlBuffer 包含原sql語句的StringBuffer物件  
149.     * @return Mysql資料庫分頁語句  
150.     */
151.    private String getMysqlPageSql(Page<?> page, StringBuffer sqlBuffer) {    
152.       //計算第一條記錄的位置，Mysql中記錄的位置是從0開始的。  
153. //     System.out.println("page:"+page.getPage()+"-------"+page.getRows());
154.       int offset = (page.getPage() - 1) * page.getRows();    
155.       sqlBuffer.append(" limit ").append(offset).append(",").append(page.getRows());    
156.       return sqlBuffer.toString();    
157.    }    
158.    /**  
159.     * 獲取Oracle資料庫的分頁查詢語句  
160.     * @param page 分頁物件  
161.     * @param sqlBuffer 包含原sql語句的StringBuffer物件  
162.     * @return Oracle資料庫的分頁查詢語句  
163.     */
164.    private String getOraclePageSql(Page<?> page, StringBuffer sqlBuffer) {    
165.       //計算第一條記錄的位置，Oracle分頁是通過rownum進行的，而rownum是從1開始的  
166.       int offset = (page.getPage() - 1) * page.getRows() + 1;    
167.       sqlBuffer.insert(0, "select u.*, rownum r from (").append(") u where rownum < ").append(offset + page.getRows());    
168.       sqlBuffer.insert(0, "select * from (").append(") where r >= ").append(offset);    
169.       //上面的Sql語句拼接之後大概是這個樣子：  
170.       //select * from (select u.*, rownum r from (select * from t_user) u where rownum < 31) where r >= 16  
171.       return sqlBuffer.toString();    
172.    }    
173.     /**  
174.      * 攔截器對應的封裝原始物件的方法  
175.      */
176.     public Object plugin(Object arg0) {    
177.         // TODO Auto-generated method stub  
178.         if (arg0 instanceof StatementHandler) {    
179.             return Plugin.wrap(arg0, this);    
180.         } else {    
181.             return arg0;    
182.         }   
183.     }    
184.     /**  
185.      * 設定註冊攔截器時設定的屬性  
186.      */
187.     publicvoid setProperties(Properties p) {  
188.     }  
189.     public String getDialect() {  
190.         return dialect;  
191.     }  
192.     publicvoid setDialect(String dialect) {  
193.         this.dialect = dialect;  
194.     }  
195.     public String getPageSqlId() {  
196.         return pageSqlId;  
197.     }  
198.     publicvoid setPageSqlId(String pageSqlId) {  
199.         this.pageSqlId = pageSqlId;  
200.     }  
201. }  

xml配置：

1. <!-- MyBatis 介面程式設計配置  -->
2.     <beanclass="org.mybatis.spring.mapper.MapperScannerConfigurer">
3.         <!-- basePackage指定要掃描的包，在此包之下的對映器都會被搜尋到,可指定多個包，包與包之間用逗號或分號分隔-->
4.         <propertyname="basePackage"value="com.yidao.mybatis.dao"/>
5.         <propertyname="sqlSessionFactoryBeanName"value="sqlSessionFactory"/>
6.     </bean>
7.     <!-- MyBatis 分頁攔截器-->
8.     <beanid="paginationInterceptor"class="com.mybatis.interceptor.PageInterceptor">
9.         <propertyname="dialect"value="mysql"/>
10.         <!-- 攔截Mapper.xml檔案中，id包含query字元的語句 -->
11.         <propertyname="pageSqlId"value=".*query$"/>
12.     </bean>

Page類

1. package com.yidao.utils;  
2. /**自己看看，需要什麼欄位加什麼欄位吧*/
3. publicclass Page {  
4.     private Integer rows;  
5.     private Integer page = 1;  
6.     private Integer totalRecord;  
7.     public Integer getRows() {  
8.         return rows;  
9.     }  
10.     publicvoid setRows(Integer rows) {  
11.         this.rows = rows;  
12.     }  
13.     public Integer getPage() {  
14.         return page;  
15.     }  
16.     publicvoid setPage(Integer page) {  
17.         this.page = page;  
18.     }  
19.     public Integer getTotalRecord() {  
20.         return totalRecord;  
21.     }  
22.     publicvoid setTotalRecord(Integer totalRecord) {  
23.         this.totalRecord = totalRecord;  
24.     }  
25. }  

ReflectHelper類

1. package com.yidao.utils;  
2. import java.lang.reflect.Field;  
3. import org.apache.commons.lang3.reflect.FieldUtils;  
4. publicclass ReflectHelper {  
5.     publicstatic Object getFieldValue(Object obj , String fieldName ){  
6.         if(obj == null){  
7.             returnnull ;  
8.         }  
9.         Field targetField = getTargetField(obj.getClass(), fieldName);  
10.         try {  
11.             return FieldUtils.readField(targetField, obj, true ) ;  
12.         } catch (IllegalAccessException e) {  
13.             e.printStackTrace();  
14.         }   
15.         returnnull ;  
16.     }  
17.     publicstatic Field getTargetField(Class<?> targetClass, String fieldName) {  
18.         Field field = null;  
19.         try {  
20.             if (targetClass == null) {  
21.                 return field;  
22.             }  
23.             if (Object.class.equals(targetClass)) {  
24.                 return field;  
25.             }  
26.             field = FieldUtils.getDeclaredField(targetClass, fieldName, true);  
27.             if (field == null) {  
28.                 field = getTargetField(targetClass.getSuperclass(), fieldName);  
29.             }  
30.         } catch (Exception e) {  
31.         }  
32.         return field;  
33.     }  
34.     publicstaticvoid setFieldValue(Object obj , String fieldName , Object value ){  
35.         if(null == obj){return;}  
36.         Field targetField = getTargetField(obj.getClass(), fieldName);    
37.         try {  
38.              FieldUtils.writeField(targetField, obj, value) ;  
39.         } catch (IllegalAccessException e) {  
40.             e.printStackTrace();  
41.         }   
42.     }   
43. }