hbase分頁應用場景及分頁思路與代碼實現

轉自：http://www.aboutyun.com/forum.php?mod=viewthread&tid=7030&extra=page=1

可以帶着下面問題來閱讀
1.hbasef分頁什么情況下比較有用？
2.hbase分頁的思路是什么？
3.hbase分頁代碼與sql分頁代碼有什么區別和聯系？

一、hbase分頁應用場景：


一、應用場景
hbase到底需不需要分頁，hbase的數據量肯定不少，肯定是需要分頁的。很多人認為數量量如此大，怎么會展示。這個從客戶角度來講，我們做的系統，不可能會給機器看的。這里面我們可以對其進行統計分析，這樣利於我們決策。
比如我們：平台中有一個場景是要做用戶歷史訂單數據的查詢，並且需要支持分頁。這里只是舉了一個場景，后面大家可以根據自己的經驗。下面給大家講講分頁的思路。





二、hbase分頁思路：

hbase通過scan來掃描表，通過startKey，stopKey來確定范圍，hbase官方提供了一個PageFilter來支持一次scan可以返回多少條數據即每頁的行數。假如一頁是10條，這樣是第一頁還好，但是第二頁呢，如果不改變PageFilter的pageSize，那返回的還是第一頁的數據，如果改變pageSize為20，則返回了第一頁10多余的數據，在客戶端要過濾掉，性能不好。那怎么辦呢，方法就是在查詢下一頁時，指定下一頁的startKey，這樣PageFilter每次就不會返回多余的記錄，stopKey可以不用變，那現在問題是，怎么得到下一頁的startKey(即下一頁第一行的rowkey)呢?,有兩種方法來取每一頁的startKey

1.  上一頁的最后一行記錄的rowkey作為下一頁的startKey。
2.   在每次scan時多取一條記錄，即把下一頁第一條行頁取出來，把該行的rowkey做為下一頁的startKey。

這兩種方法，都要注意，hbase scan時是包含startKey的，如果是采用第一種，則要在記錄多取一條，排除第一條。第二種頁是多取一條，但是排除最后一條，用來做下一頁的startKey。還有需要注意的是在計算是否有下一頁時，可以根據返回的條數來判斷。

startKey怎么取沒有問題了。但是怎么存儲呢，有同學可能會想到存到session，但是如果你的服務是rest api型的，就沒有session的概念了。那還有兩種選擇：
1. 是存到客戶端，讓客戶端每次請求時把startKey再傳回來，這樣需要依賴客戶端，如果客戶端是遠程，或者是開放平台的情況下，可能不合適。
2. 存在服務端，存在服務端需要注意並發訪問的情況。比如scan同一個表，一個訪問第2頁，一個訪問第3頁，服務端就需要對每一個table的scan 存每一頁的startKey，需要為同一個查詢條件包含pageSize，因為pageSize不一樣，startKey也會不一樣，
在服務crash情況下，從起后都從第一頁開始。

我自己是采用第二種方案，存在服務端.




----------------------------------------------------------------------------------------------------------------------------------------------------
三、代碼實現

