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

HBase的编程实践（实验3_熟悉常用的HBase操作）_在右侧命令行中操作,完成 hbase 表 student 的创建,具体要求如下: hbase 表名为

作者：知新_RL | 2024-04-21 22:32:15

赞

踩

在右侧命令行中操作,完成 hbase 表 student 的创建,具体要求如下: hbase 表名为 s

一、Hbase中使用Shell命令：

① HBase中创建表：（create 命令：第一个变量是表名，然后是列族名）

语法：create '表名称','列族名称1','列族名称2','列族名称N'

create 'student','Sname','Ssex','Sage','Sdept','course'

通过命令 describe 'student'  进行查看表的结构：（desc ‘表名’，查看表的结构）

接下来是hbase 常规操作（增删改查） 

✿ 增加数据

② put：（put 命令：第一个变量是表名，第二个变量是行键，第三个变量开始就是添加列族情况啦（列限定符可选）

 注意 put 命令：一次只能为一个表的一行数据的一个列，也就是一次只能给一个单元格添加一个数据，

所以直接用shell命令插入数据效率很低，在实际应用中，一般都是利用编程操作数据。

语法：put '表名称','行名称','列名称:','值'

例子：student表添加了学号为95001，名字为LiYing的一行数据，其行键为95001。

put 'student', '95001','Sname','LiYing'

例子：为95001行下的course列族的math列添加了一个数据：

  put 'student','95001','course:math','80'

在表格中的样子（大概如此，变量名不一定对得上哦，我只是为了展示表格的形式）：

 ✿ 删除数据

③ delete命令：

□ put 的反向操作：

□ 删除 一行中的所有数据：

□ 删除 表：

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

□ put 的反向操作：

  delete 'student','95001','Sname:firstName'

 □ 删除 一行中的所有数据：

  deleteall 'student','95001'

 □ 删除表 ：

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

✿ 查看数据：

□ get： 查看的是一行中的数据

□ scan： 查看的是表中的全部数据

 get 'student','95001'

scan 'student'

 还可以查询部分细节的数据等等细节的数据，例如：查询 某个列族的数据：

 ✿  查询表历史数据：

④ 查询表的历史版本，需要两步。
1、在创建表的时候，指定保存的版本数（假设指定为5）

  create 'teacher',{NAME=>'username',VERSIONS=>5}

2、插入数据然后更新数据，使其产生历史版本数据，注意：这里插入数据和更新数据都是用put命令

  1. put 'teacher','91001','username','Mary'
  2. put 'teacher','91001','username','Mary1'
  3. put 'teacher','91001','username','Mary2'
  4. put 'teacher','91001','username','Mary3'
  5. put 'teacher','91001','username','Mary4'  
  6. put 'teacher','91001','username','Mary5'

3、查询时，指定查询的历史版本数。默认会查询出最新的数据

  get 'teacher','91001',{COLUMN=>'username',VERSIONS=>3}

 ✿ 退出HBase数据库操作

⑤ 命令： exit

注意：这里退出HBase数据库是退出对数据库表的操作，而不是停止启动HBase数据库后台运行。

 二、Hbase编程实践：

✿ 准备工作：导入jar包：

导包步骤：File -》 Project Structure -》Libraries -》+ -》选择需要导入的包，然后记得导入完成后，点击一下 Apply，再点 Ok

（1） 进入到“/usr/local/hbase/lib”目录，选中该目录下的所有jar文件（注意，不要选中client-facing-thirdparty、ruby、shaded-clients和zkcli这四个目录）

（2）  进入到“/usr/local/hbase/lib/client-facing-thirdparty”目录, 选中该目录下的所有jar文件。

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

  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. }

运行程序后，到终端输入：scan ‘student’ 查看一下

三、实验：熟悉常用的HBase 操作：

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

  1. 列出 HBase 所有的表的相关信息，例如表名；
  2. 在终端打印出指定的表的所有记录数据；
  3. 向已经创建好的表添加和删除指定的列族或列；
  4. 清空指定的表的所有记录数据；
  5. 统计表的行数。

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

■ HBase Shell：List

■ Java Api:

  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. }

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

