mybatis分页实现2

最新推荐文章于 2022-08-12 10:35:37 发布
最新推荐文章于 2022-08-12 10:35:37 发布 · 313 阅读 · 0
文章标签：

#Spring #SQL #ITeye #XML

前一篇写了如何实现sql分页
[url]http://icefire.iteye.com/blogs/1028915[/url]

[quote]本文对直接使用sqlsession的方式无参考价值，本文只针对只写接口和XML文件的方式[/quote]

这一篇讲，如何实现一个mapping的方法访问，自动返回page数据，也就是自读计算分页总数。

先看成果对比效果
原先 

public interface HelloMapping {

	public List<Hello> findAll(RowBounds rowBounds);

	public Long findAllCount();
}


public String list(@ModelAttribute Pagination<Hello> pagination,Model model) {

	pagination.setTotal(helloMapping.findAllCount());
	pagination.setList(helloMapping.findAll(pagination.newRowBounds())));
	model.addAttribute("paging", pagination);

	return "/hello/view/list";
}


现在 

public interface HelloMapping {

	public Pagination<Hello> findAll(Pagination<Hello> pagination);
}


public String list(@ModelAttribute Pagination<Hello> pagination,Model model) {

	model.addAttribute("paging", helloMapping.findAll(pagination));

	return "/hello/view/list";
}


如果看源码，会发现，mapping接口自动代理涉及Configuration，MapperRegistry，MapperProxy，MapperMethod。
其中比较可惜的是，MapperProxy，MapperMethod完全无法重用，只能参考其中代码自己来实现了。还有那个mybatis通过的spring集成类SqlSessionFactoryBean，由于要实现自己Configuration，也导致SqlSessionFactoryBean无法重用。这点上，和spring比较起来，就差太多了。

MyConfiguration 

public class MyConfiguration extends Configuration {

	protected MapperRegistry mapperRegistry = new PaginationMapperRegistry(this);

	public <T> void addMapper(Class<T> type) {
		mapperRegistry.addMapper(type);
	}

	public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
		return mapperRegistry.getMapper(type, sqlSession);
	}

	@SuppressWarnings("rawtypes")
	public boolean hasMapper(Class type) {
		return mapperRegistry.hasMapper(type);
	}
}


PaginationMapperRegistry 

public class PaginationMapperRegistry extends MapperRegistry {

	public PaginationMapperRegistry(Configuration config) {
		super(config);
	}

	public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
		if (!hasMapper(type)) {
			throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
		}
		try {
			return PaginationMapperProxy.newMapperProxy(type, sqlSession);
		} catch (Exception e) {
			throw new BindingException("Error getting mapper instance. Cause: " + e, e);
		}
	}

}


PaginationMapperProxy 

public class PaginationMapperProxy implements InvocationHandler {

	private static final Set<String> OBJECT_METHODS = new HashSet<String>() {
		private static final long serialVersionUID = -1782950882770203583L;
		{
			add("toString");
			add("getClass");
			add("hashCode");
			add("equals");
			add("wait");
			add("notify");
			add("notifyAll");
		}
	};

	private boolean isObjectMethod(Method method) {
		return OBJECT_METHODS.contains(method.getName());
	}

	private SqlSession sqlSession;

	private <T> PaginationMapperProxy(SqlSession sqlSession) {
		this.sqlSession = sqlSession;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		if (isObjectMethod(method)) {
			return null;
		}
		final Class<?> declaringInterface = findDeclaringInterface(proxy, method);
		if (Pagination.class.isAssignableFrom(method.getReturnType())) {
			// 分页处理
			return new PaginationMapperMethod(declaringInterface, method, sqlSession).execute(args);
		}
		// 原处理方式
		final MapperMethod mapperMethod = new MapperMethod(declaringInterface, method, sqlSession);
		final Object result = mapperMethod.execute(args);
		if (result == null && method.getReturnType().isPrimitive()) {
			throw new BindingException(
					"Mapper method '"
							+ method.getName()
							+ "' ("
							+ method.getDeclaringClass()
							+ ") attempted to return null from a method with a primitive return type ("
							+ method.getReturnType() + ").");
		}
		return result;
	}

	private Class<?> findDeclaringInterface(Object proxy, Method method) {
		Class<?> declaringInterface = null;
		for (Class<?> iface : proxy.getClass().getInterfaces()) {
			Method m = ReflectionUtils.findMethod(iface, method.getName(), method.getParameterTypes());
			if (m != null) {
				declaringInterface = iface;
			}
		}
		if (declaringInterface == null) {
			throw new BindingException(
					"Could not find interface with the given method " + method);
		}
		return declaringInterface;
	}

