MyBatis学习（九）-MyBatis分页实现 - Oracle（二）

还记得上一次写的分页吗？

在MyBatis中实现分页的方法是这样的：

1.自定义一个拦截器

2.在拦截器中，根据不同的数据库返回不同的分页SQL语句

3.在配置文件中配置该拦截器插件

大概就是这么个顺序，在上一次实现时，使用了RowBounds，功能可能不是很强大，后来又在网上找到了一个实现方法，现分享一下：

1.pom.xml

这个和上一次是一样的

[html]  view plain copy

1. <?xml version="1.0"?>  
2. <project  
3.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"  
4.     xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">  
5.     <modelVersion>4.0.0</modelVersion>  
6.   
7.     <groupId>org.ygy.demo</groupId>  
8.     <artifactId>mybatis-parent</artifactId>  
9.     <version>0.0.1-SNAPSHOT</version>  
10.     <packaging>pom</packaging>  
11.   
12.   
13.     <name>mybatis-parent</name>  
14.     <url>http://maven.apache.org</url>  
15.   
16.     <dependencyManagement>  
17.         <dependencies>  
18.             <dependency>  
19.                 <groupId>junit</groupId>  
20.                 <artifactId>junit</artifactId>  
21.                 <version>4.10</version>  
22.                 <scope>test</scope>  
23.             </dependency>   
24.   
25.             <dependency>  
26.                 <groupId>org.mybatis</groupId>  
27.                 <artifactId>mybatis</artifactId>  
28.                 <version>3.1.1</version>  
29.             </dependency>  
30.   
31.             <dependency>  
32.                 <groupId>org.projectlombok</groupId>  
33.                 <artifactId>lombok</artifactId>  
34.                 <version>0.12.0</version>  
35.             </dependency>  
36.   
37.             <dependency>  
38.                 <groupId>com.oracle</groupId>  
39.                 <artifactId>ojdbc14</artifactId>  
40.                 <version>10.2.0.4.0</version>  
41.             </dependency>  
42.   
43.             <dependency>  
44.                 <groupId>log4j</groupId>  
45.                 <artifactId>log4j</artifactId>  
46.                 <version>1.2.17</version>  
47.             </dependency>  
48.   
49.         </dependencies>  
50.     </dependencyManagement>  
51.   
52.     <dependencies>  
53.         <dependency>  
54.             <groupId>junit</groupId>  
55.             <artifactId>junit</artifactId>  
56.         </dependency>  
57.   
58.         <dependency>  
59.             <groupId>org.mybatis</groupId>  
60.             <artifactId>mybatis</artifactId>  
61.         </dependency>  
62.   
63.         <dependency>  
64.             <groupId>org.projectlombok</groupId>  
65.             <artifactId>lombok</artifactId>  
66.         </dependency>  
67.   
68.         <dependency>  
69.             <groupId>com.oracle</groupId>  
70.             <artifactId>ojdbc14</artifactId>  
71.         </dependency>  
72.   
73.         <dependency>  
74.             <groupId>log4j</groupId>  
75.             <artifactId>log4j</artifactId>  
76.         </dependency>  
77.     </dependencies>  
78.   
79.     <build>  
80.         <plugins>  
81.             <plugin>  
82.                 <groupId>org.apache.maven.plugins</groupId>  
83.                 <artifactId>maven-compiler-plugin</artifactId>  
84.                 <configuration>  
85.                     <source>1.6</source>  
86.                     <target>1.6</target>  
87.                 </configuration>  
88.             </plugin>  
89.         </plugins>  
90.     </build>  
91.   
92.     <modules>  
93.         <module>mybatis-hello</module>  
94.         <module>mybatis-relevance</module>  
95.         <module>mybatis-common</module>  
96.         <module>mybatis-page</module>  
97.         <module>mybatis-batch</module>  
98.     </modules>  
99. </project>  

2.分页实体的实现

这个自定义了一个分页实体，实现了更多的功能

[java]  view plain copy

