Hbase本身是没有分页查询的，我在网上找了很多资料来实现一个分页功能，在这里做了一下记录，分享给大家，有什么不足之处，请尽管指出。废话不多说，看代码。

import java.io.IOException;

import java.util.LinkedHashMap;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

import org.apache.commons.lang.StringUtils;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.hbase.HBaseConfiguration;

import org.apache.hadoop.hbase.client.Get;

import org.apache.hadoop.hbase.client.HTableInterface;

import org.apache.hadoop.hbase.client.HTablePool;

import org.apache.hadoop.hbase.client.Result;

import org.apache.hadoop.hbase.client.ResultScanner;

import org.apache.hadoop.hbase.client.Scan;

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.FirstKeyOnlyFilter;

import org.apache.hadoop.hbase.filter.SingleColumnValueFilter;

import org.apache.hadoop.hbase.util.Bytes;

publicclass HBaseUtils {

    privatestatic Configuration config = null;

    privatestatic HTablePool tp = null;

    static {

        // 加载集群配置

        config = HBaseConfiguration.create();

        config.set("hbase.zookeeper.quorum", "xx.xx.xx");

        config.set("hbase.zookeeper.property.clientPort", "2181");

        // 创建表池(可伟略提高查询性能，具体说明请百度或官方API)

        tp = new HTablePool(config, 10);

    }

    /*

     * 获取hbase的表

     */

    publicstatic HTableInterface getTable(StringtableName) {

        if (StringUtils.isEmpty(tableName))

            returnnull;

        returntp.getTable(getBytes(tableName));

    }

    /* 转换byte数组 */

    publicstaticbyte[] getBytes(String str) {

        if (str == null)

            str= "";

        return Bytes.toBytes(str);

    }

    /**

     * 查询数据

     * @param tableKey 表标识

     * @param queryKey 查询标识

     * @param startRow 开始行

     * @param paramsMap 参数集合

     * @return结果集

     */

    publicstatic TBData getDataMap(StringtableName, String startRow,

            StringstopRow, Integer currentPage, Integer pageSize)

            throws IOException {

        List>mapList = null;

        mapList = new LinkedList>();

        ResultScanner scanner = null;

        // 为分页创建的封装类对象，下面有给出具体属性

        TBData tbData = null;

        try {

            // 获取最大返回结果数量

            if (pageSize == null || pageSize == 0L)

                pageSize = 100;

            if (currentPage == null || currentPage == 0)

                currentPage = 1;

            // 计算起始页和结束页

            IntegerfirstPage = (currentPage - 1) * pageSize;

            IntegerendPage = firstPage + pageSize;

            // 从表池中取出HBASE表对象

            HTableInterfacetable = getTable(tableName);

            // 获取筛选对象

            Scanscan = getScan(startRow, stopRow);

            // 给筛选对象放入过滤器(true标识分页,具体方法在下面)

            scan.setFilter(packageFilters(true));

            // 缓存1000条数据

            scan.setCaching(1000);

            scan.setCacheBlocks(false);

            scanner= table.getScanner(scan);

            int i = 0;

            List<byte[]> rowList = new LinkedList<byte[]>();

            // 遍历扫描器对象， 并将需要查询出来的数据row key取出

            for (Result result : scanner) {

                String row = toStr(result.getRow());

                if (i >= firstPage && i< endPage) {

                    rowList.add(getBytes(row));

                }

                i++;

            }

            // 获取取出的row key的GET对象

            ListgetList = getList(rowList);

            Result[]results = table.get(getList);

            // 遍历结果

            for (Result result : results) {

                Map<byte[], byte[]> fmap = packFamilyMap(result);

                Map rmap = packRowMap(fmap);

                mapList.add(rmap);

            }

            // 封装分页对象

            tbData= new TBData();

            tbData.setCurrentPage(currentPage);

            tbData.setPageSize(pageSize);

            tbData.setTotalCount(i);

            tbData.setTotalPage(getTotalPage(pageSize, i));

            tbData.setResultList(mapList);

        } catch (IOException e) {

            e.printStackTrace();

        } finally {

            closeScanner(scanner);

        }

        return tbData;

    }

    privatestaticint getTotalPage(int pageSize, int totalCount) {

        int n = totalCount / pageSize;

        if (totalCount % pageSize == 0) {

            return n;

        } else {

            return ((int) n) + 1;

        }

    }

    // 获取扫描器对象

    privatestatic Scan getScan(String startRow,String stopRow) {

        Scan scan = new Scan();

        scan.setStartRow(getBytes(startRow));

        scan.setStopRow(getBytes(stopRow));

        return scan;

    }

    /**

     * 封装查询条件

     */

    privatestatic FilterList packageFilters(boolean isPage) {

        FilterList filterList = null;

        // MUST_PASS_ALL(条件 AND) MUST_PASS_ONE（条件OR）

        filterList = new FilterList(FilterList.Operator.MUST_PASS_ALL);

        Filter filter1 = null;

        Filter filter2 = null;

        filter1 = newFilter(getBytes("family1"), getBytes("column1"),

                CompareOp.EQUAL, getBytes("condition1"));

        filter2 = newFilter(getBytes("family2"), getBytes("column1"),

                CompareOp.LESS, getBytes("condition2"));

        filterList.addFilter(filter1);

        filterList.addFilter(filter2);

        if (isPage) {

            filterList.addFilter(new FirstKeyOnlyFilter());

        }

        return filterList;

    }

    privatestatic Filter newFilter(byte[] f, byte[] c, CompareOp op, byte[] v) {

        returnnew SingleColumnValueFilter(f, c, op,v);

    }

    privatestaticvoid closeScanner(ResultScannerscanner) {

        if (scanner != null)

            scanner.close();

    }

    /**

     * 封装每行数据

     */

    privatestatic MappackRowMap(Map<byte[], byte[]> dataMap) {

        Map map = new LinkedHashMap();

        for (byte[] key : dataMap.keySet()) {

            byte[] value = dataMap.get(key);

            map.put(toStr(key), toStr(value));

        }

        return map;

    }

    /* 根据ROW KEY集合获取GET对象集合 */

    privatestatic List getList(List<byte[]> rowList) {

        List list = new LinkedList();

        for (byte[] row : rowList) {

            Getget = new Get(row);

            get.addColumn(getBytes("family1"), getBytes("column1"));

            get.addColumn(getBytes("family1"), getBytes("column2"));

            get.addColumn(getBytes("family2"), getBytes("column1"));

            list.add(get);

        }

        return list;

    }

    /**

     * 封装配置的所有字段列族

     */

    privatestatic Map<byte[], byte[]> packFamilyMap(Result result){

        Map<byte[], byte[]> dataMap = null;

        dataMap = new LinkedHashMap<byte[], byte[]>();

        dataMap.putAll(result.getFamilyMap(getBytes("family1")));

        dataMap.putAll(result.getFamilyMap(getBytes("family2")));

        return dataMap;

    }

    privatestatic String toStr(byte[] bt) {

        return Bytes.toString(bt);

    }

    publicstaticvoid main(String[] args) throws IOException {

        // 拿出row key的起始行和结束行

        // #<0<9<:

        String startRow = "aaaa#";

        String stopRow = "aaaa:";

        int currentPage = 1;

        int pageSize = 20;

        // 执行hbase查询

        getDataMap("table", startRow, stopRow, currentPage,pageSize);

    }

}

class TBData {

    private Integer currentPage;

    private Integer pageSize;

    private Integer totalCount;

    private Integer totalPage;

    private List> resultList;

    public Integer getCurrentPage() {

        returncurrentPage;

    }

    publicvoid setCurrentPage(IntegercurrentPage) {

        this.currentPage = currentPage;

    }

    public Integer getPageSize() {

        returnpageSize;

    }

    publicvoid setPageSize(Integer pageSize) {

        this.pageSize = pageSize;

    }

    public Integer getTotalCount() {

        returntotalCount;

    }

    publicvoid setTotalCount(Integer totalCount){

        this.totalCount = totalCount;

    }

    public Integer getTotalPage() {

        returntotalPage;

    }

    publicvoid setTotalPage(Integer totalPage) {

        this.totalPage = totalPage;

    }

    public List> getResultList() {

        returnresultList;

    }

    publicvoidsetResultList(List> resultList) {

        this.resultList = resultList;

    }

}