■ HBase Shell：scan 'student'

■ Java Api:

  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. }

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

■ HBase Shell：

  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’   　(删除整个行记录)

■ Java Api:

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

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

■ HBase Shell：truncate 'student'

■ Java Api:

  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. }

5,统计表的行数:

■ HBase Shell：count 'student'

■ Java Api:

  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. }

（二）现有以下关系型数据库中的表和数据，要求将其转换为适合于HBase存储的表并插入数据：

学生表（Student）、课程表（Course）、选课表（SC）：同时，请编程完成以下指定功能：

  1. create 'Student','S_No','S_Name','S_Sex','S_Age'
  2. put 'Student','s001','S_No','2015001'
  3. put 'Student','s001','S_Name','Zhangsan'
  4. put 'Student','s001','S_Sex','male'
  5. put 'Student','s001','S_Age','23'
  6. put 'Student','s002','S_No','2015002'
  7. put 'Student','s002','S_Name','Mary'
  8. put 'Student','s002','S_Sex','female'
  9. put 'Student','s002','S_Age','22'
  10. put 'Student','s003','S_No','2015003'
  11. put 'Student','s003','S_Name','Lisi'
  12. put 'Student','s003','S_Sex','male'
  13. put 'Student','s003','S_Age','24'
  14. —————————————————————————————————————————————————————————————————————————————
  15. create 'Course','C_No','C_Name','C_Credit'
  16. put 'Course','c001','C_No','123001'
  17. put 'Course','c001','C_Name','Math'
  18. put 'Course','c001','C_Credit','2.0'
  19. put 'Course','c002','C_No','123002'
  20. put 'Course','c002','C_Name','Computer'
  21. put 'Course','c002','C_Credit','5.0'
  22. put 'Course','c003','C_No','123003'
  23. put 'Course','c003','C_Name','English'
  24. put 'Course','c003','C_Credit','3.0'
  25. ————————————————————————————————————————————————————————————————————————————————
  26. put 'SC','sc001','SC_Sno','2015001'
  27. put 'SC','sc001','SC_Cno','123001'
  28. put 'SC','sc001','SC_Score','86'
  29. put 'SC','sc002','SC_Sno','2015001'
  30. put 'SC','sc002','SC_Cno','123003'
  31. put 'SC','sc002','SC_Score','69'
  32. put 'SC','sc003','SC_Sno','2015002'
  33. put 'SC','sc003','SC_Cno','123002'
  34. put 'SC','sc003','SC_Score','77'
  35. put 'SC','sc004','SC_Sno','2015002'
  36. put 'SC','sc004','SC_Cno','123003'
  37. put 'SC','sc004','SC_Score','99'
  38. put 'SC','sc005','SC_Sno','2015003'
  39. put 'SC','sc005','SC_Cno','123001'
  40. put 'SC','sc005','SC_Score','98'
  41. put 'SC','sc006','SC_Sno','2015003'
  42. put 'SC','sc006','SC_Cno','123002'
  43. put 'SC','sc006','SC_Score','95'

同时，请编程完成以下指定功能：

① createTable(String tableName, String[] fields)： 创建表，参数tableName为表的名称，字符串数组fields为存储记录各个域名称的数组。