	@SuppressWarnings("unchecked")
	public static <T> T newMapperProxy(Class<T> mapperInterface,
			SqlSession sqlSession) {
		ClassLoader classLoader = mapperInterface.getClassLoader();
		Class<?>[] interfaces = new Class[] { mapperInterface };
		PaginationMapperProxy proxy = new PaginationMapperProxy(sqlSession);
		return (T) Proxy.newProxyInstance(classLoader, interfaces, proxy);
	}

}


PaginationMapperMethod 

public class PaginationMapperMethod {

	private SqlSession sqlSession;
	private Configuration config;

	private SqlCommandType type;
	private String commandName;
	private String commandCountName;

	private Class<?> declaringInterface;
	private Method method;

	private Integer rowBoundsIndex;
	private Integer paginationIndex;
	private List<String> paramNames;
	private List<Integer> paramPositions;

	private boolean hasNamedParameters;

	public PaginationMapperMethod(Class<?> declaringInterface, Method method,
			SqlSession sqlSession) {
		paramNames = new ArrayList<String>();
	    paramPositions = new ArrayList<Integer>();
	    this.sqlSession = sqlSession;
	    this.method = method;
	    this.config = sqlSession.getConfiguration();
	    this.hasNamedParameters = false;
	    this.declaringInterface = declaringInterface;
	    setupFields();
	    setupMethodSignature();
	    setupCommandType();
	    validateStatement();
	}

	@SuppressWarnings({ "unchecked", "rawtypes" })
	public Object execute(Object[] args) {
		final Object param = getParam(args);
		Pagination<Object> page;
		RowBounds rowBounds;
		if (paginationIndex != null) {
			page = (Pagination) args[paginationIndex];
			rowBounds = page.newRowBounds();
		}
		else if (rowBoundsIndex != null) {
			rowBounds = (RowBounds) args[rowBoundsIndex];
			page = new Pagination<Object>(rowBounds);
		}
		else {
			throw new BindingException("Invalid bound statement (not found rowBounds or pagination in paramenters)");
		}
		page.setTotal(executeForCount(param));
		page.setList(executeForList(param, rowBounds));
		return page;
	}

	private long executeForCount(Object param) {
		Number result = (Number) sqlSession.selectOne(commandCountName, param);
		return result.longValue();
	}

	@SuppressWarnings("rawtypes")
	private List executeForList(Object param, RowBounds rowBounds) {
		return sqlSession.selectList(commandName, param, rowBounds);
	}

	private Object getParam(Object[] args) {
		final int paramCount = paramPositions.size();
		if (args == null || paramCount == 0) {
			return null;
		} else if (!hasNamedParameters && paramCount == 1) {
			return args[paramPositions.get(0)];
		} else {
			Map<String, Object> param = new HashMap<String, Object>();
			for (int i = 0; i < paramCount; i++) {
				param.put(paramNames.get(i), args[paramPositions.get(i)]);
			}
			return param;
		}
	}

	private void setupMethodSignature() {
		final Class<?>[] argTypes = method.getParameterTypes();
		for (int i = 0; i < argTypes.length; i++) {
			if (Pagination.class.isAssignableFrom(argTypes[i])) {
				paginationIndex = i;
			}
			else if (RowBounds.class.isAssignableFrom(argTypes[i])) {
				rowBoundsIndex = i;
			} else {
				String paramName = String.valueOf(paramPositions.size());
				paramName = getParamNameFromAnnotation(i, paramName);
				paramNames.add(paramName);
				paramPositions.add(i);
			}
		}
	}

	private String getParamNameFromAnnotation(int i, String paramName) {
		Object[] paramAnnos = method.getParameterAnnotations()[i];
		for (Object paramAnno : paramAnnos) {
			if (paramAnno instanceof Param) {
				hasNamedParameters = true;
				paramName = ((Param) paramAnno).value();
			}
		}
		return paramName;
	}

	private void setupFields() {
		commandName = declaringInterface.getName() + "." + method.getName();
		commandCountName = commandName + "Count"; // 命名约定
	}

	private void setupCommandType() {
		MappedStatement ms = config.getMappedStatement(commandName);
		type = ms.getSqlCommandType();
		if (type != SqlCommandType.SELECT) {
			throw new BindingException("Unsupport execution method for: " + commandName);
		}
	}

	private void validateStatement() {
		if (!config.hasStatement(commandName)) {
			throw new BindingException("Invalid bound statement (not found): " + commandName);
		}
		if (!config.hasStatement(commandCountName)) {
			throw new BindingException("Invalid bound statement (not found): " + commandCountName);
		}
	}

}


具体某个查询的SQL配置 


<select id="findAll" resultMap="helloResultMap">
	select * from HELLO
</select>

<select id="findAllCount" resultType="long">
	select count(*) from HELLO
</select>


