HBase学习之二: hbase分页查询

最新推荐文章于 2024-03-26 16:27:08 发布
最新推荐文章于 2024-03-26 16:27:08 发布
阅读量3.6w 收藏 35
点赞数 2
文章标签： filter hbase
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/javajxz008/article/details/51833982
版权

      在hbase中可以使用scan做一些简单的查询，但是要实现多条件复杂查询还需要借助filter(过滤器)来完成，甚至还可以自定义filter实现个性化的需求，项目中需要分页查询，记录了其中的核心代码，以便于查阅。

zookeeper.properties配置文件内容：

hbase_zookeeper_quorum=xxx.com,xxx.com,xxx.com
zookeeper_znode_parent=/hbase

zookeeper集群配置，一般hbase会交给zookeeper管理。

ConfigUtil为读取配置文件类：

package cp.app.batch.utils;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/**
 *
 * @author author
 *
 */

public class ConfigUtil {

	private Properties props = new Properties();

	public ConfigUtil(String file) {
	String path = ConfigUtil.class.getClassLoader()
	.getResource(file).getPath();
	InputStream is = null;
	try {
	is = new FileInputStream(path);
	props.load(is);
	} catch (IOException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
	} finally {
	try {
	is.close();
	} catch (IOException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
	}
	}
	}

	public int getInt(String key) {
	return Integer.parseInt(props.getProperty(key));
	}

	public String getString(String key) {
	return props.getProperty(key);
	}

}


HBase 查询工具类:

package cp.app.service.impl;

import java.io.IOException;
import java.io.InterruptedIOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.apache.commons.lang.StringUtils;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.MasterNotRunningException;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.TableNotFoundException;
import org.apache.hadoop.hbase.ZooKeeperConnectionException;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.HBaseAdmin;
import org.apache.hadoop.hbase.client.HConnection;
import org.apache.hadoop.hbase.client.HConnectionManager;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.client.HTableInterface;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.ResultScanner;
import org.apache.hadoop.hbase.client.RetriesExhaustedWithDetailsException;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.client.coprocessor.AggregationClient;
import org.apache.hadoop.hbase.client.coprocessor.LongColumnInterpreter;
import org.apache.hadoop.hbase.filter.BinaryComparator;
import org.apache.hadoop.hbase.filter.CompareFilter;
import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp;
import org.apache.hadoop.hbase.filter.Filter;
import org.apache.hadoop.hbase.filter.FilterList;
import org.apache.hadoop.hbase.filter.PageFilter;
import org.apache.hadoop.hbase.filter.RowFilter;
import org.apache.hadoop.hbase.filter.SingleColumnValueFilter;
import org.apache.hadoop.hbase.filter.SubstringComparator;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Service;

import cp.app.batch.utils.ConfigUtil;
import cp.app.comm.CpConstants;
import cp.app.service.HBaseService;

/**
 * HBase查询与插入操作工具类
 * 
 * @author author
 *
 */
 //采用注入方式，HBaseService为定义的查询接口，可不需要。 
@Service
public class HBaseServiceImpl implements HBaseService{

	private static Logger log = Logger.getLogger(HBaseServiceImpl.class.getName());

	static ConfigUtil util = new ConfigUtil("conf/zookeeper.properties");
	private static final String HBASE_ZOOKEEPER_QUORUM = util
			.getString("hbase_zookeeper_quorum");
	private static final String ZOOKEEPER_ZNODE_PARENT = util
			.getString("zookeeper_znode_parent");
	private static Configuration conf = HBaseConfiguration.create();
	static {
		conf.set("hbase.zookeeper.quorum", HBASE_ZOOKEEPER_QUORUM);
		conf.set("zookeeper.znode.parent", ZOOKEEPER_ZNODE_PARENT);
	}

