hbase 分页代码

众所周知，hbase通过scan来扫描表，通过startKey，stopKey来确定范围，hbase官方提供了一个PageFilter来支持一次scan可以返回多少条数据即每页的行数。假如一页是10条，这样是第一页还好，但是第二页呢，如果不改变PageFilter的pageSize，那返回的还是第一页的数据，如果改变pageSize为20，则返回了第一页10多余的数据，在客户端要过滤掉，性能不好。那怎么办呢，方法就是在查询下一页时，指定下一页的startKey，这样PageFilter每次就不会返回多余的记录，stopKey可以不用变，那现在问题是，怎么得到下一页的startKey(即下一页第一行的rowkey)呢?,有两种方法来取每一页的startKey

一  上一页的最后一行记录的rowkey作为下一页的startKey。
二   在每次scan时多取一条记录，即把下一页第一条行页取出来，把该行的rowkey做为下一页的startKey。

不管用一还是二，都要注意，hbase scan时是包含startKey的，如果是采用第一种，则要在记录多取一条，排除第一条。第二种页是多取一条，但是排除最后一条，用来做下一页的startKey。还有需要注意的是在计算是否有下一页时，可以根据返回的条数来判断。

startKey怎么取没有问题了。但是怎么存储呢，有同学可能会想到存到session，但是如果你的服务是rest api型的，就没有session的概念了。那还有两种选择：
一 是存到客户端，让客户端每次请求时把startKey再传回来，这样需要依赖客户端，如果客户端是远程，或者是开放平台的情况下，可能不合适。
二 存在服务端，存在服务端需要注意并发访问的情况。比如scan同一个表，一个访问第2页，一个访问第3页，服务端就需要对每一个table的scan 存每一页的startKey，需要为同一个查询条件包含pageSize，因为pageSize不一样，startKey也会不一样，
在服务crash情况下，从起后都从第一页开始。

我自己是采用第二种方案，存在服务端，需要代码的，如果你有更好的方案的请分享出来。

注：hbase的分页一般只提供下一页，不提供直接最后一页，

代码如下：

import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 分页监控器
 *
 * @author bahaidong
 *
 */
public class PageScanManager {
    //失效时间10分钟
    private final static long expirtTime = 10 * 60 * 1000;
    private Map<String, PageScan> scanMaps = new ConcurrentHashMap<String, PageScan>();
    private static PageScanManager instance = new PageScanManager();

    private PageScanManager() {

        Thread monitor = new Thread(new ScanMonitor(),
                "pagescan-monitor-thread");
        monitor.setDaemon(true);
        monitor.start();
    }

    public static PageScanManager getInstance() {
        return instance;
    }

    public PageScan getPageScan(String scanStartKey, String scanEndKey,
            int pageSize) {
        String scanKey = scanStartKey + scanEndKey + pageSize;
        PageScan ps = scanMaps.get(scanKey);
        if (ps != null)
            return ps;
        synchronized (scanMaps) {
            if (scanMaps.get(scanKey) == null) {
                PageScan nps = new PageScan(scanStartKey, scanEndKey, pageSize);
                scanMaps.put(nps.getKEY(), nps);
            }
        }
        return scanMaps.get(scanKey);
    }

    /**
     * 内部监控PageScan的线程，如果某个PageScan在指定的时间内没有被访问 。则销毁
     *
     * @author bahaidong
     *
     */
    private class ScanMonitor implements Runnable {

        @Override
        public void run() {
            while (true) {
                long now = System.currentTimeMillis();
                Iterator<PageScan> it = scanMaps.values().iterator();
                while (it.hasNext()) {
                    PageScan pS = it.next();
                    if ((now - expirtTime) > pS.getStartTime()) {
                        String k = pS.getKEY();
                        scanMaps.remove(k);
                    }
                }
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }

    }

}

import java.util.HashMap;
import java.util.Map;

/**
 * hbase 分页
 *
 * @author bahaidong
 *
 */
public class PageScan {

    private String sKey;
    private String eKey;
    private int pageSize;
    private long startTime;
    private Map<Integer, String> pageRowKey;

    public PageScan(String startKey, String endKey, int pageSize) {
        this.sKey = startKey;
        this.eKey = endKey;
        this.pageSize = pageSize;
        this.startTime = System.currentTimeMillis();
    }

    public synchronized void setPageNoStartKey(int pageNo, String startKey) {
        if (pageRowKey == null) {
            pageRowKey = new HashMap<Integer, String>();
        }
        String prePageRowKey = pageRowKey.get(pageNo);
        if (prePageRowKey != null) {
            pageRowKey.remove(pageNo);
        }
        pageRowKey.put(pageNo, startKey);
    }

