Mybatis自定义分页类

最新推荐文章于 2024-04-19 15:49:21 发布
最新推荐文章于 2024-04-19 15:49:21 发布
阅读量570 收藏 1
点赞数
分类专栏： mybatis 文章标签： java mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42555782/article/details/121516624
版权

在实际项目中，大家经常为mybatis的分页使出各种方案，其中不乏采用mybatis-plus等第三方控件的方法，但整体来说并不灵活。其实分页思想就是对查询结果集增加了预处理，最近笔者在一个项目中看到了某大佬手撸的一个分页类源码，顿时拜倒折服，也同大家互勉。
代码采用AOP非侵入方式，拦截方法名直接全局操作，不需要对源码提出任何需求就可以轻松实现分页。

Pager类

package top.powersys.core.pager;

import javax.servlet.http.HttpSession;

import org.apache.commons.lang3.StringUtils;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import top.powersys.core.util.GlobalUtil;
import top.powersys.core.util.I18nUtil;

import java.util.Map;

public class Pager {
    private int showCount = 10;
    private int showTag = 10;
    private int totalResult;
    private int totalPage;
    private int currentPage;
    private int currentResult;
    private String pageStr;
    private String url;
    private String para;
    private String orderBy;
    private boolean showSizeOption = true;

    public Pager() {
        this.showCount = GlobalUtil.pagesize;
        HttpSession session = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest().getSession();
        if (session != null) {
            Object pageSizeInSession = session.getAttribute(GlobalUtil.PAGESIZE_KEY);
            if (pageSizeInSession != null)
                this.showCount = Integer.parseInt(pageSizeInSession.toString());
        }
        if (this.showCount > 100)
            this.showCount = 100;

    }

    public Pager(final int currentPage, final String url, final String orderby) {
        this();
        this.url = url;
        this.orderBy = orderby;
        this.currentPage = currentPage;
    }

    public Pager(final int currentPage, final String url, final String orderby, final String param) {
        this(currentPage, url, orderby);
        this.para = param;
    }

    public Pager(final int currentPage, final String url, final String orderby, final Map<String, Object> param) {
        this(currentPage, url, orderby);
        StringBuilder paramMap = new StringBuilder();
        for (Map.Entry<String, Object> entry : param.entrySet()) {
            if (StringUtils.isNotEmpty(entry.getKey()) && entry.getValue() != null && StringUtils.isNotEmpty(String.valueOf(entry.getValue())))
                paramMap.append("&" + entry.getKey() + "=" + entry.getValue());
        }
        this.para = paramMap.toString();
    }

    /***
     *
     * @param currentPage
     * @param url
     * @param paramWithOrder     *
     * ob==orderby
     * ot==ordertype 0=asc .1(or other)=desc
     */
    public Pager(final int currentPage, final String url, final Map<String, Object> paramWithOrder) {
        this(currentPage, url, paramWithOrder.get("ob").toString() + " " + (paramWithOrder.get("ot").toString().equals("0") ? "asc" : "desc"), paramWithOrder);
    }


    public String getOrderBy() {
        if (StringUtils.isBlank(orderBy)) return "";
        else return " order by " + orderBy;
    }

