devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

云计算于大数据入门实验三——熟悉常用的 HBase 操作

作者：羊村懒王 | 2024-06-04 21:08:45

赞

踩

熟悉常用的hbase操作

云计算于大数据入门实验三——熟悉常用的 HBase 操作

实验目的

理解HBase在Hadoop体系结构中的角色

熟练使用HBase操作常用的shell命令

熟悉HBase操作常用的Java API

实验要求

  1. 保存程序，并自行存档

  2. 最终的程序都必须经过测试，验证是正确的

  3. 按照实验报告格式，认真记录实验过程及结果，回答实验报告中的问题。实验报告模板在学习通的资料里面下载。学生提交的实验报告需转换成PDF文件提交

image

实验步骤

Hbase 常用命令

  1. 在 Hbase 中建表
create 'student','Sname','Ssex','Sage','Sdept','course'

image

  1. 查看表结构
describe 'student'

image

  1. 添加数据
  1. put 'student', '95001','Sname','LiYing'
  2. put 'student','95001','course:math','80'

image

  1. 查看数据
get 'student','95001'

image

  1. 删除数据
  1. delete 'student','95001','Sname:firstName'
  2. deleteall 'student','95001'

image

  1. 删除表
  1. disable 'student'      #让表不可用
  2. drop 'student'         #删除表

image

  1. 查询历史数据
  1. create 'teacher',{NAME=>'username',VERSIONS=>5}
  2. put 'teacher','91001','username','Mary'
  3. put 'teacher','91001','username','Mary1'
  4. put 'teacher','91001','username','Mary2'
  5. put 'teacher','91001','username','Mary3'
  6. put 'teacher','91001','username','Mary4'
  7. put 'teacher','91001','username','Mary5'
  8. get 'teacher','91001',{COLUMN=>'username',VERSIONS=>3}

image

  1. 退出 HBase
exit

image

编程实践

例子：创建表，插入数据，查看表中数据

  1. import org.apache.hadoop.conf.Configuration;
  2. import org.apache.hadoop.hbase.*;
  3. import org.apache.hadoop.hbase.client.*;
  4. import org.apache.hadoop.hbase.util.Bytes;
  5.  
  6. import java.io.IOException;
  7. public class ExampleForHBase {
  8.     public static Configuration configuration;
  9.     public static Connection connection;
  10.     public static Admin admin;
  11.     public static void main(String[] args)throws IOException{
  12.         init();　　　　//主要操作就是为了连接到数据库hbase
  13.         createTable("student",new String[]{"score"});　　　　//创建表，shell命令：create '表名'，'列族名1'，'列族名2'，'列族名3' ...
  14.         insertData("student","zhangsan","score","English","69"); //shell命令： put 'student'，'张三'，'score：English'，'69'
  15.         insertData("student","zhangsan","score","Math","86");
  16.         insertData("student","zhangsan","score","Computer","77");
  17.         getData("student", "zhangsan", "score","English");
  18.         close();
  19.     }
  20.  
  21.     public static void init(){
  22.         configuration  = HBaseConfiguration.create();
  23.         configuration.set("hbase.rootdir","hdfs://localhost:9000/hbase");
  24.         try{
  25.             connection = ConnectionFactory.createConnection(configuration);
  26.             admin = connection.getAdmin();
  27.         }catch (IOException e){
  28.             e.printStackTrace();
  29.         }
  30.     }
  31.  
  32.     public static void close(){
  33.         try{
  34.             if(admin != null){
  35.                 admin.close();
  36.             }
  37.             if(null != connection){
  38.                 connection.close();
  39.             }
  40.         }catch (IOException e){
  41.             e.printStackTrace();
  42.         }
  43.     }
  44.  
  45.     public static void createTable(String myTableName,String[] colFamily) throws IOException {
  46.         TableName tableName = TableName.valueOf(myTableName);
  47.         if(admin.tableExists(tableName)){
  48.             System.out.println("talbe is exists!");
  49.         }else {
  50.             TableDescriptorBuilder tableDescriptor = TableDescriptorBuilder.newBuilder(tableName);
  51.             for(String str:colFamily){
  52.                 ColumnFamilyDescriptor family = 
  53. ColumnFamilyDescriptorBuilder.newBuilder(Bytes.toBytes(str)).build();
  54.                 tableDescriptor.setColumnFamily(family);
  55.             }
  56.             admin.createTable(tableDescriptor.build());
  57.         } 
  58.     }
  59.  
  60.     public static void insertData(String tableName,String rowKey,String colFamily,String col,String val) throws IOException { 
  61.         Table table = connection.getTable(TableName.valueOf(tableName));
  62.         Put put = new Put(rowKey.getBytes());
  63.         put.addColumn(colFamily.getBytes(),col.getBytes(), val.getBytes());
  64.         table.put(put);
  65.         table.close(); 
  66.     }
  67.  
  68.     public static void getData(String tableName,String rowKey,String colFamily, String col)throws  IOException{ 
  69.         Table table = connection.getTable(TableName.valueOf(tableName));
  70.         Get get = new Get(rowKey.getBytes());
  71.         get.addColumn(colFamily.getBytes(),col.getBytes());
  72.         Result result = table.get(get);
  73.         System.out.println(new String(result.getValue(colFamily.getBytes(),col==null?null:col.getBytes())));
  74.         table.close(); 
  75.     }
  76. }