1. import java.io.IOException;
2. import java.util.LinkedHashMap;
3. import java.util.LinkedList;
4. import java.util.List;
5. import java.util.Map;
7. import org.apache.commons.lang.StringUtils;
8. import org.apache.hadoop.conf.Configuration;
9. import org.apache.hadoop.hbase.HBaseConfiguration;
10. import org.apache.hadoop.hbase.client.Get;
11. import org.apache.hadoop.hbase.client.HTableInterface;
12. import org.apache.hadoop.hbase.client.HTablePool;
13. import org.apache.hadoop.hbase.client.Result;
14. import org.apache.hadoop.hbase.client.ResultScanner;
15. import org.apache.hadoop.hbase.client.Scan;
16. import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp;
17. import org.apache.hadoop.hbase.filter.Filter;
18. import org.apache.hadoop.hbase.filter.FilterList;
19. import org.apache.hadoop.hbase.filter.FirstKeyOnlyFilter;
20. import org.apache.hadoop.hbase.filter.SingleColumnValueFilter;
21. import org.apache.hadoop.hbase.util.Bytes;
23. public class HBaseUtils {
24.         private static Configuration config = null;
25.         private static HTablePool tp = null;
26.         static {
27.                 // 加載集群配置
28.                 config = HBaseConfiguration.create();
29.                 config.set("hbase.zookeeper.quorum", "xx.xx.xx");
30.                 config.set("hbase.zookeeper.property.clientPort", "2181");
31.                 // 創建表池(可偉略提高查詢性能，具體說明請百度或官方API)
32.                 tp = new HTablePool(config, 10);
33.         }
35.         /*
36.          * 獲取hbase的表
37.          */
38.         public static HTableInterface getTable(String tableName) {
40.                 if (StringUtils.isEmpty(tableName))
41.                         return null;
43.                 return tp.getTable(getBytes(tableName));
44.         }
46.         /* 轉換byte數組 */
47.         public static byte[] getBytes(String str) {
48.                 if (str == null)
49.                         str = "";
51.                 return Bytes.toBytes(str);
52.         }
54.         /**
55.          * 查詢數據
56.          * @param tableKey 表標識
57.          * @param queryKey 查詢標識
58.          * @param startRow 開始行
59.          * @param paramsMap 參數集合
60.          * @return 結果集
61.          */
62.         public static TBData getDataMap(String tableName, String startRow,
63.                         String stopRow, Integer currentPage, Integer pageSize)
64.                         throws IOException {
65.                 List<Map<String, String>> mapList = null;
66.                 mapList = new LinkedList<Map<String, String>>();
68.                 ResultScanner scanner = null;
69.                 // 為分頁創建的封裝類對象，下面有給出具體屬性
70.                 TBData tbData = null;
71.                 try {
72.                         // 獲取最大返回結果數量
73.                         if (pageSize == null || pageSize == 0L)
74.                                 pageSize = 100;
76.                         if (currentPage == null || currentPage == 0)
77.                                 currentPage = 1;
79.                         // 計算起始頁和結束頁
80.                         Integer firstPage = (currentPage - 1) * pageSize;
82.                         Integer endPage = firstPage + pageSize;
84.                         // 從表池中取出HBASE表對象
85.                         HTableInterface table = getTable(tableName);
86.                         // 獲取篩選對象
87.                         Scan scan = getScan(startRow, stopRow);
88.                         // 給篩選對象放入過濾器(true標識分頁,具體方法在下面)
89.                         scan.setFilter(packageFilters(true));
90.                         // 緩存1000條數據
91.                         scan.setCaching(1000);
92.                         scan.setCacheBlocks(false);
93.                         scanner = table.getScanner(scan);
94.                         int i = 0;
95.                         List<byte[]> rowList = new LinkedList<byte[]>();
96.                         // 遍歷掃描器對象， 並將需要查詢出來的數據row key取出
97.                         for (Result result : scanner) {
98.                                 String row = toStr(result.getRow());
99.                                 if (i >= firstPage && i < endPage) {
100.                                         rowList.add(getBytes(row));
101.                                 }
102.                                 i++;
103.                         }
105.                         // 獲取取出的row key的GET對象
106.                         List<Get> getList = getList(rowList);
107.                         Result[] results = table.get(getList);
108.                         // 遍歷結果
109.                         for (Result result : results) {
110.                                 Map<byte[], byte[]> fmap = packFamilyMap(result);
111.                                 Map<String, String> rmap = packRowMap(fmap);
112.                                 mapList.add(rmap);
113.                         }
115.                         // 封裝分頁對象
116.                         tbData = new TBData();
117.                         tbData.setCurrentPage(currentPage);
118.                         tbData.setPageSize(pageSize);
119.                         tbData.setTotalCount(i);
120.                         tbData.setTotalPage(getTotalPage(pageSize, i));
121.                         tbData.setResultList(mapList);
122.                 } catch (IOException e) {
123.                         e.printStackTrace();
124.                 } finally {
125.                         closeScanner(scanner);
126.                 }
128.                 return tbData;
129.         }
131.         private static int getTotalPage(int pageSize, int totalCount) {
132.                 int n = totalCount / pageSize;
133.                 if (totalCount % pageSize == 0) {
134.                         return n;
135.                 } else {
136.                         return ((int) n) + 1;
137.                 }
138.         }
140.         // 獲取掃描器對象
141.         private static Scan getScan(String startRow, String stopRow) {
142.                 Scan scan = new Scan();
143.                 scan.setStartRow(getBytes(startRow));
144.                 scan.setStopRow(getBytes(stopRow));
146.                 return scan;
147.         }
149.         /**
150.          * 封裝查詢條件
151.          */
152.         private static FilterList packageFilters(boolean isPage) {
153.                 FilterList filterList = null;
154.                 // MUST_PASS_ALL(條件 AND) MUST_PASS_ONE（條件OR）
155.                 filterList = new FilterList(FilterList.Operator.MUST_PASS_ALL);
156.                 Filter filter1 = null;
157.                 Filter filter2 = null;
158.                 filter1 = newFilter(getBytes("family1"), getBytes("column1"),
159.                                 CompareOp.EQUAL, getBytes("condition1"));
160.                 filter2 = newFilter(getBytes("family2"), getBytes("column1"),
161.                                 CompareOp.LESS, getBytes("condition2"));
162.                 filterList.addFilter(filter1);
163.                 filterList.addFilter(filter2);
164.                 if (isPage) {
165.                         filterList.addFilter(new FirstKeyOnlyFilter());
166.                 }
167.                 return filterList;
168.         }
170.         private static Filter newFilter(byte[] f, byte[] c, CompareOp op, byte[] v) {
171.                 return new SingleColumnValueFilter(f, c, op, v);
172.         }
174.         private static void closeScanner(ResultScanner scanner) {
175.                 if (scanner != null)
176.                         scanner.close();
177.         }
179.         /**
180.          * 封裝每行數據
181.          */
182.         private static Map<String, String> packRowMap(Map<byte[], byte[]> dataMap) {
183.                 Map<String, String> map = new LinkedHashMap<String, String>();
185.                 for (byte[] key : dataMap.keySet()) {
187.                         byte[] value = dataMap.get(key);
189.                         map.put(toStr(key), toStr(value));
191.                 }
192.                 return map;
193.         }
195.         /* 根據ROW KEY集合獲取GET對象集合 */
196.         private static List<Get> getList(List<byte[]> rowList) {
197.                 List<Get> list = new LinkedList<Get>();
198.                 for (byte[] row : rowList) {
199.                         Get get = new Get(row);
201.                         get.addColumn(getBytes("family1"), getBytes("column1"));
202.                         get.addColumn(getBytes("family1"), getBytes("column2"));
203.                         get.addColumn(getBytes("family2"), getBytes("column1"));
204.                         list.add(get);
205.                 }
206.                 return list;
207.         }
209.         /**
210.          * 封裝配置的所有字段列族
211.          */
212.         private static Map<byte[], byte[]> packFamilyMap(Result result) {
213.                 Map<byte[], byte[]> dataMap = null;
214.                 dataMap = new LinkedHashMap<byte[], byte[]>();
215.                 dataMap.putAll(result.getFamilyMap(getBytes("family1")));
216.                 dataMap.putAll(result.getFamilyMap(getBytes("family2")));
217.                 return dataMap;
218.         }
220.         private static String toStr(byte[] bt) {
221.                 return Bytes.toString(bt);
222.         }
224.         public static void main(String[] args) throws IOException {
225.                 // 拿出row key的起始行和結束行
226.                 // #<0<9<:
227.                 String startRow = "aaaa#";
228.                 String stopRow = "aaaa:";
229.                 int currentPage = 1;
230.                 int pageSize = 20;
231.                 // 執行hbase查詢
232.                 getDataMap("table", startRow, stopRow, currentPage, pageSize);
234.         }
235. }
237. class TBData {
238.         private Integer currentPage;
239.         private Integer pageSize;
240.         private Integer totalCount;
241.         private Integer totalPage;
242.         private List<Map<String, String>> resultList;
244.         public Integer getCurrentPage() {
245.                 return currentPage;
246.         }
248.         public void setCurrentPage(Integer currentPage) {
249.                 this.currentPage = currentPage;
250.         }
252.         public Integer getPageSize() {
253.                 return pageSize;
254.         }
256.         public void setPageSize(Integer pageSize) {
257.                 this.pageSize = pageSize;
258.         }
260.         public Integer getTotalCount() {
261.                 return totalCount;
262.         }
264.         public void setTotalCount(Integer totalCount) {
265.                 this.totalCount = totalCount;
266.         }
268.         public Integer getTotalPage() {
269.                 return totalPage;
270.         }
272.         public void setTotalPage(Integer totalPage) {
273.                 this.totalPage = totalPage;
274.         }
276.         public List<Map<String, String>> getResultList() {
277.                 return resultList;
278.         }
280.         public void setResultList(List<Map<String, String>> resultList) {
281.                 this.resultList = resultList;
282.         }
283. }

復制代碼