hbase02
文章树列

HBase的管理Java API

中止服务器或客户端。

1
void abort(String why,Throwable e)

检查服务器或客户端是否已中止。

1
boolean isAborted()

返回此对象使用的连接。

1
Connection getConnection()

判断表述否已存在,不存在则创建表

1
boolean tableExists

列出所有用户空间表

1
2
3
4
5
#已过时。 自2.0版本以来,将在3.0版本中删除,使用listTableDescriptors()。
HTableDescriptor[] listTables()
HTableDescriptor[] listTables(String regex)
HTableDescriptor[] listTables(Pattern pattern,boolean includeSysTables)
List<TableDescriptor> listTableDescriptors()

正则匹配查询所有的表

1
2
3
4
#已过时。 自2.0版本以来,将在3.0版本中删除。 
HTableDescriptor[] listTables(Pattern pattern)throws IOException
#新版本使用
List<TableDescriptor> listTableDescriptors(Pattern pattern)throws IOException

列出用户空间表的所有名称。

1
2
3
4
TableName[] listTableNames()
TableName[] listTableNames(Pattern pattern)
TableName[] listTableNames(String regex)
TableName[] listTableNames(Pattern pattern, boolean includeSysTables)

获取表描述符

1
2
3
4
#已过时。 自2.0版本以来,将在3.0版本中删除
HTableDescriptor getTableDescriptor(TableName tableName)
#新版本
TableDescriptor getDescriptor(TableName tableName)

创建表

1
2
3
4
5
void createTable(TableDescriptor desc)
void createTable(TableDescriptor desc, byte[] startKey, byte[] endKey,int numRegions)
void createTable(TableDescriptor desc, byte[][] splitKeys)
#异步创建表
Future<Void> createTableAsync(HTableDescriptor desc, byte[][] splitKeys)

删除表

1
2
3
4
5
6
void deleteTable(TableName tableName)
#### 异步删除
Future<Void> deleteTableAsync(TableName tableName)
#已过时。 自2.0版本以来,将在3.0版本中删除
HTableDescriptor[] deleteTables(String regex)
HTableDescriptor[] deleteTables(Pattern pattern)

截断表。 同步操作。

1
2
3
void truncateTable(TableName tableName,boolean preserveSplits)
#### 异步截断
Future<Void> truncateTableAsync(TableName tableName,boolean preserveSplits)

启用表

1
2
3
4
5
6
7
void enableTable(TableName tableName)
Future<Void> enableTableAsync(TableName tableName)
#已过时。 自2.0版本以来,将在3.0版本中删除
HTableDescriptor[] enableTables(String regex)
HTableDescriptor[] enableTables(Pattern pattern)
#是否启用
boolean isTableEnabled(TableName tableName)

禁用表

1
2
3
4
5
6
7
8
9
#已过时。 自2.0版本以来,将在3.0版本中删除
HTableDescriptor[] disableTables(String regex)
void disableTable(TableName tableName)
Future<Void> disableTableAsync(TableName tableName)
#是否禁用
boolean isTableDisabled(TableName tableName)

#### 是否可用
boolean isTableAvailable(TableName tableName)

将列族添加到现有表

1
2
3
4
5
6
#已过时。 自2.0版本以来,将在3.0版本中删除
default void addColumn(TableName tableName, ColumnFamilyDescriptor columnFamily)
#新版本
void addColumnFamily(TableName tableName,ColumnFamilyDescriptor columnFamily)
#异步添加
Future<Void> addColumnFamilyAsync(TableName tableName,ColumnFamilyDescriptor columnFamily)

从表中删除列

1
2
3
4
#已过时。 自2.0版本以来,将在3.0版本中删除
void deleteColumn(TableName tableName,byte[] columnFamily)
void deleteColumnFamily(TableName tableName,byte[] columnFamily)
Future<Void> deleteColumnFamilyAsync(TableName tableName,byte[] columnFamily)

修改表上的现有列

1
2
3
default void modifyColumn(TableName tableName, ColumnFamilyDescriptor columnFamily)
void modifyColumnFamily(TableName tableName,ColumnFamilyDescriptor columnFamily)
Future<Void> modifyColumnFamilyAsync(TableName tableName,ColumnFamilyDescriptor columnFamily)