image

实验三 熟悉常用的HBase 操作

编程实现以下指定功能，并用 Hadoop 提供的 HBase Shell 命令完成相同任务：

  • 列出 HBase 所有的表的相关信息，例如表名；

  • 在终端打印出指定的表的所有记录数据；

  • 向已经创建好的表添加和删除指定的列族或列；

  • 清空指定的表的所有记录数据；

  • 统计表的行数。

列出 HBase 所有的表的相关信息，例如表名：

  1. /**
  2. * 同样是正常的建立 数据库连接，执行操作，然后最后关闭连接
  3. *  重点是：HTableDescriptor hTableDescriptors[] = admin.listTables(); 获取到 表格列表，然后遍历
  4. */
  5. import java.io.IOException;
  6. import org.apache.hadoop.conf.Configuration;
  7. import org.apache.hadoop.hbase.*;
  8. import org.apache.hadoop.hbase.client.*;
  9. import java.io.IOException;
  10. public class Test_1 {
  11.     public static Configuration configuration;
  12.     public static Connection connection;
  13.     public static Admin admin;
  14.     /**
  15.      * 建立连接
  16.      */
  17.     public static void init() {
  18.         configuration = HBaseConfiguration.create();
  19.         configuration.set("hbase.rootdir", "hdfs://localhost:9000/hbase");
  20.         try {
  21.             connection = ConnectionFactory.createConnection(configuration);
  22.             admin = connection.getAdmin();
  23.         } catch (IOException e) {
  24.             e.printStackTrace();
  25.         }
  26.     }
  27.     /**
  28.      * 关闭连接
  29.      */
  30.     public static void close() {
  31.         try {
  32.             if (admin != null) {
  33.                 admin.close();
  34.             }
  35.             if (null != connection) {
  36.                 connection.close();
  37.             }
  38.         } catch (IOException e) {
  39.             e.printStackTrace();
  40.         }
  41.  
  42.     }
  43.     /**
  44.      * 
  45.      * 查看已有表,通过方法listTables()
  46.      * 
  47.      * @throws IOException
  48.      * 
  49.      */
  50.     public static void listTables() throws IOException {
  51.         init();
  52.         HTableDescriptor hTableDescriptors[] = admin.listTables();
  53.         for (HTableDescriptor hTableDescriptor : hTableDescriptors) {
  54.             System.out.println(hTableDescriptor.getNameAsString());
  55.         }
  56.         close();
  57.     }
  58.     
  59.     public static void main(String[] args) {
  60.         Test_1 t = new Test_1();
  61.         try {
  62.             System.out.println("以下为Hbase 数据库中所存的表信息");
  63.             t.listTables();
  64.         } catch (IOException e) {
  65.             e.printStackTrace();
  66.         }
  67.     }
  68. }

image

