`
qq123zhz
  • 浏览: 536306 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

mybatis 后台分页实现

 
阅读更多 
package page;

public interface Dialect {
    
    public boolean supportsLimit();

    public String getLimitString(String sql, boolean hasOffset);

    public String getLimitString(String sql, int offset, int limit);

	public boolean supportsLimitOffset();
}

 

package page;

public class MySQLDialect implements Dialect {

	protected static final String SQL_END_DELIMITER = ";";

	public String getLimitString(String sql, boolean hasOffset) {
		return new StringBuffer(sql.length() + 20).append(trim(sql))
				.append(hasOffset ? " limit ?,?" : " limit ?")
				.append(SQL_END_DELIMITER).toString();
	}

	public String getLimitString(String sql, int offset, int limit) {
		sql = trim(sql);
		StringBuffer sb = new StringBuffer(sql.length() + 20);
		sb.append(sql);
		if (offset > 0) {
			sb.append(" limit ").append(offset).append(',').append(limit)
					.append(SQL_END_DELIMITER);
		} else {
			sb.append(" limit ").append(limit).append(SQL_END_DELIMITER);
		}
		return sb.toString();
	}

	public boolean supportsLimit() {
		return true;
	}

	private String trim(String sql) {
		sql = sql.trim();
		if (sql.endsWith(SQL_END_DELIMITER)) {
			sql = sql.substring(0,
					sql.length() - 1 - SQL_END_DELIMITER.length());
		}
		return sql;
	}

	public boolean supportsLimitOffset() {
		// TODO Auto-generated method stub
		return true;
	}

}

 

package page;

import java.util.Properties;

import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.MappedStatement.Builder;
import org.apache.ibatis.mapping.SqlSource;
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.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;

@Intercepts({ @Signature(type = Executor.class, method = "query", args = {
		MappedStatement.class, Object.class, RowBounds.class,
		ResultHandler.class }) })
public class OffsetLimitInterceptor implements Interceptor {
	static int MAPPED_STATEMENT_INDEX = 0;
	static int PARAMETER_INDEX = 1;
	static int ROWBOUNDS_INDEX = 2;
	static int RESULT_HANDLER_INDEX = 3;

	Dialect dialect;

	public Object intercept(Invocation invocation) throws Throwable {
		processIntercept(invocation.getArgs());
		return invocation.proceed();
	}

	void processIntercept(final Object[] queryArgs) {
		// queryArgs = query(MappedStatement ms, Object parameter, RowBounds
		// rowBounds, ResultHandler resultHandler)
		MappedStatement ms = (MappedStatement) queryArgs[MAPPED_STATEMENT_INDEX];
		Object parameter = queryArgs[PARAMETER_INDEX];
		final RowBounds rowBounds = (RowBounds) queryArgs[ROWBOUNDS_INDEX];
		int offset = rowBounds.getOffset();
		int limit = rowBounds.getLimit();

		if (dialect.supportsLimit()
				&& (offset != RowBounds.NO_ROW_OFFSET || limit != RowBounds.NO_ROW_LIMIT)) {
			BoundSql boundSql = ms.getBoundSql(parameter);
			String sql = boundSql.getSql().trim();
			if (dialect.supportsLimitOffset()) {
				sql = dialect.getLimitString(sql, offset, limit);
				offset = RowBounds.NO_ROW_OFFSET;
			} else {
				sql = dialect.getLimitString(sql, 0, limit);
			}
			limit = RowBounds.NO_ROW_LIMIT;

			queryArgs[ROWBOUNDS_INDEX] = new RowBounds(offset, limit);
			BoundSql newBoundSql = new BoundSql(ms.getConfiguration(), sql,
					boundSql.getParameterMappings(),
					boundSql.getParameterObject());
			MappedStatement newMs = copyFromMappedStatement(ms,
					new BoundSqlSqlSource(newBoundSql));
			queryArgs[MAPPED_STATEMENT_INDEX] = newMs;
		}
	}

	private MappedStatement copyFromMappedStatement(MappedStatement ms,
			SqlSource newSqlSource) {
		Builder builder = new MappedStatement.Builder(ms.getConfiguration(),
				ms.getId(), newSqlSource, ms.getSqlCommandType());
		builder.resource(ms.getResource());
		builder.fetchSize(ms.getFetchSize());
		builder.statementType(ms.getStatementType());
		builder.keyGenerator(ms.getKeyGenerator());
		builder.keyProperty(ms.getKeyProperty());
		builder.timeout(ms.getTimeout());
		builder.parameterMap(ms.getParameterMap());
		builder.resultMaps(ms.getResultMaps());
		builder.cache(ms.getCache());
		MappedStatement newMs = builder.build();
		return newMs;
	}

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

	public void setProperties(Properties properties) {
		String dialectClass = new PropertiesHelper(properties)
				.getRequiredString("dialectClass");
		try {
			dialect = (Dialect) Class.forName(dialectClass).newInstance();
		} catch (Exception e) {
			throw new RuntimeException(
					"cannot create dialect instance by dialectClass:"
							+ dialectClass, e);
		}
		System.out.println(OffsetLimitInterceptor.class.getSimpleName()
				+ ".dialect=" + dialectClass);
	}

	public static class BoundSqlSqlSource implements SqlSource {
		BoundSql boundSql;

		public BoundSqlSqlSource(BoundSql boundSql) {
			this.boundSql = boundSql;
		}

		public BoundSql getBoundSql(Object parameterObject) {
			return boundSql;
		}
	}

}

 

package page;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.Collection;
import java.util.Enumeration;
import java.util.InvalidPropertiesFormatException;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Set;

public class PropertiesHelper {
	/** Never check system properties. */
	public static final int SYSTEM_PROPERTIES_MODE_NEVER = 0;
	/**
	 * * Check system properties if not resolvable in the specified properties.
	 * * This is the default.
	 */
	public static final int SYSTEM_PROPERTIES_MODE_FALLBACK = 1;
	/**
	 * * Check system properties first, before trying the specified properties.
	 * * This allows system properties to override any other property source.
	 */
	public static final int SYSTEM_PROPERTIES_MODE_OVERRIDE = 2;
	Properties p;
	private int systemPropertiesMode = SYSTEM_PROPERTIES_MODE_NEVER;

	public PropertiesHelper(Properties p) {
		setProperties(p);
	}

	public PropertiesHelper(Properties p, int systemPropertiesMode) {
		setProperties(p);
		if (systemPropertiesMode != SYSTEM_PROPERTIES_MODE_NEVER
				&& systemPropertiesMode != SYSTEM_PROPERTIES_MODE_FALLBACK
				&& systemPropertiesMode != SYSTEM_PROPERTIES_MODE_OVERRIDE) {
			throw new IllegalArgumentException(
					"error systemPropertiesMode mode:" + systemPropertiesMode);
		}
		this.systemPropertiesMode = systemPropertiesMode;
	}

	public Properties getProperties() {
		return p;
	}

	public void setProperties(Properties props) {
		if (props == null)
			throw new IllegalArgumentException("properties must be not null");
		this.p = props;
	}

	public String getRequiredString(String key) {
		String value = getProperty(key);
		if (isBlankString(value)) {
			throw new IllegalStateException(
					"required property is blank by key=" + key);
		}
		return value;
	}

	public String getNullIfBlank(String key) {
		String value = getProperty(key);
		if (isBlankString(value)) {
			return null;
		}
		return value;
	}

	public String getNullIfEmpty(String key) {
		String value = getProperty(key);
		if (value == null || "".equals(value)) {
			return null;
		}
		return value;
	}

	/** * 尝试从System.getProperty(key)及System.getenv(key)得到值 * @return */
	public String getAndTryFromSystem(String key) {
		String value = getProperty(key);
		if (isBlankString(value)) {
			value = getSystemProperty(key);
		}
		return value;
	}

	private String getSystemProperty(String key) {
		String value;
		value = System.getProperty(key);
		if (isBlankString(value)) {
			value = System.getenv(key);
		}
		return value;
	}

	public Integer getInteger(String key) {
		String v = getProperty(key);
		if (v == null) {
			return null;
		}
		return Integer.parseInt(v);
	}

	public int getInt(String key, int defaultValue) {
		if (getProperty(key) == null) {
			return defaultValue;
		}
		return Integer.parseInt(getRequiredString(key));
	}

	public int getRequiredInt(String key) {
		return Integer.parseInt(getRequiredString(key));
	}

	public Long getLong(String key) {
		if (getProperty(key) == null) {
			return null;
		}
		return Long.parseLong(getRequiredString(key));
	}

	public long getLong(String key, long defaultValue) {
		if (getProperty(key) == null) {
			return defaultValue;
		}
		return Long.parseLong(getRequiredString(key));
	}

	public Long getRequiredLong(String key) {
		return Long.parseLong(getRequiredString(key));
	}

	public Boolean getBoolean(String key) {
		if (getProperty(key) == null) {
			return null;
		}
		return Boolean.parseBoolean(getRequiredString(key));
	}

	public boolean getBoolean(String key, boolean defaultValue) {
		if (getProperty(key) == null) {
			return defaultValue;
		}
		return Boolean.parseBoolean(getRequiredString(key));
	}

	public boolean getRequiredBoolean(String key) {
		return Boolean.parseBoolean(getRequiredString(key));
	}

	public Float getFloat(String key) {
		if (getProperty(key) == null) {
			return null;
		}
		return Float.parseFloat(getRequiredString(key));
	}

	public float getFloat(String key, float defaultValue) {
		if (getProperty(key) == null) {
			return defaultValue;
		}
		return Float.parseFloat(getRequiredString(key));
	}

	public Float getRequiredFloat(String key) {
		return Float.parseFloat(getRequiredString(key));
	}

	public Double getDouble(String key) {
		if (getProperty(key) == null) {
			return null;
		}
		return Double.parseDouble(getRequiredString(key));
	}

	public double getDouble(String key, double defaultValue) {
		if (getProperty(key) == null) {
			return defaultValue;
		}
		return Double.parseDouble(getRequiredString(key));
	}

	public Double getRequiredDouble(String key) {
		return Double.parseDouble(getRequiredString(key));
	}

	/** setProperty(String key,int value) ... start */
	public Object setProperty(String key, int value) {
		return setProperty(key, String.valueOf(value));
	}

	public Object setProperty(String key, long value) {
		return setProperty(key, String.valueOf(value));
	}

	public Object setProperty(String key, float value) {
		return setProperty(key, String.valueOf(value));
	}

	public Object setProperty(String key, double value) {
		return setProperty(key, String.valueOf(value));
	}

	public Object setProperty(String key, boolean value) {
		return setProperty(key, String.valueOf(value));
	}

	/** delegate method start */
	public String getProperty(String key, String defaultValue) {
		return p.getProperty(key, defaultValue);
	}

	public String getProperty(String key) {
		String propVal = null;
		if (systemPropertiesMode == SYSTEM_PROPERTIES_MODE_OVERRIDE) {
			propVal = getSystemProperty(key);
		}
		if (propVal == null) {
			propVal = p.getProperty(key);
		}
		if (propVal == null
				&& systemPropertiesMode == SYSTEM_PROPERTIES_MODE_FALLBACK) {
			propVal = getSystemProperty(key);
		}
		return propVal;
	}

	public Object setProperty(String key, String value) {
		return p.setProperty(key, value);
	}

	public void clear() {
		p.clear();
	}

	public Set<Entry<Object, Object>> entrySet() {
		return p.entrySet();
	}

	public Enumeration<?> propertyNames() {
		return p.propertyNames();
	}

	public boolean contains(Object value) {
		return p.contains(value);
	}

	public boolean containsKey(Object key) {
		return p.containsKey(key);
	}

	public boolean containsValue(Object value) {
		return p.containsValue(value);
	}

	public Enumeration<Object> elements() {
		return p.elements();
	}

	public Object get(Object key) {
		return p.get(key);
	}

	public boolean isEmpty() {
		return p.isEmpty();
	}

	public Enumeration<Object> keys() {
		return p.keys();
	}

	public Set<Object> keySet() {
		return p.keySet();
	}

	public void list(PrintStream out) {
		p.list(out);
	}

	public void list(PrintWriter out) {
		p.list(out);
	}

	public void load(InputStream inStream) throws IOException {
		p.load(inStream);
	}

	public void loadFromXML(InputStream in) throws IOException,
			InvalidPropertiesFormatException {
		p.loadFromXML(in);
	}

	public Object put(Object key, Object value) {
		return p.put(key, value);
	}

	public void putAll(Map<? extends Object, ? extends Object> t) {
		p.putAll(t);
	}

	public Object remove(Object key) {
		return p.remove(key);
	}

	/** @deprecated */
	public void save(OutputStream out, String comments) {
		p.save(out, comments);
	}

	public int size() {
		return p.size();
	}

	public void store(OutputStream out, String comments) throws IOException {
		p.store(out, comments);
	}

	public void storeToXML(OutputStream os, String comment, String encoding)
			throws IOException {
		p.storeToXML(os, comment, encoding);
	}

	public void storeToXML(OutputStream os, String comment) throws IOException {
		p.storeToXML(os, comment);
	}

	public Collection<Object> values() {
		return p.values();
	}

	public String toString() {
		return p.toString();
	}

	private static boolean isBlankString(String value) {
		return value == null || "".equals(value.trim());
	}
}

 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
PUBLIC "-//ibatis.apache.org//DTD Config 3.0//EN"
"http://ibatis.apache.org/dtd/ibatis-3-config.dtd">
<configuration>
<plugins>  

	<plugin interceptor="page.OffsetLimitInterceptor">
		<property name="dialectClass"
			value="page.MySQLDialect" />
	</plugin>
</plugins>

	<environments default="development">
		<environment id="development">
			<transactionManager type="JDBC" />
			<dataSource type="POOLED">
				<property name="driver" value="com.mysql.jdbc.Driver" />
				<property name="url"
					value="jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=UTF-8" />
				<property name="username" value="root" />
				<property name="password" value="sa" />
			</dataSource>
		</environment>
	</environments>
	<mappers>
		<mapper resource="com/company/project/model/mapper/UserInfoMapper.xml" />
	</mappers>
</configuration>

 

import java.io.Reader;
import java.util.List;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import com.company.project.model.UserInfo;
/**
 * @author badqiu
 */
public class Ibatis3DemoMain {
	
	public static void main(String[] args) throws Exception {
		
		Reader reader = Resources.getResourceAsReader("Configuration.xml");
		SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader);
		SqlSession session = sessionFactory.openSession();
		
		testCrud(session);
	}

	private static void testCrud(SqlSession session) {
		
		
		
		// test select
//		Long count = (Long)session.selectOne("UserInfo.count",user);
//		assertTrue(1 == count);
		List<UserInfo> list = session.selectList("UserInfo.pageSelect",user,new RowBounds(0, 2));
		
		for (UserInfo info : list) {
			System.out.println(info.toString());
		}
//		SqlSession.selectList(statement, parameter, new RowBounds(offset,limit))即可使用物理分页

//		fromDb = (UserInfo)list.get(0);
	}
	
}

 由于版本问题，BoundSql类在ibatis3的版本中构造函数新增了一个参数，

public BoundSql(Configuration configuration, String sql, List<ParameterMapping> parameterMappings, Object parameterObject) {
    this.sql = sql;
    this.parameterMappings = parameterMappings;
    this.parameterObject = parameterObject;
    this.additionalParameters = new HashMap<String, Object>();
    this.metaParameters = configuration.newMetaObject(additionalParameters);
  }

 所以，必须要先获得configuration，configuration可以通过MappedStatement获得。

3
顶
6
踩
分享到：
| Jquery 基础学习笔记
评论
13 楼 丿T-Bag 2014-10-15  
用3.0.1 就可以了
12 楼 qq123zhz 2013-09-05  
java-lxm 写道
看了很多优化的方案，但是在这个方言里不知道怎么去改实现如：
select * from XX where 主键 >= (select 主键 from XX order by id limit 1000000,1) limit 10;


在processIntercept 这个方法里，把你优化后的sql放进去，就可以了，mybaits拦截器本生调用的就是原生的sql来实现分页，不像hibernate封装的那么好。
11 楼 java-lxm 2013-09-05  
看了很多优化的方案，但是在这个方言里不知道怎么去改实现如：
select * from XX where 主键 >= (select 主键 from XX order by id limit 1000000,1) limit 10;
10 楼 qq123zhz 2013-09-05  
java-lxm 写道
qq123zhz 写道
java-lxm 写道
数据大了这个分页就很慢哦


这个是后台分页的，你把每次分页记录搞少一点

qq123zhz 写道
java-lxm 写道
数据大了这个分页就很慢哦


这个是后台分页的，你把每次分页记录搞少一点

我的意思是数据量大的时候，比如千万级的数据，查询百万记录后的数据。如：
select * from XX limit 1000000 ,10
这样很慢



这个就是数据库考虑优化的问题了吧
9 楼 java-lxm 2013-09-05  
qq123zhz 写道
java-lxm 写道
数据大了这个分页就很慢哦


这个是后台分页的，你把每次分页记录搞少一点

qq123zhz 写道
java-lxm 写道
数据大了这个分页就很慢哦


这个是后台分页的，你把每次分页记录搞少一点

我的意思是数据量大的时候，比如千万级的数据，查询百万记录后的数据。如：
select * from XX limit 1000000 ,10
这样很慢
8 楼 qq123zhz 2013-09-05  
java-lxm 写道
数据大了这个分页就很慢哦


这个是后台分页的，你把每次分页记录搞少一点
7 楼 java-lxm 2013-09-05  
数据大了这个分页就很慢哦
6 楼 qq123zhz 2012-07-20  
yixiandave 写道
yixiandave 写道
builder.keyProperty(ms.getKeyProperty());
OffsetLimitInterceptor这一行报错
说没有这个方法。只有一个相近的ms.getKeyProperties()方法，得到的是个String[]

是版本的问题吗

我用的是3.1.1的版本。刚刚查了下源码，builder.keyProperty方法传入一个字符串，然后用了个split(",")方法组成一个数组传给mappedStatement.properties......
目测可以ms.getKeyProperties()方法取得数组再用逗号全部串成一个字符串。。。。

好蛋疼

这个确实是版本的问题，你可以查看一下mybatis的源码，看看如何修改。
5 楼 yixiandave 2012-07-20  
yixiandave 写道
builder.keyProperty(ms.getKeyProperty());
OffsetLimitInterceptor这一行报错
说没有这个方法。只有一个相近的ms.getKeyProperties()方法，得到的是个String[]

是版本的问题吗

我用的是3.1.1的版本。刚刚查了下源码，builder.keyProperty方法传入一个字符串，然后用了个split(",")方法组成一个数组传给mappedStatement.properties......
目测可以ms.getKeyProperties()方法取得数组再用逗号全部串成一个字符串。。。。

好蛋疼
4 楼 yixiandave 2012-07-20  
builder.keyProperty(ms.getKeyProperty());
OffsetLimitInterceptor这一行报错
说没有这个方法。只有一个相近的ms.getKeyProperties()方法，得到的是个String[]

是版本的问题吗
3 楼 qq123zhz 2011-09-09  
2147483647
dir_murong 写道
问问lz 在下面这个方法里，一般反射调用的都是配置到xml配置文件里。但是我遇到如下的情况，dao层的数据offset和limit 还是我给的数据，蛋一走到这个方法里的时候，
invocation.getArgs()[2]的RowBounds对象所包含的offset和limit 就变成了0 和2147483647 这是什么情况？ 这个是属于mabits 哪里缺乏配置么？

public Object intercept(Invocation invocation) throws Throwable { 
        processIntercept(invocation.getArgs()); 
        return invocation.proceed(); 
    } 

这是你struts2的问题吧、、、、
2 楼 dir_murong 2011-09-09  
问问lz 在下面这个方法里，一般反射调用的都是配置到xml配置文件里。但是我遇到如下的情况，dao层的数据offset和limit 还是我给的数据，蛋一走到这个方法里的时候，
invocation.getArgs()[2]的RowBounds对象所包含的offset和limit 就变成了0 和2147483647 这是什么情况？ 这个是属于mabits 哪里缺乏配置么？

public Object intercept(Invocation invocation) throws Throwable { 
        processIntercept(invocation.getArgs()); 
        return invocation.proceed(); 
    } 
1 楼 grandboy 2011-07-14  
这个主意不错，收藏一下。
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    spring+mybatis实现了物理分页

    本项目是基于Spring和MyBatis框架实现的物理分页，让我们来深入探讨这个主题。 首先，Spring是一个开源的Java应用程序框架，它提供了一种依赖注入（Dependency Injection，DI）的方式来管理对象，使得代码更加模块...

    mybatis分页jar

    PageHelper插件的核心是通过对SQL语句进行智能解析，自动添加分页条件，从而实现数据库的高效分页查询。在本例中，我们涉及到的版本是PageHelper 5.1.8，它应该包含了对各种数据库的良好支持和优化。 PageHelper...

    mybatis mysql分页实例（不能用找我）

    本实例将详细介绍如何在MyBatis中实现MySQL的分页查询，帮助开发者提高应用性能，提升用户浏览数据的体验。 首先，我们要理解分页的基本概念。分页是将大量数据分成多个小部分，每次只加载一部分到内存中，这样可以...

    springmvc+mybatis+easyUI分页后台代码

    本项目是基于SpringMVC、MyBatis和EasyUI这三大框架实现的后台分页功能，旨在提供一个高效、易用的解决方案。下面将详细介绍这三个技术以及它们如何协同工作来实现前端页面的分页。 首先，SpringMVC是Spring框架的...

    MyBatis 分页插件实现

    标题 "MyBatis 分页插件实现" 涉及的是在使用MyBatis这个流行的Java持久层框架时，如何实现高效且灵活的数据库分页功能。MyBatis本身并没有内置分页支持，但可以通过使用第三方插件来解决这个问题。其中，一种常见的...

    基于SpringMVC Mybatis框架实现分页

    在分页实现中，SpringMVC主要负责接收前端请求，传递参数到后台处理，以及返回响应结果。 Mybatis则是一个轻量级的持久层框架，它简化了SQL操作，通过XML或注解配置将Java对象与数据库表映射起来。在分页场景下，...

    spring-boot集成MyBatis与分页

    本文将详细介绍如何在Spring Boot项目中集成MyBatis，并实现分页功能。 首先，我们要在Spring Boot项目中引入MyBatis的相关依赖。在`pom.xml`文件中添加MyBatis、MyBatis-Spring Boot Starter以及MyBatis的分页插件...

    spring boot+mybatis+layui实现的项目基本框架

    在Spring Boot中，我们可以使用Pageable接口结合MyBatis的动态SQL来实现分页查询。在Layui中，分页组件与后端接口配合，提供用户友好的翻页体验。 7. **数据库文件的使用** 提供的数据库文件是项目运行的基础，...

    spring+springMVC+mybatis拦截器分页 源码

    综上所述，"spring+springMVC+mybatis拦截器分页"项目结合了三大框架的优势，通过SpringMVC的拦截器实现业务逻辑的扩展，利用MyBatis的分页插件处理后台数据，再由EasyUI提供友好的用户界面。这样的组合为高效且可控...

    SpringMVC+MyBatis+EasyUI简单分页Demo

    在本项目"SpringMVC+MyBatis+EasyUI简单分页Demo"中，我们将探讨如何结合这三种技术实现一个具备基本分页功能的Web应用。SpringMVC是Spring框架的一部分，负责处理HTTP请求和响应；MyBatis是一个轻量级的持久层框架...

    Mybatis PageHelper分页插件 v5.3.3.zip

    PageHelper插件通过自动拦截SQL语句，将分页参数转化为对应的分页SQL，大大简化了开发过程中的分页实现。 在Mybatis PageHelper v5.3.3版本中，我们可以期待一些重要的改进和优化，如性能提升、兼容性增强以及可能...

    ssm按条件实现后台分页

    SSM（Spring、SpringMVC、MyBatis）框架是Java Web开发中常见的技术栈，其在处理大数据量时，后台分页查询是一项基础且重要的功能。本篇将详细讲解如何在SSM环境下，根据条件实现后台分页，并结合MySQL数据库进行...

    mybatis分页插件源码

    MyBatis 分页插件是 MyBatis 框架中的一个重要组件，它允许开发者在进行数据查询时实现高效的分页功能，而无需修改原有的 SQL 查询语句或 DAO 层代码，因此被称为“非入侵式”。这个插件的源码分析可以帮助我们深入...

    spring+springMVC+mybatis+easyui 增删查改以及分页源码

    标题 "spring+springMVC+mybatis+easyui 增删查改以及分页源码" 描述了一个使用SSM（Spring、SpringMVC、MyBatis）框架与EasyUI前端库联合实现的Web应用项目，特别是关注于CRUD（创建、读取、更新、删除）操作和无...

    Spring Boot+Mybatis-Plus+Thymeleaf+Bootstrap分页页查询（前后端都有）.zip

    在本项目中，我们结合了Spring Boot、Mybatis-Plus、Thymeleaf以及Bootstrap来实现一个具有分页查询功能的Web应用。首先，让我们详细探讨每个技术在项目中的作用和实现方式。 **Spring Boot** Spring Boot是Spring...

    项目名称：商品信息显示系统 使用技术：Springmvc+spring+mybatis+Layui 实现功能： 1、完成ssm+layui的搭建整合 2、完成商

    项目名称：商品信息显示系统 使用技术：Springmvc+spring+mybatis+Layui 实现功能： 1、完成ssm+layui的搭建整合 2、完成商品的分页展示 特点：将后台mysql数据显示在layui页面上

    Ajax与JavaWeb后台分页

    在开发Web应用时，"Ajax与JavaWeb后台分页"是一个常见的需求，它涉及到前端与后端的数据交换以及用户界面的动态更新。Ajax（Asynchronous JavaScript and XML）是一种在不刷新整个页面的情况下与服务器交换数据并...

    springboot+mybatis+limit代码实现分页、web前端到后台、crud、搜索关键字、完整实例项目

    ### 分页实现 在本项目中，使用了`LIMIT`语句来实现分页查询。在Spring Boot中，这通常通过在MyBatis的Mapper接口中定义一个方法，接收页码和每页大小作为参数，然后在对应的Mapper XML文件中编写SQL查询，利用`...

    angularjs分页实例

    在本文中，我们将深入探讨AngularJS分页的实现方法，这是一种强大的前端JavaScript框架，用于构建交互式的Web应用程序。AngularJS的分页功能是提高大型数据集加载效率的关键，它允许用户逐步加载数据，而不是一次性...

    基于Spring+Mybatis+SpringMVC后台与前台PageHelper分页实例（带页面）.zip

    6. **分页实现步骤**： - 配置PageHelper：在项目的配置文件中引入PageHelper的依赖，设置数据库的相关参数。 - 创建Page对象：在后台创建Page对象，设置当前页码和每页显示的记录数。 - 调用PageHelper.start...

Magicbox
Global site tag (gtag.js) - Google Analytics