• HBase学习笔记（2）—— API使用

    对HBase中常用的API操作进行简单的介绍

    对应HBase学习笔记（1）—— 知识点总结-CSDN博客中介绍的HBase Shell常用操作

    更多用法请参考官网：Apache HBase ™ Reference Guide

    依赖导入

    1.     <dependencies>
    2.         <dependency>
    3.             <groupId>org.apache.hbasegroupId>
    4.             <artifactId>hbase-serverartifactId>
    5.             <version>2.4.11version>
    6.             <exclusions>
    7.                 <exclusion>
    8.                     <groupId>org.glassfishgroupId>
    9.                     <artifactId>javax.elartifactId>
    10.                 exclusion>
    11.             exclusions>
    12.         dependency>
    13.  
    14.         <dependency>
    15.             <groupId>org.glassfishgroupId>
    16.             <artifactId>javax.elartifactId>
    17.             <version>3.0.1-b06version>
    18.         dependency>
    19.     dependencies>

    打包所用的插件：

    1.  <build>
    2.         <plugins>
    3.             <plugin>
    4.                 <groupId>org.apache.maven.pluginsgroupId>
    5.                 <artifactId>maven-shade-pluginartifactId>
    6.                 <version>3.2.4version>
    7.                 <executions>
    8.                     <execution>
    9.                         <phase>packagephase>
    10.                         <goals>
    11.                             <goal>shadegoal>
    12.                         goals>
    13.                     execution>
    14.                 executions>
    15.             plugin>
    16.         plugins>
    17.     build>

    建立连接

    1. package com.why;
    2. import org.apache.hadoop.hbase.client.Connection;
    3. import org.apache.hadoop.hbase.client.ConnectionFactory;
    4. import java.io.IOException;
    5.  
    6. public class HBaseConnect2 {
    7.     public static Connection connection = null;
    8.  
    9.     static {
    10.         try {
    11.             connection = ConnectionFactory.createConnection(); //使用配置文件中的参数hbase.zookeeper.quorum
    12.             System.out.println(connection);
    13.         } catch (IOException e) {
    14.             System.out.println("连接创建失败");
    15.             throw new RuntimeException(e);
    16.         }
    17.     }
    18.  
    19.     /**
    20.      * 关闭连接
    21.      * @throws IOException
    22.      */
    23.     public static void closeConnection() throws IOException {
    24.         if (connection != null)
    25.         {
    26.             connection.close();
    27.         }
    28.     }
    29.  
    30. }

    DDL操作

    1. package com.why;
    2. import org.apache.hadoop.hbase.HTableDescriptor;
    3. import org.apache.hadoop.hbase.NamespaceDescriptor;
    4. import org.apache.hadoop.hbase.TableName;
    5. import org.apache.hadoop.hbase.client.*;
    6. import org.apache.hadoop.hbase.util.Bytes;
    7. import java.io.IOException;
    8.  
    9. public class HBaseDDL {
    10.     //获取连接
    11.  
    12.     private static Connection connection = HBaseConnect2.connection;
    13.  
    14.     /**
    15.      * 创建命名空间
    16.      * @param namespace 命名空间名称
    17.      * @throws IOException
    18.      */
    19.     public static void createNamespace(String namespace) throws IOException {
    20.  
    21.         //获取admin(admin的连接是轻量级的，不是线程安全的，不推荐池化或缓存)
    22.         Admin admin = connection.getAdmin();
    23.  
    24.         //创建命名空间builder
    25.         NamespaceDescriptor.Builder builder = NamespaceDescriptor.create(namespace);
    26.  
    27. //        builder.addConfiguration("user","why");
    28.  
    29.         try{
    30.             admin.createNamespace(builder.build());
    31.         }catch (IOException e)
    32.         {
    33.             System.out.println("命名空间已经存在");
    34.             e.printStackTrace();
    35.         }
    36.         admin.close();
    37.  
    38.     }
    39.  
    40.     /**
    41.      * 查看所有命名空间
    42.      * @throws IOException
    43.      */
    44.     public static void listNamespaces() throws IOException {
    45.  
    46.         Admin admin = connection.getAdmin();
    47.  
    48.         try {
    49.             String[] strings = admin.listNamespaces();
    50.  
    51.             System.out.println("命名空间如下:");
    52.  
    53.             for(String string : strings)
    54.             {
    55.                 System.out.println(string);
    56.             }
    57.         }catch (IOException e)
    58.         {
    59.             e.printStackTrace();
    60.         }
    61.  
    62.         admin.close();
    63.  
    64.     }
    65.  
    66.  
    67.     /**
    68.      * 判断表格是否存在
    69.      * @param namespace 命名空间
    70.      * @param table 表格名称
    71.      * @return
    72.      * @throws IOException
    73.      */
    74.     public static boolean isTableExist(String namespace,String table) throws IOException {
    75.         Admin admin = connection.getAdmin();
    76.  
    77.         boolean isExist = false;
    78.         try {
    79.             //通过tableExists方法判断表格是否存在
    80.             isExist = admin.tableExists(TableName.valueOf(namespace,table));
    81.         }catch (IOException e)
    82.         {
    83.             e.printStackTrace();
    84.         }
    85.  
    86.         admin.close();
    87.  
    88.         return isExist;
    89.     }
    90.  
    91.  
    92.     /**
    93.      * 创建表格
    94.      * @param namespace 命名空间
    95.      * @param table 表格名称
    96.      * @param columnFamilies 列族名称
    97.      * @throws IOException
    98.      */
    99.     public static void createTable(String namespace , String table , String... columnFamilies) throws IOException {
    100.         //判断是否至少有一个列族
    101.         if(columnFamilies.length == 0)
    102.         {
    103.             System.out.println("至少要有一个列族");
    104.             return;
    105.         }
    106.  
    107.         //判断表格是否已经存在
    108.         if(isTableExist(namespace,table))
    109.         {
    110.             System.out.println("表格已经存在");
    111.             return;
    112.         }
    113.  
    114.         Admin admin = connection.getAdmin();
    115.  
    116.         //创建表格描述的构建器
    117.         TableDescriptorBuilder tableDescriptorBuilder = TableDescriptorBuilder.newBuilder(TableName.valueOf(namespace, table));
    118.  
    119.         //添加参数
    120.         for(String columnFamily : columnFamilies)
    121.         {
    122.             //创建列族描述的构建器
    123.             ColumnFamilyDescriptorBuilder columnFamilyDescriptorBuilder = ColumnFamilyDescriptorBuilder.newBuilder(Bytes.toBytes(columnFamily));
    124.             columnFamilyDescriptorBuilder.setMaxVersions(5); //添加最大版本数
    125.             tableDescriptorBuilder.setColumnFamily(columnFamilyDescriptorBuilder.build()); //创建添加完参数的列族描述
    126.         }
    127.  
    128.         try {
    129.             admin.createTable(tableDescriptorBuilder.build());
    130.         }catch (IOException e)
    131.         {
    132.             e.printStackTrace();
    133.         }
    134.  
    135.         admin.close();
    136.     }
    137.  
    138.     /**
    139.      * 查看所有表格
    140.      * @throws IOException
    141.      */
    142.     public static void listTableNames() throws IOException {
    143.  
    144.         Admin admin = connection.getAdmin();
    145.  
    146.         try {
    147.             TableName[] tableNames = admin.listTableNames();
    148.  
    149.             System.out.println("所有表格如下");
    150.             for(TableName tableName : tableNames)
    151.             {
    152.                 System.out.println(tableName.getNamespaceAsString() + ":" + tableName.getNameAsString());
    153.             }
    154.         }catch (IOException e)
    155.         {
    156.             e.printStackTrace();
    157.         }
    158.  
    159.         admin.close();
    160.  
    161.     }
    162.  
    163.     /**
    164.      * 修改表格中某一个列族的版本号
    165.      * @param namespace
    166.      * @param table
    167.      * @param columnFamily 列族
    168.      * @param version 版本号
    169.      */
    170.     public static void modifyTable(String namespace , String table , String columnFamily , int version) throws IOException {
    171.  
    172.         if(!isTableExist(namespace,table))
    173.         {
    174.             System.out.println("表格不存在，无法修改");
    175.             return;
    176.         }
    177.         Admin admin = connection.getAdmin();
    178.  
    179.         try {
    180.             //获取表格描述
    181.             TableDescriptor descriptor = admin.getDescriptor(TableName.valueOf(namespace, table));
    182.  
    183.             //创建新的表格描述构建器
    184.             TableDescriptorBuilder tableDescriptorBuilder = TableDescriptorBuilder.newBuilder(descriptor);
    185.  
    186.             //获取列族描述
    187.             ColumnFamilyDescriptor columnFamily1 = descriptor.getColumnFamily(Bytes.toBytes(columnFamily));
    188.  
    189.             //创建新的列族描述构建器
    190.             ColumnFamilyDescriptorBuilder columnFamilyDescriptorBuilder = ColumnFamilyDescriptorBuilder.newBuilder(columnFamily1);
    191.  
    192.             //设置参数
    193.             columnFamilyDescriptorBuilder.setMaxVersions(version);
    194.  
    195.             //将新的列族描述添加到表格描述中
    196.             tableDescriptorBuilder.modifyColumnFamily(columnFamilyDescriptorBuilder.build());
    197.  
    198.             admin.modifyTable(tableDescriptorBuilder.build());
    199.  
    200.         }catch (IOException e)
    201.         {
    202.             e.printStackTrace();
    203.         }
    204.         admin.close();
    205.     }
    206.  
    207.     /**
    208.      *
    209.      * @param namespace
    210.      * @param table
    211.      * @return true表示删除成功
    212.      */
    213.     public static boolean deleteTable(String namespace , String table) throws IOException {
    214.         if(!isTableExist(namespace,table))
    215.         {
    216.             System.out.println("表格不存在，无法删除");
    217.             return false;
    218.         }
    219.  
    220.         Admin admin = connection.getAdmin();
    221.  
    222.         try {
    223.             TableName tableName = TableName.valueOf(namespace, table);
    224.             admin.disableTable(tableName);
    225.             admin.deleteTable(tableName);
    226.         }catch (IOException e)
    227.         {
    228.             e.printStackTrace();
    229.         }
    230.  
    231.         admin.close();
    232.         return true;
    233.     }
    234.  
    235.  
    236. }

    DML操作

    1. package com.why;
    2.  
    3. import org.apache.hadoop.hbase.Cell;
    4. import org.apache.hadoop.hbase.CellUtil;
    5. import org.apache.hadoop.hbase.CompareOperator;
    6. import org.apache.hadoop.hbase.TableName;
    7. import org.apache.hadoop.hbase.client.*;
    8. import org.apache.hadoop.hbase.filter.ColumnValueFilter;
    9. import org.apache.hadoop.hbase.filter.FilterList;
    10. import org.apache.hadoop.hbase.filter.SingleColumnValueFilter;
    11. import org.apache.hadoop.hbase.util.Bytes;
    12. import java.io.IOException;
    13.  
    14. public class HBaseDML {
    15.  
    16.     private static Connection connection = HBaseConnect2.connection;
    17.  
    18.     /**
    19.      * 插入数据
    20.      *
    21.      * @param namespace
    22.      * @param table
    23.      * @param rowKey
    24.      * @param columnFamily
    25.      * @param column
    26.      * @param value
    27.      * @throws IOException
    28.      */
    29.     public static void insert(String namespace, String table, String rowKey, String columnFamily, String column, String value) throws IOException {
    30.  
    31.         //首先获取表格table
    32.         Table table1 = connection.getTable(TableName.valueOf(namespace, table));
    33.         System.out.println("表格创建成功");
    34.         //创建put对象
    35.         Put put = new Put(Bytes.toBytes(rowKey));
    36.         System.out.println("put对象创建成功");
    37.         //向put对象中添加数据
    38.         put.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes(column), Bytes.toBytes(value));
    39.         try {
    40.             table1.put(put);
    41.             System.out.println("数据插入成功");
    42.         } catch (IOException e) {
    43.             e.printStackTrace();
    44.         }
    45.  
    46.         table1.close();
    47.     }
    48.  
    49.  
    50.     /**
    51.      * 读取数据
    52.      *
    53.      * @param namespace
    54.      * @param table
    55.      * @param rowKey
    56.      * @param columnFamily
    57.      * @param column
    58.      * @throws IOException
    59.      */
    60.     public static void get(String namespace, String table, String rowKey, String columnFamily, String column) throws IOException {
    61.         //获取table
    62.         Table table1 = connection.getTable(TableName.valueOf(namespace, table));
    63.  
    64.         //获取get对象
    65.         Get get = new Get(Bytes.toBytes(rowKey));
    66.  
    67.         //设置读取某一列的数据(如果不设置的话则读取所有数据)
    68.         get.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes(column));
    69.  
    70.         try {
    71.             //调用get方法读取数据
    72.             Result result = table1.get(get);
    73.             //获取到所有的cell
    74.             Cell[] cells = result.rawCells();
    75.             //打印value
    76.             for (Cell cell : cells) {
    77.                 String value = new String(CellUtil.cloneValue(cell));
    78.                 System.out.println(value);
    79.             }
    80.         } catch (IOException e) {
    81.             e.printStackTrace();
    82.         }
    83.  
    84.         table1.close();
    85.     }
    86.  
    87.  
    88.     /**
    89.      * 扫描表
    90.      *
    91.      * @param namespace
    92.      * @param table
    93.      * @param startRow
    94.      * @param stopRow
    95.      * @throws IOException
    96.      */
    97.     public static void scan(String namespace, String table, String startRow, String stopRow) throws IOException {
    98.         //获取table
    99.         Table table1 = connection.getTable(TableName.valueOf(namespace, table));
    100.  
    101.         //创建scan对象
    102.         Scan scan = new Scan();
    103.  
    104.         //添加扫描的起止rowKey
    105.         scan.withStartRow(Bytes.toBytes(startRow));
    106.         scan.withStopRow(Bytes.toBytes(stopRow));
    107.  
    108.         try {
    109.             ResultScanner scanner = table1.getScanner(scan);
    110.  
    111.             for (Result result : scanner) {
    112.                 Cell[] cells = result.rawCells();
    113.                 for (Cell cell : cells) {
    114.                     System.out.print(new
    115.                             String(CellUtil.cloneRow(cell)) + "-" + new
    116.                             String(CellUtil.cloneFamily(cell)) + "-" + new
    117.                             String(CellUtil.cloneQualifier(cell)) + "-" + new
    118.                             String(CellUtil.cloneValue(cell)) + "\t");
    119.                 }
    120.                 System.out.println();
    121.                 ;
    122.             }
    123.         } catch (IOException e) {
    124.             e.printStackTrace();
    125.         }
    126.  
    127.         table1.close();
    128.     }
    129.  
    130.  
    131.     /**
    132.      * 扫描表（有过滤器）
    133.      *
    134.      * @param namespace
    135.      * @param table
    136.      * @param startRow
    137.      * @param stopRow
    138.      * @param columnFamily
    139.      * @param column
    140.      * @param value
    141.      */
    142.     public static void scanWithFilter(String namespace, String table, String startRow, String stopRow, String columnFamily, String column, String value) throws IOException {
    143.  
    144.         //获取table
    145.         Table table1 = connection.getTable(TableName.valueOf(namespace, table));
    146.  
    147.         //创建scan对象
    148.         Scan scan = new Scan();
    149.  
    150.         //添加扫描的起止rowKey
    151.         scan.withStartRow(Bytes.toBytes(startRow));
    152.         scan.withStopRow(Bytes.toBytes(stopRow));
    153.  
    154.         //创建过滤器列表
    155.         FilterList filterList = new FilterList();
    156.  
    157.         //创建列过滤器，作用：只保留当前列的数据
    158.         ColumnValueFilter columnValueFilter = new ColumnValueFilter(
    159.                 Bytes.toBytes(columnFamily),
    160.                 Bytes.toBytes(column),
    161.                 CompareOperator.EQUAL,
    162.                 Bytes.toBytes(value));
    163.  
    164. //        // (2) 结果保留整行数据
    165. //        // 结果同时会保留没有当前列的数据
    166. //        SingleColumnValueFilter singleColumnValueFilter = new
    167. //                SingleColumnValueFilter(
    168. //                // 列族名称
    169. //                Bytes.toBytes(columnFamily),
    170. //                // 列名
    171. //                Bytes.toBytes(column),
    172. //                // 比较关系
    173. //                CompareOperator.EQUAL,
    174. //                // 值
    175. //                Bytes.toBytes(value)
    176. //        );
    177.  
    178.         filterList.addFilter(columnValueFilter);
    179.         scan.setFilter(filterList);
    180.  
    181.         try {
    182.             ResultScanner scanner = table1.getScanner(scan);
    183.  
    184.             for (Result result : scanner) {
    185.                 Cell[] cells = result.rawCells();
    186.                 for (Cell cell : cells) {
    187.                     System.out.print(new
    188.                             String(CellUtil.cloneRow(cell)) + "-" + new
    189.                             String(CellUtil.cloneFamily(cell)) + "-" + new
    190.                             String(CellUtil.cloneQualifier(cell)) + "-" + new
    191.                             String(CellUtil.cloneValue(cell)) + "\t");
    192.                 }
    193.                 System.out.println();
    194.                 ;
    195.             }
    196.         } catch (IOException e) {
    197.             e.printStackTrace();
    198.         }
    199.  
    200.         table1.close();
    201.     }
    202.  
    203.     /**
    204.      * 删除数据
    205.      * @param nameSpace
    206.      * @param table
    207.      * @param rowKey
    208.      * @param columnFamily
    209.      * @param column
    210.      * @throws IOException
    211.      */
    212.     public static void delete(String nameSpace, String table, String rowKey, String columnFamily, String column) throws IOException {
    213.         //获取 table
    214.         Table table1 = connection.getTable(TableName.valueOf(nameSpace, table));
    215.  
    216.         //创建 Delete 对象
    217.         Delete delete = new Delete(Bytes.toBytes(rowKey));
    218.  
    219.         //添加删除信息
    220.         //删除单个版本（默认最新）
    221.         delete.addColumn(Bytes.toBytes(columnFamily),Bytes.toBytes(column));
    222.  
    223. //        //删除所有版本
    224. //        delete.addColumns(Bytes.toBytes(columnFamily),Bytes.toBytes(column));
    225.  
    226.         //删除列族
    227.         delete.addFamily(Bytes.toBytes(columnFamily));
    228.  
    229.         try {
    230.             table1.delete(delete);
    231.         }catch (IOException e)
    232.         {
    233.             e.printStackTrace();
    234.         }
    235.  
    236.         table1.close();
    237.     }
    238. }

    说明：本学习笔记根据基于尚硅谷课程进行整理，课程链接：hbase

    未完待续~

  • 相关阅读:
    算法笔记-第十章-图的遍历（未处理完-11.22日）
    Asp .Net Core 系列：Asp .Net Core 集成 NLog
    Python数据可视化-----制作全球地震散点图
    java计算机毕业设计Web端校园报修系统MyBatis+系统+LW文档+源码+调试部署
    蓝河操作系统--概述
    重走JAVA之类与对象相关的
    王者荣耀安卓区修改荣耀战区方法 | 最低战力查询（附带视频与安装包）
    Android 应用流量监控实践
    springcloud13:服务网关(gateway)
    什么是泛型？
  • 原文地址：https://blog.csdn.net/qq_51235856/article/details/134313651