在终端打印出指定的表的所有记录数据；

  1. /**
  2. * 同样是正常的建立 数据库连接，执行操作，然后最后关闭连接
  3. * 重点是： 
  4. * Table table = connection.getTable(TableName.valueOf(tableName));获取到表格对象
  5. * Scan scan = new Scan(); ResultScanner scanner = table.getScanner(scan); 然后通过Scanner对象，获取到ResultScanner扫描结果对象，遍历输出
  6. */
  7. import java.io.IOException;
  8. import org.apache.hadoop.conf.Configuration;
  9. import org.apache.hadoop.hbase.*;
  10. import org.apache.hadoop.hbase.client.*;
  11. import java.io.IOException;
  12. import java.util.Scanner;
  13. public class Test_2 {
  14.     public static Configuration configuration;
  15.     public static Connection connection;
  16.     public static Admin admin;
  17.     // 建立连接
  18.     public static void init() {
  19.         configuration = HBaseConfiguration.create();
  20.         configuration.set("hbase.rootdir", "hdfs://localhost:9000/hbase");
  21.         try {
  22.             connection = ConnectionFactory.createConnection(configuration);
  23.             admin = connection.getAdmin();
  24.         } catch (IOException e) {
  25.             e.printStackTrace();
  26.         }
  27.     }
  28.     // 关闭连接
  29.     public static void close() {
  30.         try {
  31.             if (admin != null) {
  32.                 admin.close();
  33.             }
  34.             if (null != connection) {
  35.                 connection.close();
  36.             }
  37.         } catch (IOException e) {
  38.             e.printStackTrace();
  39.  
  40.         }
  41.     }
  42.     /**
  43.      * 
  44.      * 根据表名查找表信息
  45.      * 
  46.      */
  47.     public static void getData(String tableName) throws IOException {
  48.         init();
  49.         Table table = connection.getTable(TableName.valueOf(tableName));
  50.         Scan scan = new Scan();
  51.         ResultScanner scanner = table.getScanner(scan);
  52.         for (Result result : scanner)
  53.         {
  54.             showCell((result));
  55.         }
  56.         close();
  57.     }
  58.  
  59.     /**
  60.      * 
  61.      * 格式化输出
  62.      * 
  63.      * @param result
  64.      * 
  65.      */
  66.     public static void showCell(Result result) {
  67.         Cell[] cells = result.rawCells();
  68.         for (Cell cell : cells) {
  69.             System.out.println("RowName(行键):" + new String(CellUtil.cloneRow(cell)) + " ");
  70.             System.out.println("Timetamp(时间戳):" + cell.getTimestamp() + " ");
  71.             System.out.println("column Family(列簇):" + new String(CellUtil.cloneFamily(cell)) + " ");
  72.             System.out.println("column Name(列名):" + new String(CellUtil.cloneQualifier(cell)) + " ");
  73.             System.out.println("value:(值)" + new String(CellUtil.cloneValue(cell)) + " ");
  74.             System.out.println();
  75.         }
  76.     }
  77.     public static void main(String[] args) throws IOException {
  78. // TODO Auto-generated method stub
  79.         Test_2 t = new Test_2();
  80.         System.out.println("请输入要查看的表名");
  81.         Scanner scan = new Scanner(System.in);
  82.         String tableName = scan.nextLine();
  83.         System.out.println("信息如下：");
  84.         t.getData(tableName);
  85.     }
  86. }

image

向已经创建好的表添加和删除指定的列族或列:

  1. put 'student','95003','Sname','wangjinxuan' 　　　　(添加列)
  2.  
  3. put 'student','95003','Sname:nickName','wang'　　　　(添加列族)
  4.  
  5. put 'student','95003','Sname:firstName','jinxuan'    (添加列族)
  6.  
  7. put的反向操作的delete：
  8.  
  9. delete 'student' ,’95003’,’Sname’
  10.  
  11. delete 'student' ,’95003’,’Sname:nickName’
  12.  
  13. deleteall 'student' ,’95003’   　(删除整个行记录)

image

image

image