	/**
	 * 创建表
	 * 
	 * @param tableName
	 *            表名
	 * @param columnFamily
	 *            列簇集合
	 * @return 成功-true 失败-false
	 */
	@SuppressWarnings("resource")
	public boolean createTable(String tableName, List<String> columnFamily) {
		try {
			if (StringUtils.isBlank(tableName) || columnFamily == null
					|| columnFamily.size() < 0) {
				log.error("===Parameters tableName|columnFamily should not be null,Please check!===");
			}
			HBaseAdmin admin = new HBaseAdmin(conf);
			if (admin.tableExists(tableName)) {
				return true;
			} else {
				HTableDescriptor tableDescriptor = new HTableDescriptor(
						TableName.valueOf(tableName));
				for (String cf : columnFamily) {
					tableDescriptor.addFamily(new HColumnDescriptor(cf));
				}
				admin.createTable(tableDescriptor);
				log.info("===Create Table " + tableName
						+ " Success!columnFamily:" + columnFamily.toString()
						+ "===");
			}
		} catch (MasterNotRunningException e) {
			// TODO Auto-generated catch block
			log.error(e);
			return false;
		} catch (ZooKeeperConnectionException e) {
			// TODO Auto-generated catch block
			log.error(e);
			return false;
		} catch (IOException e) {
			// TODO Auto-generated catch block
			log.error(e);
			return false;
		}
		return true;
	}

	/**
	 * 查询单条记录
	 * 
	 * @param tableName
	 *            表名
	 * @param rowKey
	 *            rowKey值
	 * @return 返回单条记录
	 */
	public List<Map<String, String>> selectOneByRowKey(String tableName,
			String rowKey) {
		if (StringUtils.isBlank(rowKey) || StringUtils.isBlank(tableName)) {
			log.error("===Parameters tableName|rowKey should not be blank,Please check!===");
			return null;
		}
		List<Map<String, String>> rowList = new ArrayList<Map<String, String>>();
		try {
			Get get = new Get(Bytes.toBytes(rowKey));
			HTableInterface hTable = getHTable(tableName);
			if (hTable != null) {
				Result result = hTable.get(get);
				Map<String, String> cellMap = getRowByResult(result);
				rowList.add(cellMap);
			}
			hTable.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			log.error(e);
		}
		return rowList;
	}

	/**
	 * 分页查询表数据
	 * 
	 * @param tableName
	 *            表名
	 * @param ddate
	 *            数据日期
	 * @param pageSize
	 *            页大小
	 * @param lastrowKey
	 *            起始rowkey值
	 * @return 返回查询数据结果集
	 */
	public List<Map<String, String>> selectAllByPage(String tableName,
			String ddate, int pageSize, String lastrowKey) {
		if (StringUtils.isBlank(tableName) || StringUtils.isBlank(ddate)
				|| StringUtils.isBlank(pageSize + "")
				|| StringUtils.isBlank(lastrowKey)) {
			log.error("===Parameters tableName|ddate|pageSize|rowKey should not be blank,Please check!===");
			return null;
		}
		HTable hTable = (HTable) getHTable(tableName);
		Scan scan = new Scan();
		FilterList filterList = new FilterList(
				FilterList.Operator.MUST_PASS_ALL);
		Filter rowFilter1 = new RowFilter(CompareFilter.CompareOp.EQUAL,
				new SubstringComparator(ddate));
		Filter pageFilter = new PageFilter(pageSize);
		filterList.addFilter(rowFilter1);
		filterList.addFilter(pageFilter);
		if (!CpConstants.ROWKEY_FIRST.equals(lastrowKey)) {
			Filter rowFilter2 = new RowFilter(CompareFilter.CompareOp.GREATER,
					new BinaryComparator(Bytes.toBytes(lastrowKey)));
			filterList.addFilter(rowFilter2);
		}
		scan.setFilter(filterList);
		List<Map<String, String>> lists = new ArrayList<Map<String, String>>();
		try {
			ResultScanner rs = hTable.getScanner(scan);
			for (Result result : rs) {
				lists.add(getRowByResult(result));
			}
			hTable.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			log.error(e);
		}
		return lists;
	}

