Varias formas de escribir paginación en MyBatis-Plus

Introducción

MyBatis-Plus (se abre en ventana nueva) (MP para abreviar) es unaherramienta de mejora para MyBatis (se abre en ventana nueva) Sobre la base de MyBatis, solo se realizan mejoras sin cambios, y nació para simplificar el desarrollo y mejorar la eficiencia.

característica

• Sin intrusión : solo mejora y sin cambios, la introducción no afectará el proyecto existente, tan suave como la seda.

• Baja pérdida : el CURD básico se inyectará automáticamente cuando se inicie, el rendimiento es básicamente sin pérdidas y la operación orientada a objetos se realiza directamente

• Potentes operaciones CRUD : mapeador general y servicio general incorporados, la mayoría de las operaciones CRUD en una sola tabla se pueden realizar con solo una pequeña cantidad de configuración, y hay un potente constructor de condiciones para satisfacer diversas necesidades de uso

• Admite llamada de formulario Lambda : a través de expresiones Lambda, es conveniente escribir varias condiciones de consulta, sin necesidad de preocuparse por los errores tipográficos de campo

• Admite la generación automática de claves principales : admite hasta 4 estrategias de claves principales (incluido un generador de ID único distribuido - Secuencia), que se pueden configurar libremente para resolver perfectamente el problema de la clave principal

• Admite el modo ActiveRecord : admite la llamada de formulario ActiveRecord, la clase de entidad solo necesita heredar la clase Model para realizar potentes operaciones CRUD

• Admite operaciones generales globales personalizadas : admite inyección de método general global (escribir una vez, usar en cualquier lugar)

• Generador de código incorporado : use el código o el complemento Maven para generar rápidamente código de capa de mapeador, modelo, servicio, controlador, motor de plantilla de soporte y más configuraciones personalizadas que están esperando que las use

• Complemento de paginación incorporado : basado en la paginación física de MyBatis, los desarrolladores no necesitan preocuparse por operaciones específicas. Después de configurar el complemento, escribir paginación es equivalente a una consulta de lista normal.

• El complemento de paginación admite múltiples bases de datos : admite MySQL, MariaDB, Oracle, DB2, H2, HSQL, SQLite, Postgre, SQLServer y otras bases de datos

• Complemento de análisis de rendimiento incorporado : puede generar declaraciones SQL y su tiempo de ejecución. Se recomienda habilitar esta función durante el desarrollo y las pruebas, que pueden descubrir rápidamente las consultas lentas.

• Complemento de intercepción global incorporado : proporciona análisis inteligente y bloqueo de operaciones de eliminación y actualización en toda la tabla, y también puede personalizar las reglas de intercepción para evitar operaciones incorrectas

base de datos de soporte

Cualquier base de datos que pueda usar MyBatis para CRUD y admita SQL estándar, el soporte específico es el siguiente, si no está en la lista a continuación, consulte la parte de paginación del tutorial PR para su soporte.

• MySQL, Oracle, DB2, H2, HSQL, SQLite, PostgreSQL, SQLServer, Phoenix, Gauss, ClickHouse, Sybase, OceanBase, Firebird, Cubrid, Goldilocks, csiidb, informix, TEngine, redshift

• Base de datos Dameng, Base de datos Xugu, Base de datos Jincang de la Universidad Renmin, Base de datos general Nanda (Huaku), Base de datos general Nanda, Base de datos Shentong, Base de datos Hangao, Base de datos Youxuan

Inicio rápido

agregar dependencias

La nueva versión MyBatis-Plus 3.0 está basada en JDK8 y proporciona llamadas lambda, por lo que los requisitos para instalar e integrar MP3.0 son los siguientes:

• JDK 8+

• Maven o Gradle

Proyecto Spring Boot

experto:

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>最新版本</version>
</dependency>

proyecto de primavera

experto:

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus</artifactId>
    <version>最新版本</version>
</dependency>

configuración

Agregue la configuración relevante de la base de datos H2 en el archivo de configuración application.yml:

# DataSource Config
spring:
  datasource:
    driver-class-name: org.h2.Driver
    schema: classpath:db/schema-h2.sql
    username: root
    password: test
  sql:
    init:
      schema-locations: classpath:db/schema-h2.sql
      data-locations: classpath:db/data-h2.sql

Agregue la anotación @MapperScan a la clase de inicio Spring Boot para escanear la carpeta Mapper:

@SpringBootApplication
@MapperScan("com.baomidou.mybatisplus.samples.quickstart.mapper")
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

}

Paginas

método uno:

Utilice la interfaz de la página de servicio de mybatis-plus

---

    @GetMapping("/pageList")
    @ApiOperation(value = "分页列表", notes = "query和user")
    public R<IPage<User>> pageList(@ApiIgnore User user, Query query) {
        //无条件分页
        IPage<User> pages = userService.page(Condition.getPage(query));
        //有条件分页
        IPage<User> pages = userService.page(Condition.getPage(query), Wrappers.lambdaQuery(user));
        return R.data(pages);
    }

Método 2:

Paginación sql personalizada

---

Código de la capa del controlador:

    @GetMapping("/pageList")
   @ApiOperation(value = "分页列表", notes = "query和user")
    public R<IPage<User>> pageList(@ApiIgnore User user, Query query) {
        IPage<User> pages = userService.selectUserPage(Condition.getPage(query), user);
        return R.data(pages);
    }

Llame al método asignador sql de paginación personalizado en el servicio

  @Override
    public IPage<User> selectUserPage(IPage<User> page, User user) {
        return page.setRecords(baseMapper.selectUserPage(page, user));
    }

Defina la interfaz de paginación del mapeador:

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.gis.spacedata.bladex.domain.entity.system.User;
import org.apache.ibatis.annotations.Param;

import java.util.List;

import java.util.List;

public interface UserMapper extends BaseMapper<User> {

    List<User> selectUserPage(IPage<User> page, @Param("user") User user);

}