image

  1. /**
  2.  * hbase只关注rowkey，column Family(列族)，并没有说在创建表的时候指定cq(列限定修饰符)有多少，这也是hbase列式存储的特点，
  3.  *     所以在hbase API中是没有提供delete 一个列下的所有数据的
  4.  * 
  5.  *     同样是正常的建立 数据库连接，执行操作，然后最后关闭连接
  6.  * 1，Table table = connection.getTable(TableName.valueOf(tableName)); 先获取到表
  7.  * 2，插入：(① 创建Put对象，② 然后通过方法 addColumn将列、列限定符、值 放到put对象，③ 最后将put对象put到表格)
  8.  *     Put put = new Put(rowKey.getBytes());
  9.  *  put.addColumn(colFamily.getBytes(), col.getBytes(), val.getBytes());
  10.  *  table.put(put);        
  11.  * 3，删除：
  12.  * Table table = connection.getTable(TableName.valueOf(tableName)); 同样首先获取到表
  13.  * Delete delete = new Delete(rowKey.getBytes());    //通过传入行键，new一个删除对象    
  14.  * //删除对象添加要被删除的列或列族                        
  15.  * ① 删除指定列族的所有数据(此情况是列族下无列限定符时的情况)：delete.addFamily(colFamily.getBytes());        
  16.  * ② 删除指定列的数据(此列主要说的是列限定修饰符)：delete.addColumn(colFamily.getBytes(), col.getBytes());
  17.  * table.delete(delete); //最后就是表格delete掉 delete对象
  18.  */
  19. import java.io.IOException;
  20. import java.util.Scanner;
  21. import org.apache.hadoop.conf.Configuration;
  22. import org.apache.hadoop.hbase.Cell;
  23. import org.apache.hadoop.hbase.CellUtil;
  24. import org.apache.hadoop.hbase.HBaseConfiguration;
  25. import org.apache.hadoop.hbase.TableName;
  26. import org.apache.hadoop.hbase.client.Admin;
  27. import org.apache.hadoop.hbase.client.Connection;
  28. import org.apache.hadoop.hbase.client.ConnectionFactory;
  29. import org.apache.hadoop.hbase.client.Delete;
  30. import org.apache.hadoop.hbase.client.Put;
  31. import org.apache.hadoop.hbase.client.Result;
  32. import org.apache.hadoop.hbase.client.ResultScanner;
  33. import org.apache.hadoop.hbase.client.Scan;
  34. import org.apache.hadoop.hbase.client.Table;
  35.  
  36. public class Test_3 {
  37.     public static Configuration configuration;
  38.     public static Connection connection;
  39.     public static Admin admin;
  40.  
  41.     // 建立连接
  42.     public static void init() {
  43.         configuration = HBaseConfiguration.create();
  44.         configuration.set("hbase.rootdir", "hdfs://localhost:9000/hbase");
  45.         try {
  46.             connection = ConnectionFactory.createConnection(configuration);
  47.             admin = connection.getAdmin();
  48.         } catch (IOException e) {
  49.             e.printStackTrace();
  50.         }
  51.     }
  52.  
  53.     // 关闭连接
  54.     public static void close() {
  55.         try {
  56.             if (admin != null) {
  57.                 admin.close();
  58.             }
  59.             if (null != connection) {
  60.                 connection.close();
  61.             }
  62.         } catch (IOException e) {
  63.             e.printStackTrace();
  64.         }
  65.     }
  66.  
  67.     /**
  68.      * 向某一行的某一列插入数据
  69.      * 
  70.      * @param tableName 表名
  71.      * @param rowKey    行键
  72.      * @param colFamily 列族名
  73.      * @param col       列名(如果其列族下没有子列，此参数可为空)
  74.      * @param val       值
  75.      * @throws IOException
  76.      */
  77.     public static void insertRow(String tableName, String rowKey, String colFamily, String col, String val)throws IOException {
  78.         init();
  79.         Table table = connection.getTable(TableName.valueOf(tableName));
  80.         Put put = new Put(rowKey.getBytes());
  81.         put.addColumn(colFamily.getBytes(), col.getBytes(), val.getBytes());
  82.         table.put(put);
  83.         table.close();
  84.         close();
  85.     }
  86.  
  87.     /**
  88.      * 根据表名查找表信息
  89.      */
  90.     public static void getData(String tableName) throws IOException {
  91.         init();
  92.         Table table = connection.getTable(TableName.valueOf(tableName));
  93.         Scan scan = new Scan();
  94.         ResultScanner scanner = table.getScanner(scan);
  95.         for (Result result : scanner) {
  96.             showCell((result));
  97.         }
  98.         close();
  99.     }
  100.     /**
  101.      * 
  102.       * 格式化输出
  103.      * 
  104.      * @param result
  105.      * 
  106.      */
  107.     public static void showCell(Result result) {
  108.         Cell[] cells = result.rawCells();
  109.         for (Cell cell : cells) {
  110.             System.out.println("RowName(行键):" + new String(CellUtil.cloneRow(cell)) + " ");
  111.             System.out.println("Timetamp(时间戳):" + cell.getTimestamp() + " ");
  112.             System.out.println("column Family(列簇):" + new String(CellUtil.cloneFamily(cell)) + " ");
  113.             System.out.println("column Name(列名):" + new String(CellUtil.cloneQualifier(cell)) + " ");
  114.             System.out.println("value:(值)" + new String(CellUtil.cloneValue(cell)) + " ");
  115.             System.out.println();
  116.         }
  117.     }
  118.     /**
  119.      * 
  120.      * 删除数据
  121.      * 
  122.      * @param tableName 表名
  123.      * 
  124.      * @param rowKey    行键
  125.      * 
  126.      * @param colFamily 列族名
  127.      * 
  128.      * @param col       列名
  129.      * 
  130.      * @throws IOException
  131.      * 
  132.      */
  133.     public static void deleteRow(String tableName, String rowKey, String colFamily, String col) throws IOException {
  134.         init();
  135.         Table table = connection.getTable(TableName.valueOf(tableName));
  136.         Delete delete = new Delete(rowKey.getBytes());
  137.         if(col == null) {
  138.             //删除指定列族的所有数据(此情况是列族下无列限定符时的情况)
  139.             delete.addFamily(colFamily.getBytes());
  140.             table.delete(delete);
  141.             table.close();
  142.         }else {
  143.             //删除指定列的数据(此列主要说的是列限定修饰符)
  144.             delete.addColumn(colFamily.getBytes(), col.getBytes());
  145.             table.delete(delete);
  146.             table.close();
  147.         }
  148.         close();
  149.     }
  150.  
  151.     public static void main(String[] args) {
  152.         Test_3 t = new Test_3();
  153.         boolean flag = true;
  154.         while (flag){
  155.             System.out.println("------------向已经创建好的表中添加和删除指定的列簇或列--------------------");
  156.             System.out.println("              请输入您要进行的操作   1- 添加          2-删除                       ");
  157.             Scanner scan = new Scanner(System.in);
  158.             String choose1 = scan.nextLine();
  159.             switch (choose1) {
  160.             case "1":
  161.                 try {
  162.                     //put 'student','95003','Sname','wangjinxuan' 　　　　(添加列)
  163.                     //put 'student','95003','Sname:nickName','wang'　　　　(添加列族)
  164.                     //put 'student','95003','Sname:firstName','jinxuan'  (添加列族)
  165. //                    t.insertRow(tableName, rowKey, colFamily, col, val);
  166.                     t.insertRow("student", "95003", "Sname",null, "wangjingxuan");
  167.                     t.insertRow("student", "95003", "Sname", "nickName", "wang");
  168.                     t.insertRow("student", "95003", "Sname", "firstName", "jingxuan");
  169.                     System.out.println("插入成功：");
  170.                     t.getData(tableName);
  171.                 } catch (IOException e) {
  172.                     e.getMessage();
  173.                 }
  174.                 break;
  175.             case "2":
  176.                 try {
  177.                     System.out.println("----------------------删除前，表的原本信息如下---------------------");
  178.                     t.getData(tableName);
  179.                     //delete 'student' ,’95003’,’Sname’
  180.                     //delete 'student' ,’95003’,’Sname:nickName’
  181. //                    t.deleteRow(tableName, rowKey, colFamily, col);    
  182.                     t.deleteRow("student", "95003", "Sname", "firstName");    
  183.                     System.out.println("-----------------------删除成功-----------------------------\n");
  184.                     System.out.println("---------------------删除后，表的信息如下---------------------");
  185.                     t.getData(tableName);
  186.                 } catch (IOException e) {
  187.                     e.getMessage();
  188.                 }
  189.                 break;
  190.             }
  191.             System.out.println(" 你要继续操作吗？ 是-true 否-false ");
  192.             flag = scan.nextBoolean();
  193.         }
  194.         System.out.println("   程序已退出！    ");
  195.     }
  196. }

