HBase学习之路 （四）HBase的API操作详解大数据

  1 import java.io.IOException; 
  2 import java.util.Date; 
  3  
  4 import org.apache.hadoop.conf.Configuration; 
  5 import org.apache.hadoop.hbase.HBaseConfiguration; 
  6 import org.apache.hadoop.hbase.HColumnDescriptor; 
  7 import org.apache.hadoop.hbase.HTableDescriptor; 
  8 import org.apache.hadoop.hbase.TableName; 
  9 import org.apache.hadoop.hbase.client.Admin; 
 10 import org.apache.hadoop.hbase.client.Connection; 
 11 import org.apache.hadoop.hbase.client.ConnectionFactory; 
 12 import org.apache.hadoop.hbase.client.Delete; 
 13 import org.apache.hadoop.hbase.client.Get; 
 14 import org.apache.hadoop.hbase.client.Put; 
 15 import org.apache.hadoop.hbase.client.Result; 
 16 import org.apache.hadoop.hbase.client.ResultScanner; 
 17 import org.apache.hadoop.hbase.client.Scan; 
 18 import org.apache.hadoop.hbase.client.Table; 
 19  
 20 import com.study.hbase.service.HBaseUtils; 
 21  
 22 public class HBaseUtilsImpl implements HBaseUtils { 
 23  
 24     private static final String ZK_CONNECT_KEY = "hbase.zookeeper.quorum"; 
 25     private static final String ZK_CONNECT_VALUE = "hadoop1:2181,hadoop2:2181,hadoop3:2181"; 
 26  
 27     private static Connection conn = null; 
 28     private static Admin admin = null; 
 29  
 30     public static void main(String[] args) throws Exception { 
 31          
 32         getConnection(); 
 33         getAdmin(); 
 34          
 35         HBaseUtilsImpl hbu = new HBaseUtilsImpl(); 
 36          
 37          
 38         //hbu.getAllTables(); 
 39          
 40         //hbu.descTable("people"); 
 41          
 42         //String[] infos = {"info","family"}; 
 43         //hbu.createTable("people", infos); 
 44          
 45         //String[] add = {"cs1","cs2"}; 
 46         //String[] remove = {"cf1","cf2"}; 
 47          
 48         //HColumnDescriptor hc = new HColumnDescriptor("sixsixsix"); 
 49          
 50         //hbu.modifyTable("stu",hc); 
 51         //hbu.getAllTables(); 
 52  
 53          
 54         hbu.putData("huoying", "rk001", "cs2", "name", "aobama",new Date().getTime()); 
 55         hbu.getAllTables(); 
 56          
 57         conn.close(); 
 58     } 
 59  
 60     // 获取连接 
 61     public static Connection getConnection() { 
 62         // 创建一个可以用来管理hbase配置信息的conf对象 
 63         Configuration conf = HBaseConfiguration.create(); 
 64         // 设置当前的程序去寻找的hbase在哪里 
 65         conf.set(ZK_CONNECT_KEY, ZK_CONNECT_VALUE); 
 66         try { 
 67             conn = ConnectionFactory.createConnection(conf); 
 68         } catch (IOException e) { 
 69             e.printStackTrace(); 
 70         } 
 71         return conn; 
 72     } 
 73  
 74     // 获取管理员对象 
 75     public static Admin getAdmin() { 
 76         try { 
 77             admin = conn.getAdmin(); 
 78         } catch (IOException e) { 
 79             e.printStackTrace(); 
 80         } 
 81         return admin; 
 82     } 
 83  
 84     // 查询所有表 
 85     @Override 
 86     public void getAllTables() throws Exception { 
 87         //获取列簇的描述信息 
 88         HTableDescriptor[] listTables = admin.listTables(); 
 89         for (HTableDescriptor listTable : listTables) { 
 90             //转化为表名 
 91             String tbName = listTable.getNameAsString(); 
 92             //获取列的描述信息 
 93             HColumnDescriptor[] columnFamilies = listTable.getColumnFamilies(); 
 94             System.out.println("tableName:"+tbName); 
 95             for(HColumnDescriptor columnFamilie : columnFamilies) { 
 96                 //获取列簇的名字 
 97                 String columnFamilyName = columnFamilie.getNameAsString(); 
 98                 System.out.print("/t"+"columnFamilyName:"+columnFamilyName); 
 99             } 
100             System.out.println(); 
101         } 
102  
103     } 
104  
105     // 创建表，传参，表名和列簇的名字 
106     @Override 
107     public void createTable(String tableName, String[] family) throws Exception { 
108          
109         TableName name = TableName.valueOf(tableName); 
110         //判断表是否存在 
111         if(admin.tableExists(name)) { 
112             System.out.println("table已经存在！"); 
113         }else { 
114             //表的列簇示例 
115             HTableDescriptor htd = new HTableDescriptor(name); 
116             //向列簇中添加列的信息 
117             for(String str : family) { 
118                 HColumnDescriptor hcd = new HColumnDescriptor(str); 
119                 htd.addFamily(hcd); 
120             } 
121             //创建表 
122             admin.createTable(htd); 
123             //判断表是否创建成功 
124             if(admin.tableExists(name)) { 
125                 System.out.println("table创建成功"); 
126             }else { 
127                 System.out.println("table创建失败"); 
128             } 
129         }     
130          
131     } 
132  
133     // 创建表，传参:封装好的多个列簇 
134     @Override 
135     public void createTable(HTableDescriptor htds) throws Exception { 
136         //获得表的名字 
137         String tbName = htds.getNameAsString(); 
138          
139         admin.createTable(htds); 
140     } 
141  
142     // 创建表，传参，表名和封装好的多个列簇 
143     @Override 
144     public void createTable(String tableName, HTableDescriptor htds) throws Exception { 
145  
146         TableName name = TableName.valueOf(tableName); 
147          
148         if(admin.tableExists(name)) { 
149             System.out.println("table已经存在！"); 
150         }else { 
151             admin.createTable(htds); 
152             boolean flag = admin.tableExists(name); 
153             System.out.println(flag ? "创建成功" : "创建失败"); 
154         } 
155          
156     } 
157  
158      
159     // 查看表的列簇属性 
160     @Override 
161     public void descTable(String tableName) throws Exception { 
162         //转化为表名 
163         TableName name = TableName.valueOf(tableName); 
164         //判断表是否存在 
165         if(admin.tableExists(name)) { 
166             //获取表中列簇的描述信息 
167             HTableDescriptor tableDescriptor = admin.getTableDescriptor(name); 
168             //获取列簇中列的信息 
169             HColumnDescriptor[] columnFamilies = tableDescriptor.getColumnFamilies(); 
170             for(HColumnDescriptor columnFamily : columnFamilies) { 
171                 System.out.println(columnFamily); 
172             } 
173              
174         }else { 
175             System.out.println("table不存在"); 
176         } 
177          
178     } 
179  
180     // 判断表存在不存在 
181     @Override 
182     public boolean existTable(String tableName) throws Exception { 
183         TableName name = TableName.valueOf(tableName); 
184         return admin.tableExists(name); 
185     } 
186  
187     // disable表 
188     @Override 
189     public void disableTable(String tableName) throws Exception { 
190          
191         TableName name = TableName.valueOf(tableName); 
192          
193         if(admin.tableExists(name)) { 
194             if(admin.isTableEnabled(name)) { 
195                 admin.disableTable(name); 
196             }else { 
197                 System.out.println("table不是活动状态"); 
198             } 
199         }else { 
200             System.out.println("table不存在"); 
201         } 
202              
203     } 
204  
205     // drop表 
206     @Override 
207     public void dropTable(String tableName) throws Exception { 
208         //转化为表名 
209         TableName name = TableName.valueOf(tableName); 
210         //判断表是否存在 
211         if(admin.tableExists(name)) { 
212             //判断表是否处于可用状态 
213             boolean tableEnabled = admin.isTableEnabled(name); 
214              
215             if(tableEnabled) { 
216                 //使表变成不可用状态 
217                 admin.disableTable(name); 
218             } 
219             //删除表 
220             admin.deleteTable(name); 
221             //判断表是否存在 
222             if(admin.tableExists(name)) { 
223                 System.out.println("删除失败"); 
224             }else { 
225                 System.out.println("删除成功"); 
226             } 
227              
228         }else { 
229             System.out.println("table不存在"); 
230         }  
231          
232          
233     } 
234      
235     // 修改表(增加和删除) 
236     @Override 
237     public void modifyTable(String tableName) throws Exception { 
238         //转化为表名 
239         TableName name = TableName.valueOf(tableName); 
240         //判断表是否存在 
241         if(admin.tableExists(name)) { 
242             //判断表是否可用状态 
243             boolean tableEnabled = admin.isTableEnabled(name); 
244              
245             if(tableEnabled) { 
246                 //使表变成不可用 
247                 admin.disableTable(name); 
248             } 
249             //根据表名得到表 
250             HTableDescriptor tableDescriptor = admin.getTableDescriptor(name); 
251             //创建列簇结构对象 
252             HColumnDescriptor columnFamily1 = new HColumnDescriptor("cf1".getBytes()); 
253             HColumnDescriptor columnFamily2 = new HColumnDescriptor("cf2".getBytes()); 
254              
255             tableDescriptor.addFamily(columnFamily1); 
256             tableDescriptor.addFamily(columnFamily2); 
257             //替换该表所有的列簇 
258             admin.modifyTable(name, tableDescriptor); 
259              
260         }else { 
261             System.out.println("table不存在"); 
262         }  
263     } 
264  
265     // 修改表(增加和删除) 
266     @Override 
267     public void modifyTable(String tableName, String[] addColumn, String[] removeColumn) throws Exception { 
268         //转化为表名 
269         TableName name = TableName.valueOf(tableName); 
270         //判断表是否存在 
271         if(admin.tableExists(name)) { 
272             //判断表是否可用状态 
273             boolean tableEnabled = admin.isTableEnabled(name); 
274              
275             if(tableEnabled) { 
276                 //使表变成不可用 
277                 admin.disableTable(name); 
278             } 
279             //根据表名得到表 
280             HTableDescriptor tableDescriptor = admin.getTableDescriptor(name); 
281             //创建列簇结构对象，添加列 
282             for(String add : addColumn) { 
283                 HColumnDescriptor addColumnDescriptor = new HColumnDescriptor(add); 
284                 tableDescriptor.addFamily(addColumnDescriptor); 
285             } 
286             //创建列簇结构对象，删除列 
287             for(String remove : removeColumn) { 
288                 HColumnDescriptor removeColumnDescriptor = new HColumnDescriptor(remove); 
289                 tableDescriptor.removeFamily(removeColumnDescriptor.getName()); 
290             } 
291              
292             admin.modifyTable(name, tableDescriptor); 
293              
294              
295         }else { 
296             System.out.println("table不存在"); 
297         }  
298          
299     } 
300  
301     @Override 
302     public void modifyTable(String tableName, HColumnDescriptor hcds) throws Exception { 
303         //转化为表名 
304         TableName name = TableName.valueOf(tableName); 
305         //根据表名得到表 
306         HTableDescriptor tableDescriptor = admin.getTableDescriptor(name); 
307         //获取表中所有的列簇信息 
308         HColumnDescriptor[] columnFamilies = tableDescriptor.getColumnFamilies(); 
309          
310         boolean flag = false; 
311         //判断参数中传入的列簇是否已经在表中存在 
312         for(HColumnDescriptor columnFamily : columnFamilies) { 
313             if(columnFamily.equals(hcds)) { 
314                 flag = true; 
315             } 
316         }     
317         //存在提示，不存在直接添加该列簇信息 
318         if(flag) { 
319             System.out.println("该列簇已经存在"); 
320         }else { 
321             tableDescriptor.addFamily(hcds); 
322             admin.modifyTable(name, tableDescriptor); 
323         } 
324          
325     } 
326  
327      
328     /**添加数据 
329     *tableName:    表明 
330     *rowKey:    行键 
331     *familyName:列簇 
332     *columnName:列名 
333     *value:        值 
334     */ 
335     @Override 
336     public void putData(String tableName, String rowKey, String familyName, String columnName, String value) 
337             throws Exception { 
338         //转化为表名 
339         TableName name = TableName.valueOf(tableName); 
340         //添加数据之前先判断表是否存在，不存在的话先创建表 
341         if(admin.tableExists(name)) { 
342          
343         }else { 
344             //根据表明创建表结构 
345             HTableDescriptor tableDescriptor = new HTableDescriptor(name); 
346             //定义列簇的名字 
347             HColumnDescriptor columnFamilyName = new HColumnDescriptor(familyName); 
348             tableDescriptor.addFamily(columnFamilyName); 
349             admin.createTable(tableDescriptor); 
350          
351         } 
352  
353         Table table = conn.getTable(name); 
354         Put put = new Put(rowKey.getBytes()); 
355          
356         put.addColumn(familyName.getBytes(), columnName.getBytes(), value.getBytes()); 
357         table.put(put); 
358  
359     } 
360  
361     @Override 
362     public void putData(String tableName, String rowKey, String familyName, String columnName, String value, 
363             long timestamp) throws Exception { 
364  
365         // 转化为表名 
366         TableName name = TableName.valueOf(tableName); 
367         // 添加数据之前先判断表是否存在，不存在的话先创建表 
368         if (admin.tableExists(name)) { 
369  
370         } else { 
371             // 根据表明创建表结构 
372             HTableDescriptor tableDescriptor = new HTableDescriptor(name); 
373             // 定义列簇的名字 
374             HColumnDescriptor columnFamilyName = new HColumnDescriptor(familyName); 
375             tableDescriptor.addFamily(columnFamilyName); 
376             admin.createTable(tableDescriptor); 
377  
378         } 
379  
380         Table table = conn.getTable(name); 
381         Put put = new Put(rowKey.getBytes()); 
382  
383         //put.addColumn(familyName.getBytes(), columnName.getBytes(), value.getBytes()); 
384         put.addImmutable(familyName.getBytes(), columnName.getBytes(), timestamp, value.getBytes()); 
385         table.put(put); 
386  
387     } 
388  
389  
390     // 根据rowkey查询数据 
391     @Override 
392     public Result getResult(String tableName, String rowKey) throws Exception { 
393          
394         Result result; 
395         TableName name = TableName.valueOf(tableName); 
396         if(admin.tableExists(name)) { 
397             Table table = conn.getTable(name); 
398             Get get = new Get(rowKey.getBytes()); 
399             result = table.get(get); 
400              
401         }else { 
402             result = null; 
403         } 
404          
405         return result; 
406     } 
407  
408     // 根据rowkey查询数据 
409     @Override 
410     public Result getResult(String tableName, String rowKey, String familyName) throws Exception { 
411         Result result; 
412         TableName name = TableName.valueOf(tableName); 
413         if(admin.tableExists(name)) { 
414             Table table = conn.getTable(name); 
415             Get get = new Get(rowKey.getBytes()); 
416             get.addFamily(familyName.getBytes()); 
417             result = table.get(get); 
418              
419         }else { 
420             result = null; 
421         } 
422          
423         return result; 
424     } 
425  
426     // 根据rowkey查询数据 
427     @Override 
428     public Result getResult(String tableName, String rowKey, String familyName, String columnName) throws Exception { 
429          
430         Result result; 
431         TableName name = TableName.valueOf(tableName); 
432         if(admin.tableExists(name)) { 
433             Table table = conn.getTable(name); 
434             Get get = new Get(rowKey.getBytes()); 
435             get.addColumn(familyName.getBytes(), columnName.getBytes()); 
436             result = table.get(get); 
437              
438         }else { 
439             result = null; 
440         } 
441          
442         return result; 
443     } 
444  
445     // 查询指定version 
446     @Override 
447     public Result getResultByVersion(String tableName, String rowKey, String familyName, String columnName, 
448             int versions) throws Exception { 
449          
450         Result result; 
451         TableName name = TableName.valueOf(tableName); 
452         if(admin.tableExists(name)) { 
453             Table table = conn.getTable(name); 
454             Get get = new Get(rowKey.getBytes()); 
455             get.addColumn(familyName.getBytes(), columnName.getBytes()); 
456             get.setMaxVersions(versions); 
457             result = table.get(get); 
458              
459         }else { 
460             result = null; 
461         } 
462          
463         return result; 
464     } 
465  
466     // scan全表数据 
467     @Override 
468     public ResultScanner getResultScann(String tableName) throws Exception { 
469          
470         ResultScanner result; 
471         TableName name = TableName.valueOf(tableName); 
472         if(admin.tableExists(name)) { 
473             Table table = conn.getTable(name); 
474             Scan scan = new Scan(); 
475             result = table.getScanner(scan); 
476              
477         }else { 
478             result = null; 
479         } 
480          
481         return result; 
482     } 
483  
484     // scan全表数据 
485     @Override 
486     public ResultScanner getResultScann(String tableName, Scan scan) throws Exception { 
487          
488         ResultScanner result; 
489         TableName name = TableName.valueOf(tableName); 
490         if(admin.tableExists(name)) { 
491             Table table = conn.getTable(name); 
492             result = table.getScanner(scan); 
493              
494         }else { 
495             result = null; 
496         } 
497          
498         return result; 
499     } 
500  
501     // 删除数据（指定的列） 
502     @Override 
503     public void deleteColumn(String tableName, String rowKey) throws Exception { 
504          
505         TableName name = TableName.valueOf(tableName); 
506         if(admin.tableExists(name)) { 
507             Table table = conn.getTable(name); 
508             Delete delete = new Delete(rowKey.getBytes()); 
509             table.delete(delete); 
510          
511         }else { 
512             System.out.println("table不存在"); 
513         } 
514          
515          
516     } 
517  
518     // 删除数据（指定的列） 
519     @Override 
520     public void deleteColumn(String tableName, String rowKey, String falilyName) throws Exception { 
521          
522         TableName name = TableName.valueOf(tableName); 
523         if(admin.tableExists(name)) { 
524             Table table = conn.getTable(name); 
525             Delete delete = new Delete(rowKey.getBytes()); 
526             delete.addFamily(falilyName.getBytes()); 
527             table.delete(delete); 
528          
529         }else { 
530             System.out.println("table不存在"); 
531         } 
532          
533     } 
534  
535     // 删除数据（指定的列） 
536     @Override 
537     public void deleteColumn(String tableName, String rowKey, String falilyName, String columnName) throws Exception { 
538         TableName name = TableName.valueOf(tableName); 
539         if(admin.tableExists(name)) { 
540             Table table = conn.getTable(name); 
541             Delete delete = new Delete(rowKey.getBytes()); 
542             delete.addColumn(falilyName.getBytes(), columnName.getBytes()); 
543             table.delete(delete); 
544          
545         }else { 
546             System.out.println("table不存在"); 
547         } 
548     } 
549  
550 }