（域名称即列族名称啦）要求当HBase已经存在名为tableName的表的时候，先删除原有的表，然后再创建新的表。

  1. import org.apache.hadoop.conf.Configuration;
  2. import org.apache.hadoop.hbase.HBaseConfiguration;
  3. import org.apache.hadoop.hbase.HColumnDescriptor;
  4. import org.apache.hadoop.hbase.HTableDescriptor;
  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.  
  10. import java.io.IOException;
  11.  
  12. public class CreateTable {
  13.     public static Configuration configuration;
  14.     public static Connection connection;
  15.     public static Admin admin;
  16.  
  17.     public static void createTable(String tableName, String[] fields) throws IOException {
  18.         init();
  19.         TableName tablename = TableName.valueOf(tableName);
  20.         if (admin.tableExists(tablename)) {
  21.             System.out.println("table is exists!");
  22.             admin.disableTable(tablename);
  23.             admin.deleteTable(tablename);
  24.         }
  25.         HTableDescriptor hTableDescriptor = new HTableDescriptor(tablename);
  26.         for (String str : fields) {
  27.             HColumnDescriptor hColumnDescriptor = new HColumnDescriptor(str);
  28.             hTableDescriptor.addFamily(hColumnDescriptor);
  29.         }
  30.         admin.createTable(hTableDescriptor);
  31.         close();
  32.     }
  33.  
  34.     public static void init() {
  35.         configuration = HBaseConfiguration.create();
  36.         configuration.set("hbase.rootdir", "hdfs://localhost:9000/hbase");
  37.         try {
  38.             connection = ConnectionFactory.createConnection(configuration);
  39.             admin = connection.getAdmin();
  40.         } catch (IOException e) {
  41.             e.printStackTrace();
  42.         }
  43.     }
  44.  
  45.     public static void close() {
  46.         try {
  47.             if (admin != null) {
  48.                 admin.close();
  49.             }
  50.             if (null != connection) {
  51.                 connection.close();
  52.             }
  53.         } catch (IOException e) {
  54.             e.printStackTrace();
  55.         }
  56.     }
  57.  
  58.     public static void main(String[] args) {
  59.         String[] fields = {"Score"};
  60.         try {
  61.             createTable("person", fields);
  62.         } catch (IOException e) {
  63.             e.printStackTrace();
  64.         }
  65.     }
  66. }

② addRecord(String tableName, String row, String[] fields, String[] values)： 向表tableName、行row（用S_Name表示）和字符串数组files指定的单元格中添加对应的数据values。其中fields中每个元素如果对应的列族下还有相应的列限定符的话，用"columnFamily:column"表示。例如，同时向"Math"、“Computer Science”、"English"三列添加成绩时，字符串数组fields为{“Score:Math”, “Score: Computer Science”, “Score:English”}，数组values存储这三门课的成绩。

  1. import org.apache.hadoop.conf.Configuration;
  2. import org.apache.hadoop.hbase.HBaseConfiguration;
  3. import org.apache.hadoop.hbase.TableName;
  4. import org.apache.hadoop.hbase.client.*;
  5.  
  6. import java.io.IOException;
  7.  
  8. public class AddRecord {
  9.     public static Configuration configuration;
  10.     public static Connection connection;
  11.     public static Admin admin;
  12.  
  13.     public static void addRecord(String tableName, String row, String[] fields, String[] values) throws IOException {
  14.         init();
  15.         Table table = connection.getTable(TableName.valueOf(tableName));
  16.         for (int i = 0; i != fields.length; i++) {
  17.             Put put = new Put(row.getBytes());
  18.             String[] cols = fields[i].split(":");
  19.             put.addColumn(cols[0].getBytes(), cols[1].getBytes(), values[i].getBytes());
  20.             table.put(put);
  21.         }
  22.         table.close();
  23.         close();
  24.     }
  25.  
  26.     public static void init() {
  27.         configuration = HBaseConfiguration.create();
  28.         configuration.set("hbase.rootdir", "hdfs://localhost:9000/hbase");
  29.         try {
  30.             connection = ConnectionFactory.createConnection(configuration);
  31.             admin = connection.getAdmin();
  32.         } catch (IOException e) {
  33.             e.printStackTrace();
  34.         }
  35.     }
  36.  
  37.     public static void close() {
  38.         try {
  39.             if (admin != null) {
  40.                 admin.close();
  41.             }
  42.             if (null != connection) {
  43.                 connection.close();
  44.             }
  45.         } catch (IOException e) {
  46.             e.printStackTrace();
  47.         }
  48.     }
  49.  
  50.     public static void main(String[] args) {
  51.         String[] fields = {"Score:Math", "Score:Computer Science", "Score:English"};
  52.         String[] values = {"99", "80", "100"};
  53.         try {
  54.             addRecord("person", "Score", fields, values);
  55.         } catch (IOException e) {
  56.             e.printStackTrace();
  57.         }
  58.  
  59.     }
  60. }