1. package org.ygy.demo.mybatis.interceptor;  
2.   
3. import java.util.HashMap;  
4. import java.util.List;  
5. import java.util.Map;  
6.   
7. import lombok.Data;  
8.   
9. /** 
10.  * 对分页的基本数据进行一个简单的封装 
11.  */  
12. @Data  
13. public class Page<T> {  
14.   
15.     private int start = 1;// 页码，默认是第一页  
16.     private int pageSize = 15;// 每页显示的记录数，默认是15  
17.     private int totalRecord;// 总记录数  
18.     private int totalPage;// 总页数  
19.     private List<T> results;// 对应的当前页记录  
20.     private Map<String, Object> params = new HashMap<String, Object>();// 其他的参数我们把它分装成一个Map对象  
21.   
22.     public void setTotalRecord(int totalRecord) {  
23.         this.totalRecord = totalRecord;  
24.         // 在设置总条数的时候计算出对应的总页数，在下面的三目运算中加法拥有更高的优先级，所以最后可以不加括号。  
25.         int totalPage = totalRecord % pageSize == 0 ? totalRecord / pageSize : totalRecord / pageSize + 1;  
26.         this.setTotalPage(totalPage);  
27.     }  
28. }  

3.拦截器的实现

这个拦截器的实现，原作者写了很多的注释，很有用，感谢分享（ps:很抱歉，忘记在哪里找的了）

[java]  view plain copy

