Hay varias formas de implementar la paginación en el marco mybatis. La más simple es usar la palabra clave SQL nativa limit para implementarla. Otra es usar interceptor para empalmar SQL para lograr la misma función que limit. La tercera es usar PageHelper para implementarlo. Aquí hay tres métodos de implementación comunes:
No importa qué método de implementación se utilice, el resultado que devolvemos ya no puede usar Lista y requiere un buscapersonas de objeto personalizado.
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;
}
}
limitar la implementación de palabras clave:
UserDao.java agrega dos métodos
public List<User> findByPager(Map<String, Object> params);
public long count();Agregue dos consultas a 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>Agregar método de paginación en 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;
}Este es el método de implementación más intuitivo y también es el método más simple que se puede implementar fácilmente sin complementos ni herramientas.
Implementación del complemento interceptor:
Necesita definir una clase para implementar la interfaz Interceptor
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");
}
}
Anteriormente pasamos dos parámetros para limitar en el método de servicio findByPager y la página se calculó. No es necesario calcular usando el interceptor aquí:
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;
}En la configuración de primavera, agregue la configuración del complemento:
En este punto, es posible que haya adivinado que MyPageInterceptor en realidad actúa como un interceptor. Cuando el programa ejecuta el método findByPager, agregará un límite de página y tamaño a la declaración. Sigue siendo la misma que la primera idea de implementación nativa, así que aquí Es necesario eliminar la parte límite #{page}, #{size} de la declaración correspondiente a la consulta findByPager en el archivo de configuración UserMapper.xml y cambiarla a lo siguiente:
En este punto, la función de paginación también se implementa a través del complemento interceptor.
Implementación de PageHelper:
Implementar de esta manera requiere que introduzcamos dependencias de Maven.
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>4.2.1</version>
</dependency>Realice algunas modificaciones en el archivo de configuración spring.xml:
<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> Método de capa de servicio, realice algunas modificaciones:
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;
}Hasta ahora, también se ha implementado el método de la herramienta PageHelper para implementar la paginación. De hecho, el método PageHelper también es una implementación de terceros del segundo método interceptor Interceptor y nos ayuda internamente a implementar la función Interceptor. Por tanto, no necesitamos personalizar la clase MyPageInterceptor. De hecho, al ejecutar el método de consulta, intercepte y luego configure los parámetros de paginación. Por lo tanto, la oración PageHelper.startPage (página, tamaño) debe llamarse explícitamente y luego ejecutar userDao.findAll (). Al consultar toda la información del usuario, se realizará una configuración de parámetros de paginación para que los resultados devueltos sean solo resultados de paginación. No todo está listo.