③ scanColumn(String tableName, String column)： 浏览表tableName某一列的数据，如果某一行记录中该列数据不存在，则返回null。要求当参数column为某一列族名称时，如果底下有若干个列限定符，则要列出每个列限定符代表的列的数据；当参数column为某一列具体名称（例如"Score:Math"）时，只需要列出该列的数据。

  1. import org.apache.hadoop.conf.Configuration;
  2. import org.apache.hadoop.hbase.Cell;
  3. import org.apache.hadoop.hbase.CellUtil;
  4. import org.apache.hadoop.hbase.HBaseConfiguration;
  5. import org.apache.hadoop.hbase.TableName;
  6. import org.apache.hadoop.hbase.client.*;
  7. import org.apache.hadoop.hbase.util.Bytes;
  8.  
  9. import java.io.IOException;
  10.  
  11. public class ScanColumn {
  12.     public static Configuration configuration;
  13.     public static Connection connection;
  14.     public static Admin admin;
  15.  
  16.     public static void scanColumn(String tableName, String column) throws IOException {
  17.         init();
  18.         Table table = connection.getTable(TableName.valueOf(tableName));
  19.         Scan scan = new Scan();
  20.         scan.addFamily(Bytes.toBytes(column));
  21.         ResultScanner scanner = table.getScanner(scan);
  22.         for (Result result = scanner.next(); result != null; result = scanner.next()) {
  23.             showCell(result);
  24.         }
  25.         table.close();
  26.         close();
  27.     }
  28.  
  29.     public static void showCell(Result result) {
  30.         Cell[] cells = result.rawCells();
  31.         for (Cell cell : cells) {
  32.             System.out.println("RowName:" + new String(CellUtil.cloneRow(cell)) + " ");
  33.             System.out.println("Timetamp:" + cell.getTimestamp() + " ");
  34.             System.out.println("column Family:" + new String(CellUtil.cloneFamily(cell)) + " ");
  35.             System.out.println("row Name:" + new String(CellUtil.cloneQualifier(cell)) + " ");
  36.             System.out.println("value:" + new String(CellUtil.cloneValue(cell)) + " ");
  37.         }
  38.     }
  39.  
  40.     public static void init() {
  41.         configuration = HBaseConfiguration.create();
  42.         configuration.set("hbase.rootdir", "hdfs://localhost:9000/hbase");
  43.         try {
  44.             connection = ConnectionFactory.createConnection(configuration);
  45.             admin = connection.getAdmin();
  46.         } catch (IOException e) {
  47.             e.printStackTrace();
  48.         }
  49.     }
  50.  
  51.     // 关闭连接
  52.     public static void close() {
  53.         try {
  54.             if (admin != null) {
  55.                 admin.close();
  56.             }
  57.             if (null != connection) {
  58.                 connection.close();
  59.             }
  60.         } catch (IOException e) {
  61.             e.printStackTrace();
  62.         }
  63.     }
  64.  
  65.     public static void main(String[] args) {
  66.         try {
  67.             scanColumn("person", "Score");
  68.         } catch (IOException e) {
  69.             e.printStackTrace();
  70.         }
  71.  
  72.     }
  73. }