1. package org.ygy.demo.mybatis.interceptor;  
2.   
3. import java.lang.reflect.Field;  
4. import java.sql.Connection;  
5. import java.sql.PreparedStatement;  
6. import java.sql.ResultSet;  
7. import java.sql.SQLException;  
8. import java.util.List;  
9. import java.util.Properties;  
10.   
11. import org.apache.ibatis.executor.parameter.DefaultParameterHandler;  
12. import org.apache.ibatis.executor.parameter.ParameterHandler;  
13. import org.apache.ibatis.executor.statement.RoutingStatementHandler;  
14. import org.apache.ibatis.executor.statement.StatementHandler;  
15. import org.apache.ibatis.mapping.BoundSql;  
16. import org.apache.ibatis.mapping.MappedStatement;  
17. import org.apache.ibatis.mapping.ParameterMapping;  
18. import org.apache.ibatis.plugin.Interceptor;  
19. import org.apache.ibatis.plugin.Intercepts;  
20. import org.apache.ibatis.plugin.Invocation;  
21. import org.apache.ibatis.plugin.Plugin;  
22. import org.apache.ibatis.plugin.Signature;  
23.   
24. /** 
25.  *  
26.  * 分页拦截器，用于拦截需要进行分页查询的操作，然后对其进行分页处理。 利用拦截器实现Mybatis分页的原理： 
27.  * 要利用JDBC对数据库进行操作就必须要有一个对应的Statement对象 
28.  * ，Mybatis在执行Sql语句前就会产生一个包含Sql语句的Statement对象，而且对应的Sql语句 
29.  * 是在Statement之前产生的，所以我们就可以在它生成Statement之前对用来生成Statement的Sql语句下手 
30.  * 。在Mybatis中Statement语句是通过RoutingStatementHandler对象的 
31.  * prepare方法生成的。所以利用拦截器实现Mybatis分页的一个思路就是拦截StatementHandler接口的prepare方法 
32.  * ，然后在拦截器方法中把Sql语句改成对应的分页查询Sql语句，之后再调用 
33.  * StatementHandler对象的prepare方法，即调用invocation.proceed()。 
34.  * 对于分页而言，在拦截器里面我们还需要做的一个操作就是统计满足当前条件的记录一共有多少 
35.  * ，这是通过获取到了原始的Sql语句后，把它改为对应的统计语句再利用Mybatis封装好的参数和设 
36.  * 置参数的功能把Sql语句中的参数进行替换，之后再执行查询记录数的Sql语句进行总记录数的统计。 
37.  *  
38.  */  
39. @Intercepts({ @Signature(method = "prepare", type = StatementHandler.class, args = { Connection.class }) })  
40. public class PageInterceptor implements Interceptor {  
41.   
42.     private String databaseType;// 数据库类型，不同的数据库有不同的分页方法  
43.   
44.     /** 
45.      * 拦截后要执行的方法 
46.      */  
47.     public Object intercept(Invocation invocation) throws Throwable {  
48.         // 对于StatementHandler其实只有两个实现类，一个是RoutingStatementHandler，另一个是抽象类BaseStatementHandler，  
49.         // BaseStatementHandler有三个子类，分别是SimpleStatementHandler，PreparedStatementHandler和CallableStatementHandler，  
50.         // SimpleStatementHandler是用于处理Statement的，PreparedStatementHandler是处理PreparedStatement的，而CallableStatementHandler是  
51.         // 处理CallableStatement的。Mybatis在进行Sql语句处理的时候都是建立的RoutingStatementHandler，而在RoutingStatementHandler里面拥有一个  
52.         // StatementHandler类型的delegate属性，RoutingStatementHandler会依据Statement的不同建立对应的BaseStatementHandler，即SimpleStatementHandler、  
53.         // PreparedStatementHandler或CallableStatementHandler，在RoutingStatementHandler里面所有StatementHandler接口方法的实现都是调用的delegate对应的方法。  
54.         // 我们在PageInterceptor类上已经用@Signature标记了该Interceptor只拦截StatementHandler接口的prepare方法，又因为Mybatis只有在建立RoutingStatementHandler的时候  
55.         // 是通过Interceptor的plugin方法进行包裹的，所以我们这里拦截到的目标对象肯定是RoutingStatementHandler对象。  
56.         RoutingStatementHandler handler = (RoutingStatementHandler) invocation.getTarget();  
57.         // 通过反射获取到当前RoutingStatementHandler对象的delegate属性  
58.         StatementHandler delegate = (StatementHandler) ReflectUtil.getFieldValue(handler, "delegate");  
59.         // 获取到当前StatementHandler的  
60.         // boundSql，这里不管是调用handler.getBoundSql()还是直接调用delegate.getBoundSql()结果是一样的，因为之前已经说过了  
61.         // RoutingStatementHandler实现的所有StatementHandler接口方法里面都是调用的delegate对应的方法。  
62.         BoundSql boundSql = delegate.getBoundSql();  
63.         // 拿到当前绑定Sql的参数对象，就是我们在调用对应的Mapper映射语句时所传入的参数对象  
64.         Object obj = boundSql.getParameterObject();  
65.         // 这里我们简单的通过传入的是Page对象就认定它是需要进行分页操作的。  
66.         if (obj instanceof Page<?>) {  
67.             Page<?> page = (Page<?>) obj;  
68.             // 通过反射获取delegate父类BaseStatementHandler的mappedStatement属性  
69.             MappedStatement mappedStatement = (MappedStatement) ReflectUtil.getFieldValue(delegate, "mappedStatement");  
70.             // 拦截到的prepare方法参数是一个Connection对象  
71.             Connection connection = (Connection) invocation.getArgs()[0];  
72.             // 获取当前要执行的Sql语句，也就是我们直接在Mapper映射语句中写的Sql语句  
73.             String sql = boundSql.getSql();  
74.             // 给当前的page参数对象设置总记录数  
75.             this.setTotalRecord(page, mappedStatement, connection);  
76.             // 获取分页Sql语句  
77.             String pageSql = this.getPageSql(page, sql);  
78.             // 利用反射设置当前BoundSql对应的sql属性为我们建立好的分页Sql语句  
79.             ReflectUtil.setFieldValue(boundSql, "sql", pageSql);  
80.         }  
81.           
82.         return invocation.proceed();  
83.     }  
84.   
85.     /** 
86.      * 拦截器对应的封装原始对象的方法 
87.      */  
88.     public Object plugin(Object target) {  
89.         return Plugin.wrap(target, this);  
90.     }  
91.   
92.     /** 
93.      * 设置注册拦截器时设定的属性 
94.      * 该方法，会在配置文件加载前执行 
95.      */  
96.     public void setProperties(Properties properties) {  
97.         this.databaseType = properties.getProperty("databaseType") == null ? "oracle" : properties.getProperty("databaseType");  
98.     }  
99.   
100.     /** 
101.      * 根据page对象获取对应的分页查询Sql语句，这里只做了两种数据库类型，Mysql和Oracle 其它的数据库都 没有进行分页 
102.      *  
103.      * @param page 
104.      *            分页对象 
105.      * @param sql 
106.      *            原sql语句 
107.      * @return 
108.      */  
109.     private String getPageSql(Page<?> page, String sql) {  
110.         StringBuffer sqlBuffer = new StringBuffer(sql);  
111.           
112.         if ("mysql".equalsIgnoreCase(databaseType)) {  
113.             return getMysqlPageSql(page, sqlBuffer);  
114.         } else if ("oracle".equalsIgnoreCase(databaseType)) {  
115.             return getOraclePageSql(page, sqlBuffer);  
116.         }  
117.         return sqlBuffer.toString();  
118.     }  
119.   
120.     /** 
121.      * 获取Mysql数据库的分页查询语句 
122.      *  
123.      * @param page 
124.      *            分页对象 
125.      * @param sqlBuffer 
126.      *            包含原sql语句的StringBuffer对象 
127.      * @return Mysql数据库分页语句 
128.      */  
129.     private String getMysqlPageSql(Page<?> page, StringBuffer sqlBuffer) {  
130.         // 计算第一条记录的位置，Mysql中记录的位置是从0开始的。  
131.         int offset = (page.getStart() - 1) * page.getPageSize();  
132.         sqlBuffer.append(" limit ").append(offset).append(",").append(page.getPageSize());  
133.         return sqlBuffer.toString();  
134.     }  
135.   
136.     /** 
137.      * 获取Oracle数据库的分页查询语句 
138.      *  
139.      * @param page 
140.      *            分页对象 
141.      * @param sqlBuffer 
142.      *            包含原sql语句的StringBuffer对象 
143.      * @return Oracle数据库的分页查询语句 
144.      */  
145.     private String getOraclePageSql(Page<?> page, StringBuffer sqlBuffer) {  
146.         // 计算第一条记录的位置，Oracle分页是通过rownum进行的，而rownum是从1开始的  
147.         int offset = (page.getStart() - 1) * page.getPageSize() + 1;  
148.         sqlBuffer.insert(0, "select u.*, rownum r from (").append(") u where rownum < ")  
149.                 .append(offset + page.getPageSize());  
150.         sqlBuffer.insert(0, "select * from (").append(") where r >= ").append(offset);  
151.         // 上面的Sql语句拼接之后大概是这个样子：  
152.         // select * from (select u.*, rownum r from (select * from t_user) u  
153.         // where rownum < 31) where r >= 16  
154.         return sqlBuffer.toString();  
155.     }  
156.   
157.     /** 
158.      * 给当前的参数对象page设置总记录数 
159.      *  
160.      * @param page 
161.      *            Mapper映射语句对应的参数对象 
162.      * @param mappedStatement 
163.      *            Mapper映射语句 
164.      * @param connection 
165.      *            当前的数据库连接 
166.      */  
167.     private void setTotalRecord(Page<?> page, MappedStatement mappedStatement, Connection connection) {  
168.         // 获取对应的BoundSql，这个BoundSql其实跟我们利用StatementHandler获取到的BoundSql是同一个对象。  
169.         // delegate里面的boundSql也是通过mappedStatement.getBoundSql(paramObj)方法获取到的。  
170.         BoundSql boundSql = mappedStatement.getBoundSql(page);  
171.         // 获取到我们自己写在Mapper映射语句中对应的Sql语句  
172.         String sql = boundSql.getSql();  
173.         // 通过查询Sql语句获取到对应的计算总记录数的sql语句  
174.         String countSql = this.getCountSql(sql);  
175.         // 通过BoundSql获取对应的参数映射  
176.         List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();  
177.         // 利用Configuration、查询记录数的Sql语句countSql、参数映射关系parameterMappings和参数对象page建立查询记录数对应的BoundSql对象。  
178.         BoundSql countBoundSql = new BoundSql(mappedStatement.getConfiguration(), countSql, parameterMappings, page);  
179.         // 通过mappedStatement、参数对象page和BoundSql对象countBoundSql建立一个用于设定参数的ParameterHandler对象  
180.         ParameterHandler parameterHandler = new DefaultParameterHandler(mappedStatement, page, countBoundSql);  
181.         // 通过connection建立一个countSql对应的PreparedStatement对象。  
182.         PreparedStatement pstmt = null;  
183.         ResultSet rs = null;  
184.         try {  
185.             pstmt = connection.prepareStatement(countSql);  
186.             // 通过parameterHandler给PreparedStatement对象设置参数  
187.             parameterHandler.setParameters(pstmt);  
188.             // 之后就是执行获取总记录数的Sql语句和获取结果了。  
189.             rs = pstmt.executeQuery();  
190.             if (rs.next()) {  
191.                 int totalRecord = rs.getInt(1);  
192.                 // 给当前的参数page对象设置总记录数  
193.                 page.setTotalRecord(totalRecord);  
194.             }  
195.         } catch (SQLException e) {  
196.             e.printStackTrace();  
197.         } finally {  
198.             try {  
199.                 if (rs != null)  
200.                     rs.close();  
201.                 if (pstmt != null)  
202.                     pstmt.close();  
203.             } catch (SQLException e) {  
204.                 e.printStackTrace();  
205.             }  
206.         }  
207.     }  
208.   
209.     /** 
210.      * 根据原Sql语句获取对应的查询总记录数的Sql语句 
211.      *  
212.      * @param sql 
213.      * @return 
214.      */  
215.     private String getCountSql(String sql) {  
216.         int index = sql.toUpperCase().indexOf("FROM");  
217.           
218.         return "select count(*) " + sql.substring(index);  
219.     }  
220.   
221.     /** 
222.      * 利用反射进行操作的一个工具类 
223.      *  
224.      */  
225.     private static class ReflectUtil {  
226.         /** 
227.          * 利用反射获取指定对象的指定属性 
228.          *  
229.          * @param obj 
230.          *            目标对象 
231.          * @param fieldName 
232.          *            目标属性 
233.          * @return 目标属性的值 
234.          */  
235.         public static Object getFieldValue(Object obj, String fieldName) {  
236.             Object result = null;  
237.             Field field = ReflectUtil.getField(obj, fieldName);  
238.             if (field != null) {  
239.                 field.setAccessible(true);  
240.                 try {  
241.                     result = field.get(obj);  
242.                 } catch (IllegalArgumentException e) {  
243.                     e.printStackTrace();  
244.                 } catch (IllegalAccessException e) {  
245.                     e.printStackTrace();  
246.                 }  
247.             }  
248.             return result;  
249.         }  
250.   
251.         /** 
252.          * 利用反射获取指定对象里面的指定属性 
253.          *  
254.          * @param obj 
255.          *            目标对象 
256.          * @param fieldName 
257.          *            目标属性 
258.          * @return 目标字段 
259.          */  
260.         private static Field getField(Object obj, String fieldName) {  
261.             Field field = null;  
262.             for (Class<?> clazz = obj.getClass(); clazz != Object.class; clazz = clazz.getSuperclass()) {  
263.                 try {  
264.                     field = clazz.getDeclaredField(fieldName);  
265.                     break;  
266.                 } catch (NoSuchFieldException e) {  
267.                     // 这里不用做处理，子类没有该字段可能对应的父类有，都没有就返回null。  
268.                 }  
269.             }  
270.             return field;  
271.         }  
272.   
273.         /** 
274.          * 利用反射设置指定对象的指定属性为指定的值 
275.          *  
276.          * @param obj 
277.          *            目标对象 
278.          * @param fieldName 
279.          *            目标属性 
280.          * @param fieldValue 
281.          *            目标值 
282.          */  
283.         public static void setFieldValue(Object obj, String fieldName, String fieldValue) {  
284.             Field field = ReflectUtil.getField(obj, fieldName);  
285.             if (field != null) {  
286.                 try {  
287.                     field.setAccessible(true);  
288.                     field.set(obj, fieldValue);  
289.                 } catch (IllegalArgumentException e) {  
290.                     e.printStackTrace();  
291.                 } catch (IllegalAccessException e) {  
292.                     e.printStackTrace();  
293.                 }  
294.             }  
295.         }  
296.     }  
297.   
298. }  