	/**
	 * 根据状态分页查询表数据
	 * 
	 * @param tableName
	 *            表名
	 * @param ddate
	 *            数据日期
	 * @param pageSize
	 *            页大小
	 * @param lastrowKey
	 *            起始rowkey值
	 * @param status
	 *            发送状态
	 * @return 返回查询数据结果集
	 */
	public List<Map<String, String>> selectAllByPageStatus(String tableName,
			String ddate, int pageSize, String lastrowKey, String status) {
		if (StringUtils.isBlank(tableName) || StringUtils.isBlank(ddate)
				|| StringUtils.isBlank(pageSize + "")
				|| StringUtils.isBlank(lastrowKey)) {
			log.error("===Parameters tableName|ddate|pageSize|rowKey should not be blank,Please check!===");
			return null;
		}
		HTable hTable = (HTable) getHTable(tableName);
		Scan scan = new Scan();
		FilterList filterList = new FilterList(
				FilterList.Operator.MUST_PASS_ALL);
		filterList
				.addFilter(new SingleColumnValueFilter(Bytes.toBytes("info"),
						Bytes.toBytes("status"), CompareOp.EQUAL, Bytes
								.toBytes(status)));
		Filter rowFilter1 = new RowFilter(CompareFilter.CompareOp.EQUAL,
				new SubstringComparator(ddate));
		Filter pageFilter = new PageFilter(pageSize);
		filterList.addFilter(rowFilter1);
		filterList.addFilter(pageFilter);
		if (!CpConstants.ROWKEY_FIRST.equals(lastrowKey)) {
			Filter rowFilter2 = new RowFilter(CompareFilter.CompareOp.GREATER,
					new BinaryComparator(Bytes.toBytes(lastrowKey)));
			filterList.addFilter(rowFilter2);
		}
		scan.setFilter(filterList);
		List<Map<String, String>> lists = new ArrayList<Map<String, String>>();
		try {
			ResultScanner rs = hTable.getScanner(scan);
			for (Result result : rs) {
				lists.add(getRowByResult(result));
			}
			hTable.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			log.error(e);
		}
		return lists;
	}

	/**
	 * 获取页数
	 * 
	 * @param tableName
	 *            表名
	 * @param ddate
	 *            数据日期
	 * @param pageSize
	 *            分页大小
	 * @return 返回页数
	 */
	public int getPages(String tableName, String ddate, int pageSize) {
		if (StringUtils.isBlank(tableName) || StringUtils.isBlank(ddate)
				|| StringUtils.isBlank(pageSize + "")) {
			log.error("===Parameters tableName|ddate|pageSize should not be blank,Please check!===");
			return 0;
		}
		enableAggregation(tableName);
		int total = 0;
		try {
			HTable hTable = (HTable) getHTable(tableName);
			Scan scan = new Scan();
			Filter rowFilter = new RowFilter(CompareFilter.CompareOp.EQUAL,
					new SubstringComparator(ddate));
			scan.setFilter(rowFilter);
			AggregationClient aggregation = new AggregationClient(conf);
			Long count = aggregation.rowCount(hTable,
					new LongColumnInterpreter(), scan);
			total = count.intValue();
			hTable.close();
		} catch (Throwable e) {
			// TODO Auto-generated catch block
			log.error(e);
		}
		return (total % pageSize == 0) ? total / pageSize
				: (total / pageSize) + 1;
	}

	/**
	 * 根据发送状态获取页数
	 * 
	 * @param tableName
	 *            表名
	 * @param ddate
	 *            数据日期
	 * @param pageSize
	 *            分页大小
	 * @param status
	 *            发送状态
	 * @return 返回页数
	 */
	public int getPagesByStatus(String tableName, String ddate, int pageSize,
			String status) {
		if (StringUtils.isBlank(tableName) || StringUtils.isBlank(ddate)
				|| StringUtils.isBlank(pageSize + "")
				|| StringUtils.isBlank(status)) {
			log.error("===Parameters tableName|ddate|pageSize|status should not be blank,Please check!===");
			return 0;
		}
		enableAggregation(tableName);
		int total = 0;
		try {
			HTable hTable = (HTable) getHTable(tableName);
			Scan scan = new Scan();
			FilterList filterList = new FilterList(
					FilterList.Operator.MUST_PASS_ALL);
			Filter rowFilter = new RowFilter(CompareFilter.CompareOp.EQUAL,
					new SubstringComparator(ddate));
			filterList.addFilter(rowFilter);
			filterList.addFilter(new SingleColumnValueFilter(Bytes
					.toBytes("info"), Bytes.toBytes("status"), CompareOp.EQUAL,
					Bytes.toBytes(status)));
			scan.setFilter(filterList);
			AggregationClient aggregation = new AggregationClient(conf);
			Long count = aggregation.rowCount(hTable,
					new LongColumnInterpreter(), scan);
			total = count.intValue();
			hTable.close();
		} catch (Throwable e) {
			// TODO Auto-generated catch block
			log.error(e);
		}
		return (total % pageSize == 0) ? total / pageSize
				: (total / pageSize) + 1;
	}