JAVA操作Habase

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
/**
*
*
* HBase的管理API。 从Connection.getAdmin()获取实例并在完成后调用close()。
* Admin可用于创建,删除,列出,启用和禁用以及以其他方式修改表,以及执行其他管理操作。
* @author qxw
* @data 2018年8月10日上午11:08:07
*/
public class HbaseAdmin {
private static Connection connection;
private static Configuration configuration;
static {
// 取得一个数据库连接的配置参数对象
configuration = HBaseConfiguration.create();
// 设置连接参数:HBase数据库使用的端口
configuration.set("hbase.zookeeper.property.clientPort", "2181");
// 设置连接参数:HBase数据库所在的主机IP
configuration.set("hbase.zookeeper.quorum", "192.168.10.124");
}


/**
* 双重锁检查单例模式
* @return
* @throws IOException
*/
public static Connection getConnection() throws IOException{
//先检查实例是否存在,如果不存在才进入下面的同步块
if(connection==null){
synchronized (HbaseAdmin.class){
//再次判断实例是否存在,不存在 则创建
if(connection==null){
// 取得一个数据库连接对象
connection = ConnectionFactory.createConnection(configuration);
}
}
}
return connection;
}

/**
* 创建表
* @param tableName
* @param fields 列族
* @return
*/
public static JSONObject createTable(String tableName,List<String> fields){
JSONObject json=new JSONObject();
Admin db=null;
try {
db=getConnection().getAdmin();
//通过HTableDescriptor创建一个HTableDescriptor将表的描述传到createTable参数中
TableDescriptorBuilder tableDescriptor = TableDescriptorBuilder.newBuilder(TableName.valueOf(tableName));
//为描述器添加表的详细参数
fields.forEach(field->{
// 列族描述对象
tableDescriptor.setColumnFamily(ColumnFamilyDescriptorBuilder.newBuilder(Bytes.toBytes(field)).build());
});
//调用createtable方法创建表
db.createTable(tableDescriptor.build());
json.put("code",0);
return json;
} catch (Exception e) {
e.printStackTrace();
json.put("code",-1);
json.put("msg", "表" + tableName + "创建异常");
return json;
}finally{
close(db, null, null);
}
}

/**
* 预分区创建表
* @param tableName 表名
* @param columnFamily 列族名的集合
* @param splitKeys 预分期region
* @return 是否创建成功
*/
public boolean createTableBySplitKeys(String tableName, List<String> columnFamily, byte[][] splitKeys) {
Admin admin = null;
try {
if (StringUtils.isBlank(tableName) || columnFamily == null|| columnFamily.size() == 0) {
return false;
}
admin=getConnection().getAdmin();
if (admin.tableExists(TableName.valueOf(tableName))) {
return true;
} else {
List<ColumnFamilyDescriptor> familyDescriptors = new ArrayList<>(columnFamily.size());
columnFamily.forEach(cf -> {
familyDescriptors.add(ColumnFamilyDescriptorBuilder.newBuilder(Bytes.toBytes(cf)).build());
});
//为描述器添加表的详细参数
TableDescriptor tableDescriptor = TableDescriptorBuilder.newBuilder(TableName.valueOf(tableName)).setColumnFamilies(familyDescriptors).build();

//指定splitkeys
admin.createTable(tableDescriptor,splitKeys);

}
} catch (IOException e) {
e.printStackTrace();
return false;
}finally{
close(admin, null, null);
}
return true;
}


/**
* 删除表
* @param tableName
* @param isAsync true=异步:同步
* @return
*/
public static JSONObject deleteTable(String tableName,boolean isAsync){
JSONObject json=new JSONObject();
Admin db=null;
try {
db=getConnection().getAdmin();
//先禁用
db.disableTable(TableName.valueOf(tableName));
if(isAsync){
db.deleteTableAsync(TableName.valueOf(tableName));
}else{
db.deleteTable(TableName.valueOf(tableName));
}
json.put("code",0);
return json;
} catch (Exception e) {
e.printStackTrace();
json.put("code",-1);
json.put("msg", "表" + tableName + "删除异常");
return json;
}finally{
close(db, null, null);
}
}

/**
* 列出所有表名称
* @param tableName
* @param isAsync
* @return
*/
public static JSONObject listTableNames(Pattern pattern){
JSONObject json=new JSONObject();
List<String> list=new ArrayList<String>(10);
Admin db=null;
try {
db=getConnection().getAdmin();
TableName [] tableNames;
if(pattern==null){
tableNames=db.listTableNames();
}else{
tableNames=db.listTableNames(pattern);
}
for (int i = 0; i < tableNames.length; i++) {
list.add(tableNames[i].toString());
}
json.put("code",0);
json.put("data", list);
return json;
} catch (Exception e) {
e.printStackTrace();
json.put("code",-1);
json.put("msg", "列出所有表名称异常");
return json;
}finally{
close(db, null, null);
}
}

/**
* 往表中添加单条数据
* @param tableName 表明
* @param rowkey 指key
* @param family 列族名
* @param map 数据源
* @return
*/
public static JSONObject putOne(String tableName,String rowkey,String family,Map<String, String> map){
JSONObject json=new JSONObject();
Table table=null;
try {
table =getConnection().getTable(TableName.valueOf(tableName)) ;
//实例化put对象,传入行键
Put put =new Put(Bytes.toBytes(rowkey));
//调用addcolum方法,向i簇中添加字段
Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
while (it.hasNext()){
Map.Entry<String, String> entry = it.next();
put.addColumn(Bytes.toBytes(family),Bytes.toBytes(entry.getKey()),Bytes.toBytes(entry.getValue()));
}
table.put(put);
json.put("code",0);
return json;
} catch (Exception e) {
e.printStackTrace();
json.put("code",-1);
json.put("msg", "往表中添加单条数据异常");
return json;
}finally{
close(null, null, table);
}
}

/**
* 往表中添加多数据
* @param table Table
* @param rowKey rowKey
* @param tableName 表名
* @param familyName 列族名
* @param columns 列名数组
* @param values 列值得数组
* @return
*/
@SuppressWarnings("resource")
public static JSONObject put(String tableName,String rowkey,String familyName, String[] columns, String[] values){
JSONObject json=new JSONObject();
Table table=null;
try {
table =getConnection().getTable(TableName.valueOf(tableName)) ;
//实例化put对象,传入行键
Put put =new Put(Bytes.toBytes(rowkey));
if(columns != null && values != null && columns.length == values.length){
for(int i=0;i<columns.length;i++){
if(columns[i] != null && values[i] != null){
put.addColumn(Bytes.toBytes(familyName), Bytes.toBytes(columns[i]), Bytes.toBytes(values[i]));
}else{
throw new NullPointerException(MessageFormat.format("列名和列数据都不能为空,column:{0},value:{1}" ,columns[i],values[i]));
}
}
}
table.put(put);
json.put("code",0);
return json;
} catch (Exception e) {
e.printStackTrace();
json.put("code",-1);
json.put("msg", "往表中添加单条数据异常");
return json;
}finally{
close(null, null, table);
}
}

/***
* 遍历查询指定表中的所有数据
* @param tableName
* @return
*/
public static Map<String,Map<String,String>> getResultScanner(String tableName){
Scan scan = new Scan();
return queryData(tableName,scan);
}

/**
* 根据startRowKey和stopRowKey遍历查询指定表中的所有数据
* @param tableName 表名
* @param startRowKey 起始rowKey
* @param stopRowKey 结束rowKey
*/
public static Map<String,Map<String,String>> getResultScanner(String tableName, String startRowKey, String stopRowKey){
Scan scan = new Scan();
if(StringUtils.isNotBlank(startRowKey) && StringUtils.isNotBlank(stopRowKey)){
scan.withStartRow(Bytes.toBytes(startRowKey));
scan.withStopRow(Bytes.toBytes(stopRowKey));
}
return queryData(tableName,scan);
}

/**
* 通过行前缀过滤器查询数据
* @param tableName 表名
* @param prefix 以prefix开始的行键
*/
public static Map<String,Map<String,String>> getResultScannerPrefixFilter(String tableName, String prefix){
Scan scan = new Scan();
if(StringUtils.isNotBlank(prefix)){
Filter filter = new PrefixFilter(Bytes.toBytes(prefix));
scan.setFilter(filter);
}
return queryData(tableName,scan);
}

/**
* 通过列前缀过滤器查询数据
* @param tableName 表名
* @param prefix 以prefix开始的列名
*/
public static Map<String,Map<String,String>> getResultScannerColumnPrefixFilter(String tableName, String prefix){
Scan scan = new Scan();
if(StringUtils.isNotBlank(prefix)){
Filter filter = new ColumnPrefixFilter(Bytes.toBytes(prefix));
scan.setFilter(filter);
}
return queryData(tableName,scan);
}
/**
* 查询行键中包含特定字符的数据
* @param tableName 表名
* @param keyword 包含指定关键词的行键
*/
public static Map<String,Map<String,String>> getResultScannerRowFilter(String tableName, String keyword){
Scan scan = new Scan();
if(StringUtils.isNotBlank(keyword)){
Filter filter = new RowFilter(CompareOperator.GREATER_OR_EQUAL,new SubstringComparator(keyword));
scan.setFilter(filter);
}
return queryData(tableName,scan);
}

/**
* 查询列名中包含特定字符的数据
* @author zifangsky
* @param tableName 表名
* @param keyword 包含指定关键词的列名
*/
public static Map<String,Map<String,String>> getResultScannerQualifierFilter(String tableName, String keyword){
Scan scan = new Scan();
if(StringUtils.isNotBlank(keyword)){
Filter filter = new QualifierFilter(CompareOperator.GREATER_OR_EQUAL,new SubstringComparator(keyword));
scan.setFilter(filter);
}
return queryData(tableName,scan);
}


/**
* 根据tableName和rowKey精确查询一行的数据
* @param tableName 表名
* @param rowKey 行键
* @return
*/
public static Map<String,String> getRowData(String tableName, String rowKey){
Map<String,String> result = new HashMap<>();
Get get = new Get(Bytes.toBytes(rowKey));
Table table= null;
try {
table =getConnection().getTable(TableName.valueOf(tableName)) ;
Result hTableResult = table.get(get);
if (hTableResult != null && !hTableResult.isEmpty()) {
for (Cell cell : hTableResult.listCells()) {
result.put(Bytes.toString(cell.getQualifierArray(), cell.getQualifierOffset(), cell.getQualifierLength()), Bytes.toString(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength()));
}
}
} catch (Exception e) {
e.printStackTrace();
}finally{
close(null, null, table);
}
return result;
}



/**
* 根据tableName、rowKey、familyName、column查询指定单元格的数据
* @param tableName 表名
* @param rowKey rowKey
* @param familyName 列族名
* @param columnName 列名
*/
public static String getColumnValue(String tableName, String rowKey, String familyName, String columnName){
String str = null;
Get get = new Get(Bytes.toBytes(rowKey));
// 获取表
Table table= null;
try {
table =getConnection().getTable(TableName.valueOf(tableName)) ;
Result result = table.get(get);
if (result != null && !result.isEmpty()) {
Cell cell = result.getColumnLatestCell(Bytes.toBytes(familyName), Bytes.toBytes(columnName));
if(cell != null){
str = Bytes.toString(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength());
}
}
} catch (IOException e) {
e.printStackTrace();
}finally{
close(null, null, table);
}
return str;
}

/**
* 根据tableName、rowKey、familyName、column查询指定单元格多个版本的数据
* @param tableName 表名
* @param rowKey rowKey
* @param familyName 列族名
* @param columnName 列名
* @param versions 需要查询的版本数
*/
public List<String> getColumnValuesByVersion(String tableName, String rowKey, String familyName, String columnName,int versions) {
//返回数据
List<String> result = new ArrayList<>(versions);
// 获取表
Table table= null;
try {
table =getConnection().getTable(TableName.valueOf(tableName)) ;
Get get = new Get(Bytes.toBytes(rowKey));
get.addColumn(Bytes.toBytes(familyName), Bytes.toBytes(columnName));
//读取多少个版本
get.readVersions(versions);
Result hTableResult = table.get(get);
if (hTableResult != null && !hTableResult.isEmpty()) {
for (Cell cell : hTableResult.listCells()) {
result.add(Bytes.toString(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength()));
}
}
} catch (IOException e) {
e.printStackTrace();
}finally{
close(null, null, table);
}

return result;
}

/**
* 通过表名以及过滤条件查询数据
* @param tableName 表名
* @param scan 过滤条件
*/
private static Map<String,Map<String,String>> queryData(String tableName,Scan scan){
Map<String,Map<String,String>> result = new HashMap<>();
ResultScanner rs = null;
// 获取表
Table table= null;
try {
table =getConnection().getTable(TableName.valueOf(tableName)) ;
rs = table.getScanner(scan);
for (Result r : rs) {
//每一行数据
Map<String,String> columnMap = new HashMap<>();
String rowKey = null;
for (Cell cell : r.listCells()) {
if(rowKey == null){
rowKey = Bytes.toString(cell.getRowArray(),cell.getRowOffset(),cell.getRowLength());
}
columnMap.put(Bytes.toString(cell.getQualifierArray(), cell.getQualifierOffset(), cell.getQualifierLength()), Bytes.toString(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength()));
}

if(rowKey != null){
result.put(rowKey,columnMap);
}
}
}catch (IOException e) {
e.printStackTrace();
System.out.println("遍历查询指定表中的所有数据失败");
}finally{
close(null, null, table);
}

return result;
}

/**
* 更新数据 为表的某个单元格赋值
* @param tableName 表名
* @param rowKey rowKey
* @param family 列族名
* @param columkey 列名
* @param updatedata 列值
*/
public void updateData(String tableName,String rowKey,String family,String columkey,String updatedata){
Table table=null;
try {
//hbase中更新数据同样采用put方法,在相同的位置put数据,则在查询时只会返回时间戳较新的数据
//且在文件合并时会将时间戳较旧的数据舍弃
Put put = new Put(Bytes.toBytes(rowKey));
//将新数据添加到put中
put.addColumn(Bytes.toBytes(family), Bytes.toBytes(columkey),Bytes.toBytes(updatedata));
table = connection.getTable(TableName.valueOf(tableName));
//将put写入HBase
table.put(put);
} catch (Exception e) {
e.printStackTrace();
}finally{
close(null, null, table);
}

}



/**
* 删除某条记录
* @param tableName 表名
* @param rowKey rowKey
* @param family 列族名
* @param columkey 列名
*/
public void deleteData(String tableName,String rowKey,String family,String columkey){
Table table=null;
try {
table = connection.getTable(TableName.valueOf(tableName));
//创建delete对象
Delete deletData= new Delete(Bytes.toBytes(rowKey));
//将要删除的数据的准确坐标添加到对象中
deletData.addColumn(Bytes.toBytes(family), Bytes.toBytes(columkey));
//删除表中数据
table.delete(deletData);
} catch (Exception e) {
e.printStackTrace();
}finally{
close(null, null, table);
}

}

/**
* 删除一行数据
* @param tableName
* @param rowKey
*/
public void deleteRow(String tableName,String rowKey) {
Table table =null;
try {
table = connection.getTable(TableName.valueOf(tableName));
//通过行键删除一整行的数据
Delete deletRow= new Delete(Bytes.toBytes(rowKey));
table.delete(deletRow);
} catch (Exception e){
e.printStackTrace();
}finally{
close(null, null, table);
}

}

/**
* 根据columnFamily删除指定的列族
* @param tableName 表名
* @param columnFamily 列族
* @return boolean
*/
public boolean deleteColumnFamily(String tableName, String columnFamily,boolean isAysnc){
Admin admin=null;
try {
admin=getConnection().getAdmin();
if(isAysnc){
admin.deleteColumnFamilyAsync(TableName.valueOf(tableName), Bytes.toBytes(columnFamily));
}else{
admin.deleteColumnFamily(TableName.valueOf(tableName), Bytes.toBytes(columnFamily));
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}finally{
close(admin, null, null);
}

}

/**
* 自定义获取分区splitKeys
*/
public byte[][] getSplitKeys(String[] keys){
if(keys==null){
//默认为10个分区
keys = new String[] { "1|", "2|", "3|", "4|", "5|", "6|", "7|", "8|", "9|" };
}
byte[][] splitKeys = new byte[keys.length][];
//升序排序
TreeSet<byte[]> rows = new TreeSet<byte[]>(Bytes.BYTES_COMPARATOR);
for(String key : keys){
rows.add(Bytes.toBytes(key));
}
Iterator<byte[]> rowKeyIter = rows.iterator();
int i=0;
while (rowKeyIter.hasNext()) {
byte[] tempRow = rowKeyIter.next();
rowKeyIter.remove();
splitKeys[i] = tempRow;
i++;
}
return splitKeys;
}
/**
* 按startKey和endKey,分区数获取分区
*/
public static byte[][] getHexSplits(String startKey, String endKey, int numRegions) {
byte[][] splits = new byte[numRegions-1][];
BigInteger lowestKey = new BigInteger(startKey, 16);
BigInteger highestKey = new BigInteger(endKey, 16);
BigInteger range = highestKey.subtract(lowestKey);
BigInteger regionIncrement = range.divide(BigInteger.valueOf(numRegions));
lowestKey = lowestKey.add(regionIncrement);
for(int i=0; i < numRegions-1;i++) {
BigInteger key = lowestKey.add(regionIncrement.multiply(BigInteger.valueOf(i)));
byte[] b = String.format("%016x", key).getBytes();
splits[i] = b;
}
return splits;
}

/**
* 关闭流
*/
private static void close(Admin admin, ResultScanner rs, Table table){
if(admin != null){
try {
admin.close();
} catch (IOException e) {
e.printStackTrace();
System.out.println("关闭Admin失败");
}
}
if(rs != null){
rs.close();
}
if(table != null){
try {
table.close();
} catch (IOException e) {
e.printStackTrace();
System.out.println("关闭Table失败");

}
}
}
public static void main(String[] args) throws IOException{
String tableName="tes_userInfo";
//删除表
System.out.println("删除表:"+deleteTable(tableName, true));


//创建表
List<String> fields=Arrays.asList("info","employee");
System.out.println("创建表:"+createTable(tableName, fields));


//查询所有表名称
Pattern pattern = Pattern.compile("^t.*$", Pattern.CASE_INSENSITIVE);
System.out.println("查询所有表名称: "+listTableNames(null));
System.out.println("正则查询表名称: "+listTableNames(pattern));


//单条数据添加
Map<String, String> map=new HashMap<String, String>();
map.put("name","秦学武");
map.put("age", "24");
map.put("sex", "男");
//指定列族和
System.out.println("单条数据添加: "+putOne(tableName,"row_1001","info",map));

//多条数据添加
put(tableName, "row_1002", "info", new String[]{"name","age","sex"},new String[]{"小明","18","男"});

put(tableName, "row_1001", "employee", new String[]{"name","time",},new String[]{"秦学武员工",System.currentTimeMillis()+""});
put(tableName, "row_1002", "employee", new String[]{"name","time",},new String[]{"小明员工",System.currentTimeMillis()+""});


//查询指定表中的所有数据
Map<String,Map<String,String>> maps=getResultScanner(tableName);
Iterator<Entry<String, Map<String, String>>> it = maps.entrySet().iterator();
System.out.println("查询指定表中的所有数据: "+maps.toString());
while (it.hasNext()){
Entry<String, Map<String, String>> entry =it.next();
System.out.println(entry.getKey()+","+entry.getValue());
}
//根据表名和rowkey 查询指定的数据
Map<String, String> m=getRowData(tableName, "row_1001");
System.out.println("查询 rowkey=row_1001的数据: "+ m.toString());

//根据表名、rowKey、列族名、列字段 查询指定单元格的数据
System.out.println("查询指定表名,rowKey,列族名,列字段的数据:"+getColumnValue(tableName, "row_1001","employee", "name"));

//根据startRowKey和stopRowKey遍历查询指定表中的所有数据 一般用于RowKey是连续递增,且只查询一部分数据的情况(比如分页)
Map<String,Map<String,String>> maps2=getResultScanner(tableName,"row_1001","row_1002");
System.out.println("根据startRowKey和stopRowKey遍历查询指定表中的所有数据: "+maps2.toString());


//根据rowKey行键过滤器查询数据
Map<String,Map<String,String>> result=getResultScannerPrefixFilter(tableName, "r");
System.out.println("根据行键过滤器查询数据: "+result.toString());

//根据列名过滤器查询数据
System.out.println("根据列名过滤器查询数据: "+getResultScannerColumnPrefixFilter(tableName, "time"));


}


}
新版下载
本文原创,商业转载请联系作者获得授权,非商业转载请注明出处。

评论

发送评论 编辑评论


                        

待分类分类热门文章

标签热门文章排行

☛免责声明 ☛本站使用教程
Theme Argon With Ry-Plus By 清欢
我的第21753位朋友,历经126836次回眸才与你相遇
内容失效/资源代找/交流学习
内容失效/资源代找/交流学习