    public void setOrderBy(String orderBy) {
        this.orderBy = orderBy;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public int getTotalResult() {
        return totalResult;
    }

    public void setTotalResult(int totalResult) {
        this.totalResult = totalResult;
    }

    public int getTotalPage() {
        totalPage = totalResult % showCount == 0 ? (totalResult / showCount) : (totalResult / showCount + 1);
        return totalPage;
    }

    public int getCurrentPage() {
        if (currentPage < 1 || currentPage > getTotalPage()) currentPage = 1;
        return currentPage;
    }

    public void setCurrentPage(int currentPage) {
        this.currentPage = currentPage;
    }

    public int getCurrentResult() {
        currentResult = (getCurrentPage() - 1) * this.showCount + 1;
        if (currentResult < 0)
            currentResult = 0;
        return currentResult;
    }

    public String getPara() {
        if (StringUtils.isBlank(para))
            return "";
        else
            return para;
    }

    public void setPara(String para) {
        this.para = para;
    }

    public boolean isShowSizeOption() {
        return showSizeOption;
    }

    public void setShowSizeOption(boolean showSizeOption) {
        this.showSizeOption = showSizeOption;
    }

    public int getShowCount() {
        return this.showCount;
    }

    public String getPageStr() {
        if (StringUtils.isBlank(para))
            para = "";

        String pagename = I18nUtil.getMessage("i18n.common", "page"), records = I18nUtil
                .getMessage("i18n.common", "records"), total = I18nUtil
                .getMessage("i18n.common", "total"), pagesize = I18nUtil
                .getMessage("i18n.common", "pagesize");

        StringBuilder sb = new StringBuilder();
        if (totalResult > 0) {
            if (currentPage == 1) {
                sb.append(" <span data-icon=\"&#xf06f1;\"></span> <span data-icon=\"&#xf06f3;\"></span>");
            } else {
                sb.append(" <a href='"
                        + url
                        + "?"
                        + para
                        + "&p=1'><span data-icon=\"&#xf06f1;\"></span></a> <a href='"
                        + url + "?" + para + "&p=" + (currentPage - 1)
                        + "'><span data-icon=\"&#xf06f3;\"></span></a>");
            }

            int startTag = 1;
            if (currentPage > showTag) {
                startTag = currentPage - 1;
            }
            int endTag = startTag + showTag - 1;
            for (int i = startTag; i <= totalPage && i <= endTag; i++) {
                if (currentPage == i)
                    sb.append(" <span class='text-danger'>" + i + "</span>");
                else
                    sb.append(" <a href='" + url + "?" + para + "&p=" + i
                            + "'>" + i + "</a>");
            }

            if (currentPage == totalPage) {
                sb.append(" <span data-icon=\"&#xf06f4;\"></span> <span data-icon=\"&#xf06f2;\"></span>");
            } else {
                sb.append(" <a href='"
                        + url
                        + "?"
                        + para
                        + "&p="
                        + (currentPage + 1)
                        + "'><span data-icon=\"&#xf06f4;\"></span></a> <a href='"
                        + url + "?" + para + "&p=" + totalPage
                        + "'><span data-icon=\"&#xf06f2;\"></span></a>");
            }

            sb.append(" " + total + " <span class='text-info'>" + totalResult
                    + "</span> " + records + " <span class='text-info'>"
                    + totalPage + "</span> " + pagename);

            if (this.showSizeOption == true) {
                sb.append(" "
                        + pagesize
                        + " <select id=\"perPage\" οnchange=\"if(this.options[this.selectedIndex].value!=''){location='"
                        + url + "?");
                if (StringUtils.isNotEmpty(para))
                    sb.append(para + "&");
                sb.append("p=1&pagesize='+this.options[this.selectedIndex].value;}\">");
                for (int i = 1; i <= 10; i++) {
                    sb.append("<option value=\"" + (i * 10) + "\"");
                    if ((i * 10) == showCount) {
                        sb.append(" selected='selected'>" + (i * 10) + "</option>");
                    } else {
                        sb.append(">" + (i * 10) + "</option>");
                    }
                }
                sb.append("</select>");
            }
        }
        pageStr = sb.toString();
        return pageStr;
    }
}

Pager的参数页，自己编写了Handler处理器对jdbc灵活配置

package top.powersys.core.pager;

import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.List;

import org.apache.ibatis.executor.ErrorContext;
import org.apache.ibatis.executor.ExecutorException;
import org.apache.ibatis.executor.parameter.ParameterHandler;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ParameterMapping;
import org.apache.ibatis.mapping.ParameterMode;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.property.PropertyTokenizer;
import org.apache.ibatis.scripting.xmltags.ForEachSqlNode;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.type.TypeHandler;
import org.apache.ibatis.type.TypeHandlerRegistry;

public class PagerParameterHandler implements ParameterHandler {

    private final TypeHandlerRegistry typeHandlerRegistry;
    private final MappedStatement mappedStatement;
    private final Object parameterObject;
    private BoundSql boundSql;
    private Configuration configuration;

    public PagerParameterHandler(MappedStatement mappedStatement,
                                 Object parameterObject, BoundSql boundSql) {
        this.mappedStatement = mappedStatement;
        this.configuration = mappedStatement.getConfiguration();
        this.typeHandlerRegistry = mappedStatement.getConfiguration()
                .getTypeHandlerRegistry();
        this.parameterObject = parameterObject;
        this.boundSql = boundSql;
    }

    public Object getParameterObject() {
        return parameterObject;
    }