	/**
	 * 获取同一个rowkey下的记录集合
	 * 
	 * @param result
	 *            结果集
	 * @return
	 */
	private Map<String, String> getRowByResult(Result result) {
		if (result == null) {
			log.error("===Parameter |result| should not be null,Please check!===");
			return null;
		}
		Map<String, String> cellMap = new HashMap<String, String>();
		for (Cell cell : result.listCells()) {
			String rowkey = Bytes.toString(cell.getRowArray(),
					cell.getRowOffset(), cell.getRowLength());
			String cf = Bytes.toString(cell.getFamilyArray(),
					cell.getFamilyOffset(), cell.getFamilyLength());
			String qf = Bytes.toString(cell.getQualifierArray(),
					cell.getQualifierOffset(), cell.getQualifierLength());
			String value = Bytes.toString(cell.getValueArray(),
					cell.getValueOffset(), cell.getValueLength());
			cellMap.put(CpConstants.HBASE_TABLE_PROP_ROWKEY, rowkey);
			cellMap.put(CpConstants.HBASE_TABLE_PROP_COLUMNFAMILY, cf);
			cellMap.put(qf, value);
		}
		return cellMap;
	}

	/**
	 * 获取HTableInterface
	 * 
	 * @param tableName
	 *            表名
	 * @return 返回HTableInterface实例
	 */
	private HTableInterface getHTable(String tableName) {
		if (StringUtils.isBlank(tableName)) {
			log.error("===Parameter |tableName| should not be blank,Please check!===");
			return null;
		}
		HTableInterface hTable = null;
		try {
			HConnection conn = HConnectionManager.createConnection(conf);
			hTable = conn.getTable(Bytes.toBytes(tableName));
		} catch (IOException e) {
			// TODO Auto-generated catch block
			log.error(e);
			return null;
		}
		return hTable;
	}

	/**
	 * 批量插入或更新
	 * 
	 * @param tableName
	 *            表名
	 * @param paraList
	 *            组装成json或xml后的参数
	 * @return 成功-true 失败-false
	 */
	public boolean batchPut(String tableName, List<Map<String, String>> paraList) {
		try {
			List<Put> puts = new ArrayList<Put>();
			for (Map<String, String> map : paraList) {
				Put put = getPutByMap(map);
				puts.add(put);
			}
			HTable hTable = (HTable) getHTable(tableName);
			hTable.put(puts);
			hTable.close();
		} catch (RetriesExhaustedWithDetailsException e) {
			// TODO Auto-generated catch block
			log.error(e);
			return false;
		} catch (InterruptedIOException e) {
			// TODO Auto-generated catch block
			log.error(e);
			return false;
		} catch (IOException e) {
			// TODO Auto-generated catch block
			log.error(e);
			return false;
		}
		return true;
	}

	/**
	 * 根据map返回put
	 * 
	 * @param paraMap
	 *            参数map
	 * @return 返回put
	 */
	private Put getPutByMap(Map<String, String> paraMap) {
		if (paraMap == null) {
			log.error("===Parameter |paraMap| should not be null,Please check!===");
			return null;
		}
		Set<Entry<String, String>> set = paraMap.entrySet();
		Iterator<Entry<String, String>> it = set.iterator();
		byte[] rowkey = Bytes.toBytes(paraMap
				.get(CpConstants.HBASE_TABLE_PROP_ROWKEY));
		byte[] columnfamily = Bytes.toBytes(paraMap
				.get(CpConstants.HBASE_TABLE_PROP_COLUMNFAMILY));
		Put put = new Put(rowkey);
		while (it.hasNext()) {
			Entry<String, String> entry = it.next();
			String key = entry.getKey();
			if (!CpConstants.HBASE_TABLE_PROP_ROWKEY.equals(key)
					&& !CpConstants.HBASE_TABLE_PROP_COLUMNFAMILY.equals(key)) {
				String value = entry.getValue();
				put.add(columnfamily, Bytes.toBytes(key), Bytes.toBytes(value));
			}
		}
		return put;
	}

