So implementieren Sie den einfachen Paging-Abfragetest von SpringBoot MP

Das Importieren der neuesten MP-Abhängigkeiten ist der erste Schritt, sonst kann mit zu niedrigen Versionen nichts gemacht werden. Es scheint, dass das Paging-Plugin nicht einmal zu Versionen unter 3.1 hinzugefügt wird, daher verwenden wir die neueste Version 3.5, um sicherzustellen, dass alles funktioniert ist enthalten:

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.2</version>
        </dependency>

Hier müssen wir zwei Plug-Ins kennen: MPs Kern-Plug-In MybatisPlusInterceptor und das automatische Paging-Plug-In PaginationInnerInterceptor.

Der Quellcode von MybatisPlusInterceptor (Entfernen des Zwischenverarbeitungscodes):

public class MybatisPlusInterceptor implements Interceptor {
    private List<InnerInterceptor> interceptors = new ArrayList();
    public MybatisPlusInterceptor() {}
    public Object intercept(Invocation invocation) throws Throwable {}
    public Object plugin(Object target) {}
    public void addInnerInterceptor(InnerInterceptor innerInterceptor) {}
    public List<InnerInterceptor> getInterceptors() {}
    public void setProperties(Properties properties) {}
    public void setInterceptors(final List<InnerInterceptor> interceptors) {}
}

Wir können feststellen, dass es eine private Attributliste List hat und der Elementtyp in dieser verknüpften Liste InnerInterceptor ist.

InnerInterceptor-Quellcode:

public interface InnerInterceptor {
    default boolean willDoQuery(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
        return true;
    }
    default void beforeQuery(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    }
    default boolean willDoUpdate(Executor executor, MappedStatement ms, Object parameter) throws SQLException {
        return true;
    }
    default void beforeUpdate(Executor executor, MappedStatement ms, Object parameter) throws SQLException {
    }
    default void beforePrepare(StatementHandler sh, Connection connection, Integer transactionTimeout) {
    }
    default void beforeGetBoundSql(StatementHandler sh) {
    }
    default void setProperties(Properties properties) {
    }
}

Es ist nicht schwer herauszufinden, dass der Inhalt dieser Schnittstelle grob darin besteht, die Standardattribute festzulegen. Aus Codesicht bietet sie eine gewisse Logik, die vor und nach der Standarddatenbankoperation ausgeführt werden soll Ausführungszeitraum. Wer seine Methode implementiert, erhält eine neue Funktion?

Schauen Sie sich den Quellcode des PaginationInnerInterceptor-Plug-Ins an:

public class PaginationInnerInterceptor implements InnerInterceptor {
    protected static final List<SelectItem> COUNT_SELECT_ITEM = Collections.singletonList((new SelectExpressionItem((new Column()).withColumnName("COUNT(*)"))).withAlias(new Alias("total")));
    protected static final Map<String, MappedStatement> countMsCache = new ConcurrentHashMap();
    protected final Log logger = LogFactory.getLog(this.getClass());
    protected boolean overflow;
    protected Long maxLimit;
    private DbType dbType;
    private IDialect dialect;
    protected boolean optimizeJoin = true;
    public PaginationInnerInterceptor(DbType dbType) {
        this.dbType = dbType;
    }
    public PaginationInnerInterceptor(IDialect dialect) {
        this.dialect = dialect;
    }
    public boolean willDoQuery(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
        IPage<?> page = (IPage)ParameterUtils.findPage(parameter).orElse((Object)null);
        if (page != null && page.getSize() >= 0L && page.searchCount()) {
            MappedStatement countMs = this.buildCountMappedStatement(ms, page.countId());
            BoundSql countSql;
            if (countMs != null) {
                countSql = countMs.getBoundSql(parameter);
            } else {
                countMs = this.buildAutoCountMappedStatement(ms);
                String countSqlStr = this.autoCountSql(page, boundSql.getSql());
                MPBoundSql mpBoundSql = PluginUtils.mpBoundSql(boundSql);
                countSql = new BoundSql(countMs.getConfiguration(), countSqlStr, mpBoundSql.parameterMappings(), parameter);
                PluginUtils.setAdditionalParameter(countSql, mpBoundSql.additionalParameters());
            }
            CacheKey cacheKey = executor.createCacheKey(countMs, parameter, rowBounds, countSql);
            List<Object> result = executor.query(countMs, parameter, rowBounds, resultHandler, cacheKey, countSql);
            long total = 0L;
            if (CollectionUtils.isNotEmpty(result)) {
                Object o = result.get(0);
                if (o != null) {
                    total = Long.parseLong(o.toString());
                }
            }
            page.setTotal(total);
            return this.continuePage(page);
        } else {
            return true;
        }
    }
    public void beforeQuery(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {...........省略之后全部的内容........}

Wir können leicht feststellen, dass diese Methode die Methoden in der InnerInterceptor-Schnittstelle implementiert, daher müssen wir ihren Quellcode überprüfen, um die Logik zu klären.

Wir kennen die Beziehung zwischen dem Paging-Plug-In und dem Kern-Plug-In, das heißt, wir können das Paging-Plug-In zur Plug-In-verknüpften Liste im Kern-Plug-In hinzufügen, um die Verwendung von Multi-Plug-Ins zu realisieren. funktionale Plug-Ins.

Konfigurieren Sie das MP-Plug-In und übergeben Sie es an Spring Management (wir verwenden Springboot zum Testen, sodass keine XML-Dateien verwendet werden müssen):

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class MpConfig {
    /*分页插件的配置*/
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        /*创建mp拦截器*/
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        /*创建分页插件*/
        PaginationInnerInterceptor pagInterceptor = new PaginationInnerInterceptor();
        /*设置请求的页面大于最大页容量后的请求操作，true回调第一页，false继续翻页，默认翻页*/
        pagInterceptor.setOverflow(false);
        /*设置单页分页的条数限制*/
        pagInterceptor.setMaxLimit(500L);
        /*设置数据库类型*/
        pagInterceptor.setDbType(DbType.MYSQL);
        /*将分页拦截器添加到mp拦截器中*/
        interceptor.addInnerInterceptor(pagInterceptor);
        return interceptor;
    }
}

Nach der Konfiguration schreiben Sie eine Mapper-Schnittstelle:

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.hlc.mp.entity.Product;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface ProductMapper extends BaseMapper<Product> {
}

Erstellen Sie eine Serviceklasse für die Schnittstelle (Muss dem MP-Codierungsstil folgen):

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hlc.mp.entity.Product;
import com.hlc.mp.mapper.ProductMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service(value = "ProductService")
public class ProductServiceImpl extends ServiceImpl<ProductMapper, Product>
        implements IService<Product> {
    @Autowired
    ProductMapper productMapper;
    /**
     * 根据传入的页码进行翻页
     *
     * @param current 当前页码（已经约定每页数据量是1条）
     * @return 分页对象
     */
    public Page<Product> page(Long current) {
        /*current首页位置，写1就是第一页，没有0页之说，size每页显示的数据量*/
        Page<Product> productPage = new Page<>(current, 1);
        /*条件查询分页*/
        QueryWrapper<Product> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("status", 0);
        productMapper.selectPage(productPage, queryWrapper);
        return productPage;
    }
}

Hier können wir sehen, dass die spezifische Paging-Methode darin besteht, zuerst ein Paging-Objekt zu erstellen, die Seitennummer und die Datenmenge auf jeder Seite anzugeben und dann zu bestimmen Umfang des Abfragevorgangs und Verwenden Sie die von BaseMapper bereitgestellte Abfrage-Paging-Methode selectPage(E page, Wapper), um Abfrage-Paging-Vorgänge durchzuführen.

Testklasse:

    @Test
    public void testPage(){
        IPage<Product> productIPage = productService.page(2L);
        productIPage.getRecords().forEach(System.out::println);
        System.out.println("当前页码"+productIPage.getCurrent());
        System.out.println("每页显示数量"+productIPage.getSize());
        System.out.println("总页数"+productIPage.getPages());
        System.out.println("数据总量"+productIPage.getTotal());
    }

Führen Sie die Seite aus, um die Paging-Ergebnisse anzuzeigen:

Wir können feststellen, dass die entsprechenden Seitendaten gemäß der von uns übergebenen Seitennummer normal abgefragt werden, da ich jede Seite so eingestellt habe, dass nur ein Teil angezeigt wird Wenn also die ID mit der Seitenzahl übereinstimmt, ist das Paging erfolgreich.

Das obige ist der detaillierte Inhalt vonSo implementieren Sie den einfachen Paging-Abfragetest von SpringBoot MP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!