补代码Pagination，分页辅助类 

public class Pagination<T> {

	private long total;

	private int pagesize;

	private List<T> list = Collections.emptyList();

	private int offset;

	private int limit;

	private int page;

	public Pagination() {
		this(1, 15);
	}

	public Pagination(int page) {
		this(page, 15);
	}

	public Pagination(int page, int limit) {
		setPage(page);
		setLimit(limit);
	}

	public Pagination(RowBounds rowBounds) {
		this.limit = rowBounds.getLimit();
		this.offset = rowBounds.getOffset();
		this.page = offset / limit + 1;
	}

	public void setPage(int page) {
		if (page < 0) {
			page = 1;
		}
		this.page = page;
		onInit();
	}

	public void setLimit(int limit) {
		if (limit < 1) {
			limit = 15;
		}
		this.limit = limit;
		onInit();
	}

	protected void onInit() {
		offset = (page - 1) * limit;
	}

	protected void onSetRowsize() {
		pagesize = (int) (total / limit);
		if (total % limit > 0) {
			pagesize ++;
		}
		if (page > pagesize) {
			page = pagesize;
			onInit();
		}
	}

	protected void onSetList() {
		if (list == null || list.isEmpty()) {
			total = 0;
			page = 1;
			offset = 0;
		}
	}

	public long getTotal() {
		return total;
	}

	public void setTotal(long rowsize) {
		this.total = rowsize;
		onSetRowsize();
	}

	public int getPagesize() {
		return pagesize;
	}

	public List<T> getList() {
		return list;
	}

	public void setList(List<T> list) {
		this.list = list;
		onSetList();
	}

	public int getOffset() {
		return offset;
	}

	public int getLimit() {
		return limit;
	}

	public int getPage() {
		return page;
	}

	public RowBounds newRowBounds() {
		return new RowBounds(getOffset(), getLimit());
	}
}