image

清空指定的表的所有记录数据：

  1. import java.io.IOException;
  2. import java.util.Scanner;
  3. import org.apache.hadoop.conf.Configuration;
  4. import org.apache.hadoop.hbase.Cell;
  5. import org.apache.hadoop.hbase.CellUtil;
  6. import org.apache.hadoop.hbase.HBaseConfiguration;
  7. import org.apache.hadoop.hbase.HColumnDescriptor;
  8. import org.apache.hadoop.hbase.HTableDescriptor;
  9. import org.apache.hadoop.hbase.TableName;
  10. import org.apache.hadoop.hbase.client.Admin;
  11. import org.apache.hadoop.hbase.client.Connection;
  12. import org.apache.hadoop.hbase.client.ConnectionFactory;
  13. import org.apache.hadoop.hbase.client.HBaseAdmin;
  14. import org.apache.hadoop.hbase.client.Result;
  15. import org.apache.hadoop.hbase.client.ResultScanner;
  16. import org.apache.hadoop.hbase.client.Scan;
  17. import org.apache.hadoop.hbase.client.Table;
  18. import org.apache.hadoop.hbase.util.Bytes;
  19. public class Test_4 {
  20.     public static Configuration configuration;
  21.     public static Connection connection;
  22.     public static Admin admin;
  23.     // 建立连接
  24.     public static void init() {
  25.         configuration = HBaseConfiguration.create();
  26.         configuration.set("hbase.rootdir", "hdfs://localhost:9000/hbase");
  27.         try {
  28.             connection = ConnectionFactory.createConnection(configuration);
  29.             admin = connection.getAdmin();
  30.         } catch (IOException e) {
  31.             e.printStackTrace();
  32.         }
  33.     }
  34.     // 关闭连接
  35.     public static void close() {
  36.         try {
  37.             if (admin != null) {
  38.                 admin.close();
  39.             }
  40.             if (null != connection) {
  41.                 connection.close();
  42.             }
  43.         } catch (IOException e) {
  44.             e.printStackTrace();
  45.         }
  46.     }
  47.     /**
  48.      * 
  49.      * 清空制定的表的所有记录数据
  50.      * 
  51.      * @param args
  52.      * 
  53.      * @throws IOException
  54.      * 
  55.      */
  56.     public static void clearRows(String tableName) throws IOException {
  57.         init();
  58.         HBaseAdmin admin1 = new HBaseAdmin(configuration);
  59.         // 读取了之前表的表名 列簇等信息，然后再进行删除操作。
  60.         HTableDescriptor tDescriptor = admin1.getTableDescriptor(Bytes.toBytes(tableName));
  61.         // 总思想是先将原表结构保留下来，然后进行删除，再重新依据保存的信息重新创建表。
  62.         TableName tablename = TableName.valueOf(tableName);
  63.         // 删除表
  64.         admin.disableTable(tablename);
  65.         admin.deleteTable(tablename);
  66.         // 重新建表
  67.         admin.createTable(tDescriptor);
  68.         close();
  69.     }
  70.     /**
  71.      * 
  72.      * 根据表名查找表信息
  73.      * 
  74.      */
  75.     public static void getData(String tableName) throws IOException {
  76.         init();
  77.         Table table = connection.getTable(TableName.valueOf(tableName));
  78.         Scan scan = new Scan();
  79.         ResultScanner scanner = table.getScanner(scan);
  80.         for (Result result : scanner){
  81.             showCell((result));
  82.         }
  83.         close();
  84.     }
  85.  
  86.     /**
  87.      * 
  88.      * 格式化输出
  89.      * 
  90.      * @param result
  91.      * 
  92.      */
  93.     public static void showCell(Result result) {
  94.         Cell[] cells = result.rawCells();
  95.         for (Cell cell : cells) {
  96.             System.out.println("RowName(行键):" + new String(CellUtil.cloneRow(cell)) + " ");
  97.             System.out.println("Timetamp(时间戳):" + cell.getTimestamp() + " ");
  98.             System.out.println("column Family(列簇):" + new String(CellUtil.cloneFamily(cell)) + " ");
  99.             System.out.println("column Name(列名):" + new String(CellUtil.cloneQualifier(cell)) + " ");
  100.             System.out.println("value:(值)" + new String(CellUtil.cloneValue(cell)) + " ");
  101.             System.out.println();
  102.         }
  103.     }
  104.  
  105.     public static void main(String[] args) {
  106.         Test_4 test_4 = new Test_4();
  107.         Scanner scan = new Scanner(System.in);
  108.         System.out.println("请输入要清空的表名");
  109.         String tableName = scan.nextLine();
  110.         try {
  111.             System.out.println("表原来的信息：");
  112.             test_4.getData(tableName);
  113.             test_4.clearRows(tableName);
  114.             System.out.println("表已清空：");
  115.         } catch (IOException e) {
  116.             e.printStackTrace();
  117.         }
  118.     }
  119. }