    @SuppressWarnings({"unchecked", "rawtypes"})
    public void setParameters(PreparedStatement ps) throws SQLException {
        ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
        if (parameterMappings != null) {
            MetaObject metaObject = parameterObject == null ? null : configuration.newMetaObject(parameterObject);
            for (int i = 0; i < parameterMappings.size(); i++) {
                ParameterMapping parameterMapping = parameterMappings.get(i);
                if (parameterMapping.getMode() != ParameterMode.OUT) {
                    Object value;
                    String propertyName = parameterMapping.getProperty();
                    PropertyTokenizer prop = new PropertyTokenizer(propertyName);
                    if (parameterObject == null) {
                        value = null;
                    } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
                        value = parameterObject;
                    } else if (boundSql.hasAdditionalParameter(propertyName)) {
                        value = boundSql.getAdditionalParameter(propertyName);
                    } else if (propertyName.startsWith(ForEachSqlNode.ITEM_PREFIX) && boundSql.hasAdditionalParameter(prop.getName())) {
                        value = boundSql.getAdditionalParameter(prop.getName());
                        if (value != null) {
                            value = configuration.newMetaObject(value).getValue(propertyName.substring(prop.getName().length()));
                        }
                    } else {
                        value = metaObject == null ? null : metaObject.getValue(propertyName);
                    }
                    TypeHandler typeHandler = parameterMapping.getTypeHandler();
                    if (typeHandler == null) {
                        throw new ExecutorException("There was no TypeHandler found for parameter " + propertyName + " of statement " + mappedStatement.getId());
                    }
                    typeHandler.setParameter(ps, i + 1, value, parameterMapping.getJdbcType());
                }
            }
        }
    }
}

最后，以非侵入的形式，采用拦截器对查询语句拦截拼接

package top.powersys.core.pager;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Set;

import org.apache.commons.lang3.StringUtils;
import org.apache.ibatis.executor.statement.BaseStatementHandler;
import org.apache.ibatis.executor.statement.RoutingStatementHandler;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.DatabaseIdProvider;
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.log4j.Logger;
import top.powersys.core.util.ReflectHelper;

import javax.sql.DataSource;

@Intercepts({@Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class,Integer.class})})
public class PagerPlugin implements Interceptor {

    private static Logger logger = Logger.getLogger(PagerPlugin.class);
    private static String dialect = "";
    private static String pageSqlId = ".*ListPage.*";

    @SuppressWarnings({"unchecked", "rawtypes"})
    public Object intercept(Invocation ivk) throws Throwable {
        if (ivk.getTarget() instanceof RoutingStatementHandler) {
            RoutingStatementHandler statementHandler = (RoutingStatementHandler) ivk
                    .getTarget();
            BaseStatementHandler delegate = (BaseStatementHandler) ReflectHelper
                    .getValueByFieldName(statementHandler, "delegate");
            MappedStatement mappedStatement = (MappedStatement) ReflectHelper
                    .getValueByFieldName(delegate, "mappedStatement");

            if (mappedStatement.getId().matches(pageSqlId)) {
                BoundSql boundSql = delegate.getBoundSql();
                Object parameterObject = boundSql.getParameterObject();
                if (parameterObject == null) return ivk.proceed();

                Pager pageView = null;
                if (parameterObject instanceof Map) {
                    for (Entry entry : (Set<Entry>) ((Map) parameterObject).entrySet()) {
                        if (entry.getValue() instanceof Pager) {
                            pageView = (Pager) entry.getValue();
                            break;
                        }
                    }
                } else if (parameterObject instanceof Pager) {
                    pageView = (Pager) parameterObject;
                } else {
                    pageView = ReflectHelper.getValueByFieldType(parameterObject, Pager.class);
                }
                if (pageView == null) return ivk.proceed();

                String sql = boundSql.getSql();
                PreparedStatement countStmt = null;
                ResultSet rs = null;
                try {
                    Connection connection = (Connection) ivk.getArgs()[0];
                    String countSql = "select count(*) from (" + sql + ") tmp_count";
                    countStmt = connection.prepareStatement(countSql);
                    ReflectHelper.setValueByFieldName(boundSql, "sql", countSql);
                    PagerParameterHandler parameterHandler = new PagerParameterHandler(mappedStatement, parameterObject, boundSql);
                    parameterHandler.setParameters(countStmt);
                    rs = countStmt.executeQuery();
                    int count = 0;
                    if (rs.next()) count = rs.getInt(1);
                    pageView.setTotalResult(count);
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    rs.close();
                    countStmt.close();
                }
                String pageSql = generatePageSql(sql, pageView);
                logger.debug(pageSql);
                ReflectHelper.setValueByFieldName(boundSql, "sql", pageSql);
            }
        }
        return ivk.proceed();
    }

