There are several ways to implement paging in the mybatis framework. The simplest one is to use the native SQL keyword limit to implement it. Another one is to use interceptor to splice SQL to achieve the same function as limit. The third one is to use PageHelper to implement it. Here are three common implementation methods:
No matter which implementation method is used, the result we return can no longer use List and requires a custom object Pager.
package com.xxx.mybatis.bean;
import java.util.List;
public class Pager<T> {
private int page;//分页起始页
private int size;//每页记录数
private List<T> rows;//返回的记录集合
private long total;//总记录条数
public int getPage() {
return page;
}
public void setPage(int page) {
this.page = page;
}
public int getSize() {
return size;
}
public void setSize(int size) {
this.size = size;
}
public List<T> getRows() {
return rows;
}
public void setRows(List<T> rows) {
this.rows = rows;
}
public long getTotal() {
return total;
}
public void setTotal(long total) {
this.total = total;
}
}
limit keyword implementation:
UserDao.java adds two methods
public List<User> findByPager(Map<String, Object> params);
public long count();Add two queries to UserMapper.xml
<select id="findByPager" resultType="com.xxx.mybatis.domain.User">
select * from xx_user limit #{page},#{size}
</select>
<select id="count" resultType="long">
select count(1) from xx_user
</select>Add paging method in UserService.java
public Pager<User> findByPager(int page,int size){
Map<String, Object> params = new HashMap<String, Object>();
params.put("page", (page-1)*size);
params.put("size", size);
Pager<User> pager = new Pager<User>();
List<User> list = userDao.findByPager(params);
pager.setRows(list);
pager.setTotal(userDao.count());
return pager;
}This is the most intuitive implementation method, and it is also the simplest method that can be easily implemented without any plug-ins or tools.
interceptor plugin implementation:
You need to define a class to implement the Interceptor interface
MyPageInterceptor.java
package com.xxx.mybatis.bean;
import java.sql.Connection;
import java.util.Map;
import java.util.Properties;
import org.apache.ibatis.executor.parameter.ParameterHandler;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.MappedStatement;
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.reflection.MetaObject;
import org.apache.ibatis.reflection.SystemMetaObject;
@Intercepts({@Signature(type=StatementHandler.class,method="prepare",args={Connection.class,Integer.class})})
public class MyPageInterceptor implements Interceptor {
private int page;
private int size;
@SuppressWarnings("unused")
private String dbType;
@SuppressWarnings("unchecked")
@Override
public Object intercept(Invocation invocation) throws Throwable {
System.out.println("plugin is running...");
StatementHandler statementHandler = (StatementHandler)invocation.getTarget();
MetaObject metaObject = SystemMetaObject.forObject(statementHandler);
while(metaObject.hasGetter("h")){
Object object = metaObject.getValue("h");
metaObject = SystemMetaObject.forObject(object);
}
while(metaObject.hasGetter("target")){
Object object = metaObject.getValue("target");
metaObject = SystemMetaObject.forObject(object);
}
MappedStatement mappedStatement = (MappedStatement)metaObject.getValue("delegate.mappedStatement");
String mapId = mappedStatement.getId();
if(mapId.matches(".+ByPager$")){
ParameterHandler parameterHandler = (ParameterHandler)metaObject.getValue("delegate.parameterHandler");
Map<String, Object> params = (Map<String, Object>)parameterHandler.getParameterObject();
page = (int)params.get("page");
size = (int)params.get("size");
String sql = (String) metaObject.getValue("delegate.boundSql.sql");
sql += " limit "+(page-1)*size +","+size;
metaObject.setValue("delegate.boundSql.sql", sql);
}
return invocation.proceed();
}
@Override
public Object plugin(Object target) {
return Plugin.wrap(target, this);
}
@Override
public void setProperties(Properties properties) {
String limit = properties.getProperty("limit","10");
this.page = Integer.parseInt(limit);
this.dbType = properties.getProperty("dbType", "mysql");
}
}
We previously passed two parameters to limit in the findByPager method of service, and the page was calculated. There is no need to calculate using the interceptor here:
public Pager<User> findByPager(int page,int size){
Map<String, Object> params = new HashMap<String, Object>();
params.put("page", page);
params.put("size", size);
Pager<User> pager = new Pager<User>();
List<User> list = userDao.findByPager(params);
pager.setRows(list);
pager.setTotal(userDao.count());
return pager;
}In the spring configuration, add plugin settings:
At this point, you may have guessed that MyPageInterceptor actually acts as an interceptor. When the program executes the findByPager method, it will add limit page and size splicing to the statement. It is still the same as the first native implementation idea, so here It is necessary to remove the limit #{page}, #{size} part of the statement corresponding to the findByPager query in the UserMapper.xml configuration file and change it to the following:
At this point, the paging function has also been implemented through the interceptor plug-in.
PageHelper implementation:
Implementing this way requires us to introduce maven dependencies.
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>4.2.1</version>
</dependency>Make some modifications to the spring.xml configuration file:
<bean id="pageInterceptor" class="com.github.pagehelper.PageHelper">
<property name="properties">
<props>
<prop key="helperDialect">mysql</prop>
<prop key="reasonable">true</prop>
<prop key="supportMethodsArguments">true</prop>
<prop key="params">count=countSql</prop>
</props>
</property>
</bean>
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="mapperLocations" value="classpath:com/xxx/mybatis/dao/*Mapper.xml"/>
<property name="plugins" ref="pageInterceptor"></property>
</bean> Service layer method, make some modifications:
public Pager<User> findByPager(int page,int size){
Pager<User> pager = new Pager<User>();
Page<User> res = PageHelper.startPage(page,size);
userDao.findAll();
pager.setRows(res.getResult());
pager.setTotal(res.getTotal());
return pager;
}At this point, the PageHelper tool method to implement paging has also been implemented. In fact, the PageHelper method is also a third-party implementation of the second Interceptor interceptor method. It internally helps us implement the Interceptor function. So we don't need to customize the MyPageInterceptor class. In fact, when running the query method, intercept and then set the paging parameters. Therefore, the sentence PageHelper.startPage(page,size) needs to be called explicitly, and then userDao.findAll() is executed. When querying all user information, a paging parameter setting will be performed so that the returned results are only paging results. Not all set.