    public String getPageStartKey(int pageNo) throws Exception {
        if (pageNo <= 1) {
            return this.sKey;
        }
        this.startTime = System.currentTimeMillis();
        if (this.pageRowKey == null) {
            throw new Exception(
                    " pageNo must start with 1 when useHasNext is true ");
        }
        String nextK = this.pageRowKey.get(pageNo);
        if (nextK == null) {
            return this.sKey;
        }
        return nextK;
    }

    public String getKEY() {
        return this.sKey + this.eKey + this.pageSize;
    }

    public String getsKey() {
        return sKey;
    }

    public void setsKey(String sKey) {
        this.sKey = sKey;
    }

    public String geteKey() {
        return eKey;
    }

    public void seteKey(String eKey) {
        this.eKey = eKey;
    }

    public long getStartTime() {
        return startTime;
    }

    public void setStartTime(long startTime) {
        this.startTime = startTime;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null)
            return false;
        PageScan pre = (PageScan) obj;
        if (this.sKey.equals(pre.getsKey()) && this.eKey.equals(pre.geteKey())
                && this.pageSize == pre.pageSize)
            return true;
        return false;
    }

    @Override
    public int hashCode() {

        return new StringBuilder(this.sKey).append(this.eKey)
                .append(this.pageSize).toString().hashCode();
    }

    public int getPageSize() {
        return pageSize;
    }

    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }

}

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.filter.Filter;
import org.apache.hadoop.hbase.filter.PageFilter;
import org.apache.hadoop.hbase.util.Bytes;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.hadoop.hbase.HbaseTemplate;
import org.springframework.data.hadoop.hbase.RowMapper;
import org.springframework.stereotype.Service;

/**
 * 分页工具类
 * @author bahaidong
 *
 */
@Service
public class HbasePageUtil {
    
    private @Autowired HbaseTemplate template;
    
    /**
     * 返回Map结果集格式为：<br>
     * key:hasNext        value:boolean    是否有下一页:true 有， false 没有<br>
     * key:results        value:List&lt;Result&gt;    查询结果集<br>
     *
     * @param tableName
     * @param startKey
     * @param endKey
     * @param pageSize
     * @param pageNo
     * @return Map&lt;String, Object&gt;
     * @throws Exception
     */
    public Map<String, Object> getResult(String tableName, String startKey,
            String endKey, int pageSize, int pageNo) throws Exception {
        long totalNums = 0;
        boolean hasNext = false;
        Map<String, Object> mapResult = new HashMap<String, Object>();
        PageScanManager psm = PageScanManager.getInstance();
        PageScan pS = null;
        if (pageNo >= 1) {
            pS = psm.getPageScan(startKey, endKey, pageSize);
            startKey = pS.getPageStartKey(pageNo);
        }
        Scan scan = new Scan();
        //scan.setMaxVersions(1);
        scan.setStartRow(Bytes.toBytes(startKey));
        scan.setStopRow(Bytes.toBytes(endKey));
        Filter filter = new PageFilter(pageSize + 1);
        scan.setFilter(filter);
        
        List<Result> results = template.find(tableName, scan,
                new RowMapper<Result>() {
                    @Override
                    public Result mapRow(Result result, int rowNum) throws Exception {
                        return result;
                    }
                });
        Result lastR = null;
        if(results != null) {
            for(Result s: results) {
                totalNums++;
                lastR = s;
            }
            //默认查询结果不包含endKey，现修改为包含endKey
            if(totalNums <= pageSize) {
                Result result = template.get(tableName, endKey, new RowMapper<Result>(){
                    @Override
                    public Result mapRow(Result result, int rowNum) throws Exception {
                        return result;
                    }        
                });
                if(result != null){    
                    //当totalNums==pageSize时有可能为最后一页，最后一页时排除totalNums++的情况，否则可能造成无限循环
                    if(totalNums < pageSize) {
                        totalNums++;
                        if(!endKey.equals(startKey)) {
                            results.add(result);
                        }                        
                    }else {
                        lastR = result;
                        hasNext = true;
                        String row = Bytes.toString(lastR.getRow());
                        pS.setPageNoStartKey(pageNo + 1, row);
                        if(endKey.equals(startKey)){
                            hasNext = false;
                            //results = null;
                        }            
                    }            
                }
            }
            if(pS != null && totalNums == pageSize + 1) {
                results.remove(pageSize);
                hasNext = true;
                String row = Bytes.toString(lastR.getRow());
                pS.setPageNoStartKey(pageNo + 1, row);
            }
        }
        mapResult.put("results", results);
        mapResult.put("hasNext", hasNext);
        
        return mapResult;
    }

}