    private String generatePageSql(String sql, Pager page) {
        if (StringUtils.isBlank(dialect)) getDialect();
        StringBuilder pageSql = new StringBuilder();
        if ("sqlserver".equals(dialect)) {
            pageSql.append("SELECT * FROM (  SELECT  ROW_NUMBER() OVER(");
            pageSql.append(page.getOrderBy());
            pageSql.append(") AS  r, A.* FROM (");
            pageSql.append(sql);
            pageSql.append(") A ) B WHERE  r between ");
            pageSql.append(page.getCurrentResult());// row_number from 1
            pageSql.append(" AND ");
            pageSql.append(page.getCurrentResult() + page.getShowCount() - 1);
        } else if ("mysql".equals(dialect)) {
            pageSql.append(sql);
            pageSql.append(page.getOrderBy());
            pageSql.append(" limit " + (page.getCurrentResult() - 1) + "," + page.getShowCount());
        } else if ("oracle".equals(dialect)) {
            pageSql.append("select * from (select tmp_tb.*,ROWNUM row_id from (");
            pageSql.append(sql);
            pageSql.append(page.getOrderBy());
            pageSql.append(") as tmp_tb where ROWNUM<=");
            pageSql.append(page.getCurrentResult() + page.getShowCount());
            pageSql.append(") where row_id>");
            pageSql.append(page.getCurrentResult());
        }
        return pageSql.toString();
    }

    public Object plugin(Object arg0) {
        return Plugin.wrap(arg0, this);
    }

    public void setProperties(Properties p) {
    }

    private void getDialect() {
        try {
            dialect = databaseIdProvider.getDatabaseId(dataSource);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    private DataSource dataSource;
    private DatabaseIdProvider databaseIdProvider;

    public void setDatabaseIdProvider(DatabaseIdProvider databaseIdProvider) {
        this.databaseIdProvider = databaseIdProvider;
    }

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }
}

这里，还用到了反射

package top.powersys.core.util;
import java.lang.reflect.Field;

public class ReflectHelper {

	public static Field getFieldByFieldName(Object obj, String fieldName) {
		for (Class<?> superClass = obj.getClass(); superClass != Object.class; superClass = superClass
				.getSuperclass()) {
			try {
				return superClass.getDeclaredField(fieldName);
			} catch (NoSuchFieldException e) {
			}
		}
		return null;
	}

	public static Object getValueByFieldName(Object obj, String fieldName)
			throws SecurityException, NoSuchFieldException,
			IllegalArgumentException, IllegalAccessException {
		Field field = getFieldByFieldName(obj, fieldName);
		Object value = null;
		if(field!=null){
			if (field.isAccessible()) {
				value = field.get(obj);
			} else {
				field.setAccessible(true);
				value = field.get(obj);
				field.setAccessible(false);
			}
		}
		return value;
	}


	public static void setValueByFieldName(Object obj, String fieldName,
			Object value) throws SecurityException, NoSuchFieldException,
			IllegalArgumentException, IllegalAccessException {
		Field field = obj.getClass().getDeclaredField(fieldName);
		if (field.isAccessible()) {
			field.set(obj, value);
		} else {
			field.setAccessible(true);
			field.set(obj, value);
			field.setAccessible(false);
		}
	}