目前无可避免的需要两段sql。在考虑如何实现自动生成count(*)，但目前做到这样，已经达到自己的预期了。暂时先就这样吧！
mybatis - 接口代理实现dao层 动态sql 分页和多表操作
qq_45181415的博客
02-03 604
一.接口代理方式实现Dao 1.1 代理开发方式介绍 ​ 采用 Mybatis 的代理开发方式实现 DAO 层的开发，这种方式是我们后面进入企业的主流。 Mapper 接口开发方法只需要程序员编写Mapper 接口（相当于Dao 接口），由Mybatis 框架根据接口定义创建接口的动态代理对象，代理对象的方法体同上边Dao接口实现类方法。 Mapper 接口开发需要遵循以下规范： 1) Mapper.xml文件中的namespace与mapper接口的全限定名相同 2) Mapper接口方法名和Mapper
使用 MyBatis 分页插件实现数据分页
最新发布
FireFox1997
06-18 738
分页是指将大量数据按一定的规则分成若干页，每页显示固定数量的数据。通过分页，用户可以逐页查看数据，而不用一次性加载所有数据，提高了系统性能和用户体验。分页是实际开发中非常常见的需求，MyBatis 提供了多种分页插件来简化分页操作。本文介绍了如何使用 PageHelper 和 MyBatis-Plus 两种常用的分页插件，并通过示例代码展示了它们的使用方法。选择合适的分页插件，可以大大简化分页逻辑，提升开发效率。通过合理的分页策略，可以提高系统性能和用户体验。
mybatis02(动态sql及分页)
weixin_67338832的博客
08-12 194
注意事项：使用resultMap返回自定义类型集合使用resultType返回List使用resultType返回单个对象使用resultType返回List，适用于多表查询返回结果集使用resultType返回Map，适用于多表查询返回单个结果集。
mybatis如何实现分页功能?
weixin_30301183的博客
09-12 184
1）原始方法，使用limit，需要自己处理分页逻辑： 对于mysql数据库可以使用limit，如： select * from table limit 5,10; --返回6-15行 对于oracle数据库可以使用rownum，如： --如：从表Sys_option（主键为sys_id)中从第10条记录开始检索20条记录，语句如下 SELECT * FROM (SELECT ROWNUM...
MyBatis学习笔记（二）使用MyBatis实现分页显示
IcyDate的博客
04-07 657
使用MyBatis分页，需要掌握两点知识1、limit子句的使用。2、MyBatis多参数传递的使用。首先简单阐述一下limit子句limit子句在MySQL中用于进行分页，将多条记录限制条数来显示，一般用法：SELECT * FROM table LIMIT 0,30代表起始索引，3代表要显示的条数，所以上面的SQL就是要显示1-3条记录。在此基础上，我们引入两个变量：currentPage(当...
如何使用Mybatis来实现分页功能的两种方法
王伟的博客
03-19 2万+
1. 使用Map来进行包装数据实现分页功能 1),在SQL语句映射的ResultType返回的是你要查询得到的实体类 2),穿进去的参数parameterType是你自己包装的Map类型 3),首先你传进来的参数要和SQL语句中的字段名要保持一致 4),在实体DAO层还需要把查询数据的起始下标，和查询多少条数据都put进Map中 ...
06实现mybatis分页插件demo
04-22
06实现mybatis分页插件demo06实现mybatis分页插件demo06实现mybatis分页插件demo06实现mybatis分页插件demo06实现mybatis分页插件demo06实现mybatis分页插件demo06实现mybatis分页插件demo06实现mybatis分页插件demo...
mybatis分页实现1
08-08
MyBatis 提供了两种主要的分页实现方法：一种是通过在 Mapper XML 文件中直接编写分页 SQL，另一种是利用 MyBatis 的插件机制，如 PageHelper 插件，进行拦截器实现分页。这里我们主要讨论第一种方法，即“普通的...
mybatis分页效果实现代码
08-30
在MyBatis中实现分页效果，通常有两种方式：一种是手动实现，另一种是使用分页插件。这里我们将详细探讨这两种方法。 首先，我们来看看手动实现分页的方法。手动分页主要是通过在SQL语句中添加LIMIT和OFFSET子句来...
几种常见mybatis分页实现
热门推荐
feinifi的博客
03-23 13万+
mybatis框架分页实现，有几种方式，最简单的就是利用原生的sql关键字limit来实现，还有一种就是利用interceptor来拼接sql，实现和limit一样的功能，再一个就是利用PageHelper来实现。这里讲解这三种常见的实现方式： 无论哪种实现方式，我们返回的结果，不能再使用List了，需要一个自定义对象Pager。 package com.xxx.mybatis.bean; ...
Mybatis分页实现
简书的专栏
08-01 9501
一、引言 Mybatis提供了强大的分页拦截实现，可以完美的实现分功能 二、普通的分页实现 普通分页实现即使直接在mapper文件中写分页查询语句 Messsage.xml <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-
mybatis的源码分析
qq_20610631的博客
06-25 288
文章声明：仅供个人学习 Mybatis 教程网址： https://www.yiibai.com/mybatis/mybatis_print_out_sql.html mybatis 项目举例 1 创建db_mybatis 的脚本 /* SQLyog 企业版 - MySQL GUI v8.14 MySQL - 5.1.49-community : Database - db_mybatis *...
2.19.1-mybatis-plus分页源码分析
KelvinLiu
06-07 3012
mybatis plus 分页源码分析
SpringBoot 2.x 整合Mybatis二：PageHelper分页
赵彦军
06-15 1万+
转载请标明出处：http://blog.youkuaiyun.com/zhaoyanjun6/article/details/75647437 本文出自【赵彦军的博客】 Mybatis-PageHelper 简介 PageHelper 最方便使用的分页插件，支持多种数据库： Oracle Mysql MariaDB SQLite Hsqldb PostgreSQL DB2 SqlSe...
Mybatis(三)—接口实现增删改查和分页查询
育奕的个人博客
01-06 908
一 创建UserMapper接口 package com.yuyi.mapper; import java.util.List; import org.apache.ibatis.annotations.Delete; import org.apache.ibatis.annotations.Insert; import org.apache....
mybatis-plus配置找不到Mapper接口路径的坑
又听凌晨的钟声
06-28 7万+
mybatis-plus今天遇到一个问题，就是mybatis 没有读取到mapper.xml 文件。 特此记录一下，问题如下： org.apache.ibatis.binding.BindingException: Invalid bound statement (not found): com.husy.mapper.SystemUserMapper.findUserByName at co...
分页查询缓存（代理模式）
how2js的博客
03-21 803
缓存代理 对于多次重复的操作，可以使用缓存代理的形式进行缓存（代理模式的知识，可以看我另外一篇文章设计模式-代理模式），在分页查询中，对于相同的分页，我们不希望进行重复的请求，毕竟ajax是非常消耗性能的，这个时候就可以使用缓存代理对象，当存在缓存时直接使用缓存进行获取，当不存在时才将请求交还给ajax对象。 在分页查询中的优化 在ajax中应用缓存代理，由于ajax异步的原因，所以会使用到回调或...
springBoot:Invalid bound statement (not found): com.hry.seckill.mapper.GoodsMapper.getGoodsVoList
longzhongxiaoniao的博客
01-07 537
在学习springBoot做秒杀项目的时候遇到了 “ Invalid bound statement (not found): com.hry.seckill.mapper.GoodsMapper.getGoodsVoList”的错误。 错误提示： org.apache.ibatis.binding.BindingException: Invalid bound statement (not...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值