4.配置文件

[html]  view plain copy

1. <?xml version="1.0" encoding="UTF-8" ?>  
2.   
3. <!DOCTYPE configuration  
4.   PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  
5.   "http://mybatis.org/dtd/mybatis-3-config.dtd">  
6.       
7. <configuration>  
8.   
9.     <!-- 配置数据库分页的实现 -->  
10.     <properties>    
11.         <property name="dialect" value="oracle" />   
12.         <property name="databaseType" value="oracle"></property>   
13.     </properties>    
14.         
15.     <!-- 全局别名设置，在映射文件中只需写别名，而不必写出整个类路径  -->  
16.     <typeAliases>    
17.          <typeAlias type="org.ygy.demo.mybatis.entity.PersonEntity" alias="PersonEntity"></typeAlias>  
18.          <typeAlias type="org.ygy.demo.mybatis.entity.BlogEntity" alias="BlogEntity"></typeAlias>  
19.     </typeAliases>   
20.       
21.     <!-- 配置插件 -->  
22.     <plugins>  
23.         <!-- 配置拦截器插件 -->  
24.        <!--  <plugin interceptor="org.ygy.demo.mybatis.page.dialect.PageInterceptor"></plugin>  
25.         <plugin interceptor="org.ygy.demo.mybatis.interceptor.SimpleInterceptor"></plugin> -->  
26.         <plugin interceptor="org.ygy.demo.mybatis.interceptor.PageInterceptor"></plugin>    
27.     </plugins>    
28.       
29.     <environments default="development">  
30.         <environment id="development">  
31.             <transactionManager type="JDBC" />  
32.             <dataSource type="POOLED">  
33.                 <property name="driver" value="oracle.jdbc.OracleDriver" />  
34.                 <property name="url" value="jdbc:oracle:thin:@192.168.17.254:1521:dpweb" />  
35.                 <property name="username" value="dptest" />  
36.                 <property name="password" value="dptest" />  
37.             </dataSource>  
38.         </environment>  
39.     </environments>  
40.   
41.     <!-- 配置映射文件地址 -->  
42.     <mappers>  
43.          <mapper resource="org/ygy/demo/mybatis/mapper/blog-mapper.xml"></mapper>  
44.     </mappers>  
45.       
46. </configuration>  