	@SuppressWarnings("unchecked")
	public static <T> T getValueByFieldType(Object obj, Class<T> fieldType) {
		Object value = null;
		for (Class<?> superClass = obj.getClass(); superClass != Object.class; superClass = superClass
				.getSuperclass()) {
			try {
				Field[] fields = superClass.getDeclaredFields();
				for (Field f : fields) {
					if (f.getType() == fieldType) {
						if (f.isAccessible()) {
							value = f.get(obj);
							break;
						} else {
							f.setAccessible(true);
							value = f.get(obj);
							f.setAccessible(false);
							break;
						}
					}
				}
				if (value != null) {
					break;
				}
			} catch (Exception e) {
			}
		}
		return (T) value;
	}
}

由于是经典springmvc项目，配置项也有一些复杂

<bean id="databaseIdProvider" class="org.apache.ibatis.mapping.VendorDatabaseIdProvider">
        <property name="properties">
            <props>
                <prop key="SQL Server">sqlserver</prop>
                <prop key="MySQL">mysql</prop>
                <prop key="Oracle">oracle</prop>
            </props>
        </property>
    </bean>
    <bean id="dataSource" class="com.jolbox.bonecp.BoneCPDataSource" destroy-method="close">
        <property name="driverClass" value="${jdbc.driverclass}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="idleConnectionTestPeriodInSeconds" value="14400"/>
        <property name="idleMaxAgeInSeconds" value="3600"/>
        <property name="partitionCount" value="3"/>
        <property name="minConnectionsPerPartition" value="1"/>
        <property name="maxConnectionsPerPartition" value="20"/>
        <property name="acquireIncrement" value="2"/>
    </bean>
  <bean id="customSqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="databaseIdProvider" ref="databaseIdProvider"/>
        <property name="dataSource" ref="dataSource"/>
        <property name="typeAliasesPackage"
                  value="top.powersys.system.vo,
                  top.powersys.log.vo,
                  top.powersys.parameter.vo,
                  top.powersys.archive.vo,
                  top.powersys.remoting.vo,
                  top.powersys.prepay.vo,
                  top.powersys.prepayservice.vo,
                  top.powersys.vendingservice.vo,
                  top.powersys.analysis.vo,
                  top.powersys.cmsinterface.vo"/>
        <property name="plugins">
            <list>
                <bean class="top.powersys.core.pager.PagerPlugin">
                    <property name="databaseIdProvider" ref="databaseIdProvider"/>
                    <property name="dataSource" ref="dataSource"/>
                </bean>
            </list>
        </property>