mybatisxml:

    <select id="selectUserPage" resultMap="userResultMap">
        select * from blade_user where is_deleted = 0
        <if test="user.tenantId!=null and user.tenantId != ''">
            and tenant_id = #{user.tenantId}
        </if>
        <if test="user.account!=null and user.account != ''">
            and account like CONCAT('%',#{user.account},'%')
        </if>
        <if test="user.realName!=null and user.realName != ''">
            and real_name like CONCAT('%',#{user.realName},'%')
        </if>
        <if test="user.roleId!=null and user.roleId != ''">
            and CAST(#{user.roleId} AS VARCHAR)= ANY(STRING_TO_ARRAY(role_id, ','))
        </if>
        ORDER BY id
    </select>

Clase de herramienta de condición:

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.springblade.core.launch.constant.TokenConstant;
import org.springblade.core.tool.support.Kv;
import org.springblade.core.tool.utils.BeanUtil;
import org.springblade.core.tool.utils.Func;

import java.util.Map;

/**
 * 分页工具
 *
 * @author Chill
 */
public class Condition {

    /**
     * 转化成mybatis plus中的Page
     *
     * @param query 查询条件
     * @return IPage
     */
    public static <T> IPage<T> getPage(Query query) {
        Page<T> page = new Page<>(Func.toInt(query.getCurrent(), 1), Func.toInt(query.getSize(), 10));
        page.setAsc(Func.toStrArray(SqlKeyword.filter(query.getAscs())));
        page.setDesc(Func.toStrArray(SqlKeyword.filter(query.getDescs())));
        return page;
    }

    /**
     * 获取mybatis plus中的QueryWrapper
     *
     * @param entity 实体
     * @param <T>    类型
     * @return QueryWrapper
     */
    public static <T> QueryWrapper<T> getQueryWrapper(T entity) {
        return new QueryWrapper<>(entity);
    }

    /**
     * 获取mybatis plus中的QueryWrapper
     *
     * @param query 查询条件
     * @param clazz 实体类
     * @param <T>   类型
     * @return QueryWrapper
     */
    public static <T> QueryWrapper<T> getQueryWrapper(Map<String, Object> query, Class<T> clazz) {
        Kv exclude = Kv.create().set(TokenConstant.HEADER, TokenConstant.HEADER)
            .set("current", "current").set("size", "size").set("ascs", "ascs").set("descs", "descs");
        return getQueryWrapper(query, exclude, clazz);
    }

    /**
     * 获取mybatis plus中的QueryWrapper
     *
     * @param query   查询条件
     * @param exclude 排除的查询条件
     * @param clazz   实体类
     * @param <T>     类型
     * @return QueryWrapper
     */
    public static <T> QueryWrapper<T> getQueryWrapper(Map<String, Object> query, Map<String, Object> exclude, Class<T> clazz) {
        exclude.forEach((k, v) -> query.remove(k));
        QueryWrapper<T> qw = new QueryWrapper<>();
        qw.setEntity(BeanUtil.newInstance(clazz));
        SqlKeyword.buildCondition(query, qw);
        return qw;
    }

}

Método 3:

Clase Db usando mybatis-plus

ilustrar:

• Use el método de llamada estática para ejecutar el método CRUD, evite la inyección del ciclo de servicio en el entorno Spring, simplifique el código y mejore la eficiencia

• BaseMapper que debe inyectarse en la entidad correspondiente en el proyecto

• Vea el método de uso completo: caso de prueba (se abre en una ventana nueva)

• Para el parámetro Wrapper, se debe pasar Entity o EntityClass en Wrapper para encontrar el Mapper correspondiente

• No se recomienda llamarlo en un bucle. Si se guarda en lotes, se recomienda usar Db.saveBatch(data) para guardar los datos después de construirlos.

---

    @Test
    void testPage() {
        IPage<Entity> page = Db.page(new Page<>(1, 1), Entity.class);
        Assertions.assertEquals(2, page.getTotal());
        page = Db.page(new Page<>(1, 1), Wrappers.lambdaQuery(Entity.class));
        Assertions.assertEquals(1, page.getRecords().size());
    }

Complemento de paginación de página

Lo extraño es que los datos que consulta siguen siendo todos los datos y no logra nuestro efecto de paginación.

Todos sabemos que el principio de paginación es donde límite?,?

Es decir, solo agregue la condición where después de esta declaración de consulta, podemos interceptar esta declaración y agregarle nuestra condición where, que también es el retiro de la idea AOP (solo mejora el código original, sin modificación)

Cuerpo del complemento MybatisPlusInterceptor

Este complemento es un complemento central, que actualmente representa los métodos Executor#query, Executor#update y StatementHandler#prepare.

Interceptor interno

Los complementos que proporcionamos implementarán funciones basadas en esta interfaz

Funciones disponibles actualmente:

• Paginación automática: PaginationInnerInterceptor

• Tenencia múltiple: TenantLineInnerInterceptor

• Nombre de la tabla dinámica: DynamicTableNameInnerInterceptor

• Cerradura optimista: OptimisticLockerInnerInterceptor

• Propiedades SQL: IllegalSQLInnerInterceptor

• Impedir la actualización y eliminación de tablas completas: BlockAttackInnerInterceptor

Configuración del complemento de paginación

Transacción Spring, complemento de paginación MybatisPlus, escaneo de paquetes Mybatis y otras configuraciones

import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;

/**
 * spring事务、MybatisPlus分页插件、mybatis包扫描等配置
 *
 * @author tarzan liu
 * @since JDK1.8
 * @date 2021年5月11日
 */
@EnableTransactionManagement
@Configuration
@MapperScan(basePackages = "com.tarzan.**.mapper")
public class MybatisPlusConfig {

    /**
     * 分页插件
     */
    @Bean
    public MybatisPlusInterceptor paginationInterceptor() {
        PaginationInnerInterceptor paginationInnerInterceptor = new PaginationInnerInterceptor();
        paginationInnerInterceptor.setMaxLimit(-1L);
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        mybatisPlusInterceptor.addInnerInterceptor(paginationInnerInterceptor);
        return mybatisPlusInterceptor;
    }
}

En el código, paginationInnerInterceptor.setMaxLimit(-1L); significa que no hay límite en el número máximo de páginas. De forma predeterminada, el límite máximo es de 500 datos por página.