	/**
	 * 使表具有聚合功能
	 * 
	 * @param tableName
	 *            表名
	 */
	@SuppressWarnings("resource")
	private void enableAggregation(String tableName) {
		String coprocessorName = "org.apache.hadoop.hbase.coprocessor.AggregateImplementation";
		try {
			HBaseAdmin admin = new HBaseAdmin(conf);
			HTableDescriptor htd = admin.getTableDescriptor(Bytes
					.toBytes(tableName));
			List<String> coprocessors = htd.getCoprocessors();
			if (coprocessors != null && coprocessors.size() > 0) {
				return;
			} else {
				admin.disableTable(tableName);
				htd.addCoprocessor(coprocessorName);
				admin.modifyTable(tableName, htd);
				admin.enableTable(tableName);
			}
		} catch (TableNotFoundException e) {
			// TODO Auto-generated catch block
			log.error(e);
		} catch (MasterNotRunningException e) {
			// TODO Auto-generated catch block
			log.error(e);
		} catch (ZooKeeperConnectionException e) {
			// TODO Auto-generated catch block
			log.error(e);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			log.error(e);
		}
	}
}


 

anickname
关注
  • 2
    点赞
  • 踩
  • 35
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
hbase分页查询实现
09-09
hbase分页查询实现
hbase查询分页分页
04-18
hbase查询分页分页
Hbase分页查询踩坑记录
最新发布
qq_44780681的博客
03-26 181
Hbase分页问题
【HBase入门与实战】一文搞懂HBase!
Byyyi耀的博客
03-16 1105
1.HBase的引入、定义和特点 2.NoSQL数据库的概念和与关系型数据库的区别 3.HBase的物理架构和逻辑架构 4.HBase Shell的基本命令使用 5.HBase的应用场景
hbase java api 访问 查询、分页
11-24
hbase java api 访问 查询、分页 详情请看：http://blog.csdn.net/wild46cat/article/details/53321409
hbase分页查询实现.pdf
07-14
hbase分页查询实现.pdf
HBase分页
lijiale的博客
05-28 2544
HBase 分页 前言 最近接到了一个HBase查询数据分页的需求，了解HBase的小伙伴都知道，HBase做分页想做到与MySql/Oracle那样灵活还是有些困难的，常见的分页所包含的功能一般都有：上一页、下一页、页码跳转、首页、尾页。上一页、下一页、首页这三个HBase实现起来虽然有些麻烦但也还不是不能实现，但是页码跳转与跳转到尾页这个对于HBase来说确实有些尴尬了，做大数据方面也都知道我们做HBase查询一般都是使用Scan配合Filter通过对Rowkey过滤检索的方式实现，当然也有使用Phoe
HBase2.1.0分页查询（支持跳页）
ASN_forever的博客
12-31 3652
HBase分页 hbase中的数据是按照rowkey字典排序存储的，实现分页的思路有两个，一个是获取页面的起始rowkey，然后使用PageFilter来限制每页的数量。 另一种是获取页面的起始rowkey和结束rowkey，然后直接调用scan的withStartRow和withStopRow查询即可。 方案一、PageFilter hbase中有自带的PageFilter，能够实现分页功能，但是局限性很大，实际很少使用。 就是说，PageFilter的作用域是单个的region，会从每个r
hbase分页查询实现_MyBatis Plus 的多表联接、分页查询实现方法
weixin_31444881的博客
01-14 473
一、引入之前做一个学生教师学习交流平台，DAO 层使用了 MyBatisPlus，里边有一个类似百度贴吧的发帖子的功能：而如果设计表，应为帖子表t_postidtitle标题content内容user_id 用户外键xx ...用户表t__useridname帖子发起者名字xx ...示例图中红色框中的内容为t_user表的字段name， 而要实现上面显示帖子，就要用到...
记录一次HBase的scan的分页查询
chun的博客
11-24 2944
修改前任bug，Hbase查询过于慢了，以至于都查不出来了，看了代码发现使用的Scan只设置了withStartRow、withEndRow、setCaching扫描,拿到全部数据后存入集合再subList进行分页，但是HBase中存在某些数据有几百万条，根本scan不出来了。 前任设置如下： 其中start 和 end 拼接0和z是因为HBase中RowKey按照字典顺序排序， String start = rowKey + "0"; String end = rowKey + "z"; Scan sca
hbase java 分页查询_hbase数据java后端分页查询
weixin_33364925的博客
02-13 273
public PageQueryResult queryUserLoginLogList(PageQueryParam pageQueryParam,LoginLogRequest loginLogRequest) {FilterList filterList=new FilterList();Filter pageFilter = new PageFilter(1000);//最多1000条fi...
HBaseClient:HBase客户端数据管理软件
05-12
HBaseClient HBase客户端数据管理软件 概要说明 类似PL/SQL，是一个HBase数据库的客户端数据管理软件。是免费开源的软件。 基于XJava，使用xml配置文件绘制可视化界面。 可视化界面操作 表 表的定义、编辑、删除； 数据 数据的添加、编辑、删除； 数据的全部清空、多条删除、多条复制； 查询 主键的精确； 关键字的模糊查询 关键字的模糊查询过滤显示; 数据查询结果的分页显示操作，并且对查询关键字高亮显示； 导出 表结构的导出； 表结构及数据的导出； 导入 文件批量put命令导入(支持中文) 批量put命令执行(支持中文) 非可视化界面的命令操作 HBase命令的执行 导入 文件批量put命令导入(支持中文) 批量put命令执行(支持中文) 下载 date version size support 2018-05-24 65.9M 支持HBase 1.x 2018-0
HBase分页查询性能测试ppt
07-24
里面包括了特定场合下，HBase随机查询的一些性能指标参考以及调优策略
hbase-page:hbase 分页
07-10
hbase-page hbase 分页
hbase分页查询实现[归类].pdf
10-11
hbase分页查询实现[归类].pdf
HBase分页查询的rowkey设计技巧
09-20
用户历史订单列表查询rowkey设计技巧 最左前缀原则
MySqlToHbase数据分页导入到Hbase.zip
05-16
项目中自己用的,弄了很久,需要把数据从各种数据源导入到,我们的原始数据库,原始数据库采用hbase,来存储所有数据,那么这里就用的nifi,从其他数据源获取数据以后,然后导入到Hbase中去,这个是设计好的流程模板. ...
springboot-hbase:以简单的订单业务示例hbse的使用&redis设计hbase查询分页
05-17
hbase 示例:订单设计&分页设计实效crud接口
java操作Hbase之Hbase专用过滤器PageFilter的使用源代码
01-17
java操作Hbase之Hbase专用过滤器PageFilter的使用源代码，附带全部所需源代码，欢迎下载学习。
hbase 分页查询
05-31
HBase是一种分布式的NoSQL数据库，它并不支持传统的SQL语句，但它提供了Scan类来进行数据的扫描和检索。在HBase中实现分页查询需要结合Scan类和分页参数来完成。 以下是在HBase中进行分页查询的步骤： 1. 创建Scan对象，设置起始行和结束行。 2. 设置分页参数，包括每页数据条数和当前页码。 3. 遍历Scan对象获取结果集，并计算偏移量和限制条数。 4. 对结果集进行分页处理，返回分页数据。 下面是一个示例代码，实现了在HBase中进行分页查询的功能： ```java // 创建Scan对象 Scan scan = new Scan(); scan.setStartRow(Bytes.toBytes(startRow)); scan.setStopRow(Bytes.toBytes(stopRow)); // 设置分页参数 int pageSize = 10; int pageNum = 1; // 计算偏移量和限制条数 int offset = (pageNum - 1) * pageSize; int limit = pageSize; // 遍历Scan对象获取结果集 ResultScanner scanner = table.getScanner(scan); Result[] results = scanner.next(limit + offset); // 对结果集进行分页处理 List<Map<String, Object>> pageData = new ArrayList<>(); for (int i = offset; i < results.length && i < offset + limit; i++) { Result result = results[i]; Map<String, Object> rowData = new HashMap<>(); for (Cell cell : result.rawCells()) { rowData.put(Bytes.toString(CellUtil.cloneQualifier(cell)), Bytes.toString(CellUtil.cloneValue(cell))); } pageData.add(rowData); } ``` 在上面的示例代码中，我们使用了HBase的Scan类来进行数据的扫描和检索，并结合分页参数和偏移量来完成分页查询的功能。注意，这里的分页查询是基于行级别的，而非基于列级别的。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值