        <property name="mapperLocations">
            <list>
                <value>classpath*:top/powersys/**/*Mapper.xml</value>
            </list>
        </property>
        <!--&lt;!&ndash;放开可协助查看sql语句&ndash;&gt;-->
<!--        <property name="configLocation" value="/WEB-INF/conf/mybatis-config.xml"></property>-->
    </bean>

虽然说长江后浪推前浪，但看到大佬的封装模式，最后我也是自惭形秽，一套侵入mybatis分页源码，已经说明了基础是多么重要。

镜云兮
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Mybatis实现自定义分页插件
•一个写代码的•
10-31 2233
mybatis自定义分页插件，步骤如下【文章末尾关注公众号获取完整代码】： （1）环境搭建 创建一个maven工程，然后引入mybatis依赖和mysql依赖即可。 <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.0.4</version> </dependency>
MyBatis使用篇（十一）—— MyBatis实现分页
王喆峰的博客
01-08 2488
文章目录1、搭建演示环境1.1 创建数据表1.2 创建实体类1.3 创建接口Dao1.4 创建SQL映射文件1.5 创建测试类2、通过List结果集实现分页2.1 添加接口方法2.2 添加SQL标签2.3 添加测试方法3、通过SQL参数实现分页3.1 添加接口方法3.2 添加SQL标签3.3 添加测试方法4、通过RowBounds实现分页4.1 添加接口方法4.2 添加SQL标签4.3 添加测试方...
Mybatis 自定义自动分页
java 大叔的博客
11-29 1457
Mybatis 自定义自动分页 1.JDBCToMyBatisUtils.java package com.util.query; import java.util.List; import java.util.Set; import java.util.regex.Matcher; import java.util.regex.Pattern; import org.apache.commons.lang3.StringUtils; import org.springframework.stereot
MyBatis-Plus分页查询IPage的使用方法，如何自定义分页查询功能？
最新发布
m0_70325779的博客
04-19 5537
介绍 MyBatisPlus 分页插件IPage的使用和条件构造器 LambdQueryWrapper 的使用
mybatis常见分页技术和自定义分页原理实战
baidu_21349635的专栏
04-07 2595
文章目录前言常用的几种分页方式按照真假分页分按照分页写法分自定义分页原理自定义分页实战 前言 常用的几种分页方式 按照真假分页分 按照分页写法分 自定义分页原理 自定义分页实战
Mybatis的分页方式详解以及Mybatis-plus分页。
qq_45171544的博客
07-26 9286
Mybatis的分页方式详解以及Mybatis-plus分页。
mybatis自定义分页标签
06-06
而自定义分页标签是提高开发效率、增强代码可读性和复用性的一种常见手段。本篇将详细介绍如何在MyBatis中实现自定义的JSTL标签来完成分页查询。 首先，我们要理解分页的基本概念。分页是当数据量较大时，为了提高...
mybatis自定义分页
06-14
本篇将深入探讨如何在MyBatis中实现自定义分页，并结合SpringMVC和Spring进行应用。 首先，理解分页的基本概念。分页是将大量数据分成若干小块，每次只加载一部分数据到内存中，这样可以减少服务器压力，提高页面...
mybatis 自定义分页插件.rar
09-10
在MyBatis框架中，自定义分页插件是一种常见的需求，特别是在处理大数据量时，为了提高用户体验和系统性能，我们需要对数据进行分页显示。本压缩包“mybatis 自定义分页插件.rar”提供了关于如何利用MyBatis的拦截器...
MyBatis-Plus 分页查询以及自定义sql分页的实现
09-07
MyBatis-Plus 是一个基于 ...总的来说，MyBatis-Plus 的分页查询功能强大且灵活，既支持自动化的物理分页，也允许用户根据需要自定义 SQL。通过合理的配置和使用，可以极大地提高开发效率，同时优化数据库的性能。
Mybatis自定义分页插件及PageHelper源码分析
qq_48157004的博客
06-01 1732
Mybatis作为一个应用广泛的优秀的ORM开源框架，这个框架具有强大的灵活性，在四大组件(Executor、StatementHandler、ParameterHandler、ResultSetHandler)处提供了简单易用的插 件扩展机制。Mybatis对持久层的操作就是借助于四大核心对象。MyBatis支持用插件对四大核心对象进行拦截，对mybatis来说插件就是拦截器，用来增强核心对象的功能，增强功能本质上是借助于底层的动态代理实现的，换句话说，MyBatis中的四大对象都是代理对象。
mybatis实现分页的几种方式
Jay的博客
08-14 1万+
一.借助数组进行分页 原理：进行数据库查询操作时，获取到数据库中所有满足条件的记录，保存在应用的临时数组中，再通过List的subList方法，获取到满足条件的所有记录。 实现： 首先在dao层，创建StudentMapper接口，用于对数据库的操作。在接口中定义通过数组分页的查询方法，如下所示： List<Student> queryStudentsByArray(); 方法很简单，就是获取所有的数据，通过list接收后进行分页操作。 创建StudentMapper.xml文件，编写查询的
MyBatis－如何实现分页
了解➔熟悉➔掌握➔精通
12-28 5664
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请轻击http://www.captainbed.net 1、就是直接使用我们的SQL语句进行分页，也就是在Mapper里面加上分页的语句就好了。比如MySQL添加一个limit 2,4。这种方式弊端很大，比如我们不用MySQL了，所有的代码都要修改。 2、使用成熟的框架MyBaits-Plus，它是一个MyBatis的增强工具，在MyBatis的基础上只做增强不做改变，为简化开发、提高效率而生。如果你坚持要使用My
Mybatis 的 分页讲解
王鹤霖的专栏 三人行必有我师
11-14 556
数组分页 查询出全部数据，然后再list中截取需要的部分。 mybatis接口 List<Student> queryStudentsByArray(); xml配置文件 <select id="queryStudentsByArray" resultMap="studentmapper"> select * from student </select> service 接口 List<Student> query
mybatis 在当前项目中的实际应用及自定义分页的实现
c1523456的博客
05-25 1507
mybatis 在当前项目中的实际应用及自定义分页的实现
Mybatis的四种分页方式详解
热门推荐
web13618542420的博客
08-02 2万+
先自我介绍一下，小编13年上师交大毕业，曾经在小公司待过，去过华为OPPO等大厂，18年进入阿里，直到现在。因此我收集了一份《java开发全套学习资料》送给大家，初衷也很简单，就是希望帮助到想自学又不知道该从何学起的朋友，同时减轻大家的负担。使用方式https//github.com/pagehelper/Mybatis-PageHelper/blob/master/wikis/zh/HowToUse.md。PageHelper是一个第三方实现的分页拦截器插件，使用起来灵活且方便。拦截更改后的sql。...
mybatis（三）：mybatis自定义分页
xby7437的博客
07-05 775
由于之前mybatis的版本较低，以至于在自定义分页的时候，只能返回列表，总量还是得自己调用count方法，现在升级了mybatis版本之后，对自定义分页进行改造，让其能返回page，代码如下： pom依赖，mybatis版本在3.1.1 <dependencies> <dependency> <groupId>com.baomidou</groupId> <artif.
mybatis自定义分页条件查询
07-20
在 MyBatis 中，可以通过自定义分页条件来实现分页查询。下面是一个简单的示例： 1. 首先，在Mapper接口中定义一个方法，用于接收分页查询的参数和返回查询结果： ```java List<YourEntity> findByPage(@Param(...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

镜云兮

打赏的都是爷~求各位爷可怜可怜

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值