log4j.properties

[java]  view plain copy

1. # Global logging configuration  
2. log4j.rootLogger=DEBUG, stdout  
3.   
4. # MyBatis logging configuration...  
5. log4j.logger.org.ygy.demo.mybatis=DEBUG  
6.   
7. # Console output...  
8. log4j.appender.stdout=org.apache.log4j.ConsoleAppender  
9. log4j.appender.stdout.layout=org.apache.log4j.PatternLayout  
10. log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n  
11.   
12. #log4j.logger.com.abc.mapper=DEBUG  

blog-mapper.xml

[html]  view plain copy

1. <?xml version="1.0" encoding="UTF-8" ?>  
2. <!DOCTYPE mapper  
3.   PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  
4.   "http://mybatis.org/dtd/mybatis-3-mapper.dtd">   
5.   
6. <mapper namespace="org.ygy.demo.mybatis.dao.BlogDao">  
7.       
8.     <resultMap type="BlogEntity" id="blogMap">  
9.         <result column="blogId" property="id"/>  
10.         <result column="blogTitle" property="title"></result>  
11.         <result column="blogContent" property="content"></result>  
12.           
13.         <!-- 即has-a的关系 -->  
14.         <association property="owner" javaType="PersonEntity">  
15.             <result column="blogOwnerId" property="id"/>  
16.             <result column="blogOwnerName" property="name"></result>  
17.         </association>  
18.     </resultMap>  
19.       
20.     <select id="queryAll" resultMap="blogMap">  
21.         SELECT BLOG.ID blogId , BLOG.TITLE blogTitle , BLOG.CONTENT blogContent , PERSON.ID blogOwnerId , PERSON.NAME blogOwnerName  
22.         FROM T_YGY_DEMO_BLOG BLOG INNER JOIN T_YGY_DEMO_PERSON PERSON ON BLOG.OWNERID = PERSON.ID  
23.     </select>  
24.       
25.     <insert id="add" parameterType="BlogEntity">  
26.         INSERT INTO T_YGY_DEMO_BLOG(ID , TITLE , CONTENT , OWNERID)  
27.         VALUES(#{id} , #{title} , #{content} , #{owner.id})  
28.     </insert>  
29.       
30.     <select id="queryWithPage" parameterType="org.apache.ibatis.session.RowBounds" resultMap="blogMap">  
31.         SELECT BLOG.ID blogId , BLOG.TITLE blogTitle , BLOG.CONTENT blogContent , PERSON.ID blogOwnerId , PERSON.NAME blogOwnerName  
32.         FROM T_YGY_DEMO_BLOG BLOG INNER JOIN T_YGY_DEMO_PERSON PERSON   
33.         ON BLOG.OWNERID = PERSON.ID  
34.         ORDER BY BLOG.ID  
35.     </select>  
36.       
37.     <select id="queryWithPage2" parameterType="org.ygy.demo.mybatis.interceptor.Page" resultMap="blogMap">  
38.         SELECT BLOG.ID blogId , BLOG.TITLE blogTitle , BLOG.CONTENT blogContent , PERSON.ID blogOwnerId , PERSON.NAME blogOwnerName  
39.         FROM T_YGY_DEMO_BLOG BLOG INNER JOIN T_YGY_DEMO_PERSON PERSON   
40.         ON BLOG.OWNERID = PERSON.ID  
41.         ORDER BY BLOG.ID  
42.     </select>  
43. </mapper>   

BlogDao.java

[java]  view plain copy

1. package org.ygy.demo.mybatis.dao.impl;  
2.   
3. import java.util.List;  
4.   
5. import org.apache.ibatis.session.RowBounds;  
6. import org.apache.ibatis.session.SqlSession;  
7. import org.ygy.demo.mybatis.common.util.MyBatisUtil;  
8. import org.ygy.demo.mybatis.dao.IBlogDao;  
9. import org.ygy.demo.mybatis.entity.BlogEntity;  
10. import org.ygy.demo.mybatis.interceptor.Page;  
11.   
12. public class BlogDao implements IBlogDao {  
13.     private static final String NAMESPACE = "org.ygy.demo.mybatis.dao.BlogDao";  
14.   
15.     @Override  
16.     public int add(BlogEntity blog) {  
17.         SqlSession session = MyBatisUtil.getSession();  
18.         int affectCount = session.insert(NAMESPACE + ".add" , blog);  
19.           
20.         session.commit();  
21.         session.close();  
22.           
23.         return affectCount;  
24.     }  
25.   
26.     @Override  
27.     public List<BlogEntity> queryAll() {  
28.         SqlSession session = MyBatisUtil.getSession();  
29.         List<BlogEntity> blogs = session.selectList(NAMESPACE + ".queryAll");  
30.           
31.         session.close();  
32.           
33.         return blogs;  
34.     }  
35.   
36.     @Override  
37.     public List<BlogEntity> queryWithPage(RowBounds rowBounds) {  
38.         SqlSession session = MyBatisUtil.getSession();  
39.         List<BlogEntity> blogs = session.selectList(NAMESPACE + ".queryWithPage" , null , rowBounds);  
40.           
41.         session.commit();  
42.         session.close();  
43.           
44.         return blogs;  
45.     }  
46.   
47.     @Override  
48.     public List<BlogEntity> queryAll(Page<BlogEntity> page) {  
49.         SqlSession session = MyBatisUtil.getSession();  
50.           
51.         List<BlogEntity> blogs = session.selectList(NAMESPACE + ".queryWithPage2" , page);  
52.           
53.         session.close();  
54.           
55.         return blogs;  
56.     }  
57.   
58. }  

5.测试

[java]  view plain copy

1. @Test  
2.     public void testQueryWithPage2() {  
3.         Page<BlogEntity> page = new Page<BlogEntity>();  
4.         page.setStart(1);  
5.         page.setPageSize(1);  
6.           
7.         List<BlogEntity> blogs = blogDao.queryAll(page);  
8.         for(BlogEntity blog : blogs) {  
9.             System.out.println("--blog:" + blog);  
10.         }  
11.           
12.         System.out.println("totalPage->" + page.getTotalPage());  
13.         System.out.println("totalRecord->" + page.getTotalRecord());  
14.     }  

好了，其实这里的实现，我现在也不是非常的明白，慢慢理解中......