④ modifyData(String tableName, String row, String column)： 修改表tableName，行row（可以用学生姓名S_Name表示），列column指定的单元格的数据。

  1. import org.apache.hadoop.conf.Configuration;
  2. import org.apache.hadoop.hbase.Cell;
  3. import org.apache.hadoop.hbase.HBaseConfiguration;
  4. import org.apache.hadoop.hbase.TableName;
  5. import org.apache.hadoop.hbase.client.*;
  6.  
  7. import java.io.IOException;
  8.  
  9. public class ModifyData {
  10.  
  11.     public static long ts;
  12.     public static Configuration configuration;
  13.     public static Connection connection;
  14.     public static Admin admin;
  15.  
  16.     public static void modifyData(String tableName, String row, String column, String val) throws IOException {
  17.         init();
  18.         Table table = connection.getTable(TableName.valueOf(tableName));
  19.         Put put = new Put(row.getBytes());
  20.         Scan scan = new Scan();
  21.         ResultScanner resultScanner = table.getScanner(scan);
  22.         for (Result r : resultScanner) {
  23.             for (Cell cell : r.getColumnCells(row.getBytes(), column.getBytes())) {
  24.                 ts = cell.getTimestamp();
  25.             }
  26.         }
  27.         put.addColumn(row.getBytes(), column.getBytes(), ts, val.getBytes());
  28.         table.put(put);
  29.         table.close();
  30.         close();
  31.     }
  32.  
  33.     public static void init() {
  34.         configuration = HBaseConfiguration.create();
  35.         configuration.set("hbase.rootdir", "hdfs://localhost:9000/hbase");
  36.         try {
  37.             connection = ConnectionFactory.createConnection(configuration);
  38.             admin = connection.getAdmin();
  39.         } catch (IOException e) {
  40.             e.printStackTrace();
  41.         }
  42.     }
  43.  
  44.     public static void close() {
  45.         try {
  46.             if (admin != null) {
  47.                 admin.close();
  48.             }
  49.             if (null != connection) {
  50.                 connection.close();
  51.             }
  52.         } catch (IOException e) {
  53.             e.printStackTrace();
  54.         }
  55.     }
  56.  
  57.     public static void main(String[] args) {
  58.         try {
  59.             modifyData("person", "Score", "Math", "100");
  60.         } catch (IOException e) {
  61.             e.printStackTrace();
  62.         }
  63.  
  64.     }
  65. }

⑤ deleteRow(String tableName, String row)： 删除表tableName中row指定的行的记录。

  1. import org.apache.hadoop.conf.Configuration;
  2. import org.apache.hadoop.hbase.Cell;
  3. import org.apache.hadoop.hbase.HBaseConfiguration;
  4. import org.apache.hadoop.hbase.TableName;
  5. import org.apache.hadoop.hbase.client.*;
  6.  
  7. import java.io.IOException;
  8.  
  9. public class ModifyData {
  10.  
  11.     public static long ts;
  12.     public static Configuration configuration;
  13.     public static Connection connection;
  14.     public static Admin admin;
  15.  
  16.     public static void modifyData(String tableName, String row, String column, String val) throws IOException {
  17.         init();
  18.         Table table = connection.getTable(TableName.valueOf(tableName));
  19.         Put put = new Put(row.getBytes());
  20.         Scan scan = new Scan();
  21.         ResultScanner resultScanner = table.getScanner(scan);
  22.         for (Result r : resultScanner) {
  23.             for (Cell cell : r.getColumnCells(row.getBytes(), column.getBytes())) {
  24.                 ts = cell.getTimestamp();
  25.             }
  26.         }
  27.         put.addColumn(row.getBytes(), column.getBytes(), ts, val.getBytes());
  28.         table.put(put);
  29.         table.close();
  30.         close();
  31.     }
  32.  
  33.     public static void init() {
  34.         configuration = HBaseConfiguration.create();
  35.         configuration.set("hbase.rootdir", "hdfs://localhost:9000/hbase");
  36.         try {
  37.             connection = ConnectionFactory.createConnection(configuration);
  38.             admin = connection.getAdmin();
  39.         } catch (IOException e) {
  40.             e.printStackTrace();
  41.         }
  42.     }
  43.  
  44.     public static void close() {
  45.         try {
  46.             if (admin != null) {
  47.                 admin.close();
  48.             }
  49.             if (null != connection) {
  50.                 connection.close();
  51.             }
  52.         } catch (IOException e) {
  53.             e.printStackTrace();
  54.         }
  55.     }
  56.  
  57.     public static void main(String[] args) {
  58.         try {
  59.             modifyData("person", "Score", "Math", "100");
  60.         } catch (IOException e) {
  61.             e.printStackTrace();
  62.         }
  63.  
  64.     }
  65. }

 参考：

《HBase2.2.2安装和编程实践指南_厦大数据库实验室博客 (xmu.edu.cn)》

《实验3 熟悉常用的 HBase 操作》实验3 熟悉常用的 HBase 操作_硕硕ss的博客-CSDN博客_熟悉常用的hbase操作

《实验3_熟悉常用的HBase操作》实验3_熟悉常用的HBase操作_NeverOW的博客-CSDN博客

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

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

  

闽ICP备14008679号