image

统计表的行数:

  1. import java.io.IOException;
  2. import java.util.Scanner;
  3. import org.apache.hadoop.conf.Configuration;
  4. import org.apache.hadoop.hbase.HBaseConfiguration;
  5. import org.apache.hadoop.hbase.TableName;
  6. import org.apache.hadoop.hbase.client.Admin;
  7. import org.apache.hadoop.hbase.client.Connection;
  8. import org.apache.hadoop.hbase.client.ConnectionFactory;
  9. import org.apache.hadoop.hbase.client.Result;
  10. import org.apache.hadoop.hbase.client.ResultScanner;
  11. import org.apache.hadoop.hbase.client.Scan;
  12. import org.apache.hadoop.hbase.client.Table;
  13. public class Test_5 {
  14.     public static Configuration configuration;
  15.     public static Connection connection;
  16.     public static Admin admin;
  17.     //建立连接
  18.     public static void init() {
  19.         configuration = HBaseConfiguration.create();
  20.         configuration.set("hbase.rootdir", "hdfs://localhost:9000/hbase");
  21.         try {
  22.             connection = ConnectionFactory.createConnection(configuration);
  23.             admin = connection.getAdmin();
  24.         } catch (IOException e) {
  25.             e.printStackTrace();
  26.         }
  27.     }
  28.     // 关闭连接
  29.     public static void close() {
  30.         try {
  31.             if (admin != null) {
  32.                 admin.close();
  33.             }
  34.             if (null != connection) {
  35.                 connection.close();
  36.             }
  37.         } catch (IOException e) {
  38.             e.printStackTrace();
  39.         }
  40.     }
  41.  
  42.     public static void countRows(String tableName) throws IOException{
  43.         init();
  44.         Table table = connection.getTable(TableName.valueOf(tableName));
  45.         Scan scan = new Scan();
  46.         ResultScanner scanner = table.getScanner(scan);
  47.         int num = 0;
  48.         for (Result result = scanner.next(); result != null; result = scanner.next()){
  49.             num++;
  50.         }
  51.         System.out.println("行数：" + num);
  52.         scanner.close();
  53.         close();
  54.     }
  55.     public static void main(String[] args) throws IOException {
  56.         Test_5 test_5 = new Test_5();
  57.         Scanner scan = new Scanner(System.in);
  58.         System.out.println("请输入要统计行数的表名");
  59.         String tableName = scan.nextLine();
  60.         test_5.countRows(tableName);
  61.     }
  62. }

image

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/673506
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号