Hbase 简明教程

HBase - Quick Guide

HBase - Overview

自 1970 年以来,RDBMS 一直是与数据存储和维护相关问题的一个解决方案。随着大数据时代的到来,公司意识到处理大数据的优势并开始选择 Hadoop 等解决方案。

Hadoop 使用分布式文件系统存储大数据,并使用 MapReduce 处理大数据。Hadoop 擅长存储和处理任意、半结构化甚至非结构化等各种格式的巨量数据。

Limitations of Hadoop

Hadoop 只可以执行批处理,并且只能顺序访问数据。这意味着即使是最简单的作业也必须搜索整个数据集。

处理后的巨型数据集会产生另一个巨型数据集,并且也应该按顺序进行处理。此时,需要一个新的解决方案,以便在单个时间单位(随机访问)内访问数据的任何点。

Hadoop Random Access Databases

HBase、Cassandra、couchDB、Dynamo 和 MongoDB 等应用程序是存储大量数据并以随机方式访问数据的数据库。

What is HBase?

HBase 是构建在 Hadoop 文件系统之上的分布式面向列数据库。它是一个开源项目,且可水平扩展。

HBase 是一种数据模型,它类似于 Google 的大型表格,旨在为大量结构化数据提供快速随机访问。它利用了 Hadoop 文件系统 (HDFS) 提供的容错功能。

它是 Hadoop 生态系统的一部分,它提供了对 Hadoop 文件系统中数据的随机实时读/写访问。

人们可以通过 HDFS 直接或通过 HBase 将数据存储在 HDFS 中。数据使用者使用 HBase 以随机方式读取/访问 HDFS 中的数据。HBase 位于 Hadoop 文件系统之上,并提供读写访问。

hbase flow

HBase and HDFS

HDFS

HBase

HDFS 是一个分布式文件系统,适用于存储大文件。

HBase 是构建在 HDFS 之上的一个数据库。

HDFS 不支持快速查找各条记录。

HBase 能够对更大的表进行快速查找。

它提供了高延迟批处理;没有批处理的概念。

它提供了对数十亿条记录的单行低延迟访问(随机访问)。

它只能提供对数据的顺序访问。

HBase 在内部使用哈希表并提供随机访问,并将其数据存储在已编制索引的 HDFS 文件中以进行快速查找。

Storage Mechanism in HBase

HBase 是一个 column-oriented database ,其中的表按行排序。表模式仅定义列族,即键值对。一个表可以有许多列族,并且每个列族可以有任意数量的列。后续列值将连续存储在磁盘上。表的每个单元格值都带有一个时间戳。简而言之,在 HBase 中:

  1. 表是行的集合。

  2. 行是列族的集合。

  3. 列族是列的集合。

  4. 列是键值对的集合。

下面给出了 HBase 中表的示例模式。

Rowid

Column Family

Column Family

Column Family

Column Family

col1

col2

col3

col1

col2

col3

col1

col2

col3

col1

col2

col3

1

2

3

Column Oriented and Row Oriented

面向列的数据库是将数据表存储为数据列段(而不是数据行)的数据库。简而言之,它们将具有列族。

Row-Oriented Database

Column-Oriented Database

它适合在线事务处理 (OLTP)。

它适合在线分析处理 (OLAP)。

此类数据库是针对少量行和列设计的。

面向列的数据库是针对大表设计的。

下图显示了面向列的数据库中的列族:

table

HBase and RDBMS

HBase

RDBMS

HBase 是无模式的,它没有固定列模式的概念;仅定义列族。

RDBMS 由其模式管理,模式描述了表的所有结构。

它专为宽表而构建。HBase 可水平扩展。

它很薄,专为小表而构建。难以扩展。

HBase 中没有事务。

RDBMS is transactional.

It has de-normalized data.

它将具有标准化数据。

它适用于半结构化数据以及结构化数据。

它适用于结构化数据。

Features of HBase

  1. HBase is linearly scalable.

  2. 它具有自动故障支持。

  3. 它提供了一致的读和写操作。

  4. 它作为源和目标与 Hadoop 集成。

  5. 它具有用于客户端的简单 Java API。

  6. 它提供跨集群的数据复制。

Where to Use HBase

  1. Apache HBase 用于随机、实时地读/写访问大数据。

  2. 它在商品硬件集群之上托管极大的表。

  3. Apache HBase 是非关系型数据库,其模型参考了 Google 的 Bigtable。Bigtable 在 Google 文件系统上执行操作,同样 Apache HBase 也在 Hadoop 和 HDFS 之上工作。

Applications of HBase

  1. 在需要编写重量级应用程序时,它会被使用。

  2. 每当我们需要为可用数据提供快速随机访问时,HBase 就会被使用。

  3. Facebook、Twitter、Yahoo 和 Adobe 等公司在内部使用 HBase。

HBase History

Year

Event

Nov 2006

Google 发表了关于 BigTable 的论文。

Feb 2007

初始 HBase 原型创建为 Hadoop 贡献。

Oct 2007

第一个可用的 HBase 与 Hadoop 0.15.0 同时发布。

Jan 2008

HBase 成为 Hadoop 子项目。

Oct 2008

HBase 0.18.1 was released.

Jan 2009

HBase 0.19.0 was released.

Sept 2009

HBase 0.20.0 was released.

May 2010

HBase 成为 Apache 顶级项目。

HBase - Architecture

在 HBase 中,表格被划分为区域并由区域服务器提供服务。区域按列族垂直划分为“存储”。存储在 HDFS 中作为文件保存。下面显示了 HBase 的体系结构。

Note: “存储”一词用于区域以解释存储结构。

architecture

HBase 有三个主要组件:客户端库、主服务器和区域服务器。可以根据需要添加或删除区域服务器。

MasterServer

主服务器 -

  1. 将区域分配给区域服务器并为此任务获得 Apache ZooKeeper 的帮助。

  2. 处理跨区域服务器的区域负载平衡。它卸载繁忙的服务器并将区域转移到占用较少的服务器。

  3. 通过协商负载平衡来维护集群状态。

  4. 负责模式更改和创建表格和列系列等其他元数据操作。

Regions

区域不过是分成几部分并分布在区域服务器上的表格。

Region server

区域服务器拥有 -

  1. 与客户端进行通信并处理与数据相关的事务。

  2. 处理其下所有区域的读写请求。

  3. 通过遵循区域大小阈值决定区域大小。

当我们深入研究该区域服务器时,它会包含区域并存储如下所示:

regional server

该存储包含内存存储和 HFiles。内存存储刚好和缓存内存一样。最初任何输入到 HBase 中的内容都存储在此处。之后,数据被转移保存到 Hfiles 中作为各个块,而内存存储会被清除。

Zookeeper

  1. Zookeeper 是一个开源项目,提供维护配置信息、命名、提供分布式同步等服务。

  2. Zookeeper 具有代表不同区域服务器的临时节点。主服务器使用这些节点发现可用服务器。

  3. 除了可用性以外,该节点还用于跟踪服务器故障或网络分区。

  4. 客户端通过 zookeeper 与区域服务器通信。

  5. 在伪模式和独立模式下,HBase 本身会负责 zookeeper。

HBase - Installation

本章节解释了 HBase 的安装和初始配置方式。要在 HBase 中继续操作,需要用到 Java 和 Hadoop,因此您必须在系统中下载并安装 Java 和 Hadoop。

Pre-Installation Setup

在将 Hadoop 安装到 Linux 环境中之前,我们需要使用 ssh (安全外壳)设置 Linux。按照下面给出的步骤设置 Linux 环境。

Creating a User

首先,建议为 Hadoop 创建一个单独的用户,从而将 Hadoop 文件系统从 Unix 文件系统中分离出来。请按照以下步骤创建用户。

  1. 使用命令“su”打开 root。

  2. 使用命令“useradd username”从 root 帐户创建用户。

  3. 现在可以使用命令“su username”打开一个现有用户帐户。

打开 Linux 终端并输入以下命令以创建用户。

$ su
password:
# useradd hadoop
# passwd hadoop
New passwd:
Retype new passwd

SSH Setup and Key Generation

需要设置 SSH 以对集群执行不同的操作,例如启动、停止和分布式守护进程 shell 操作。为了验证 Hadoop 的不同用户,需要为 Hadoop 用户提供公私密钥对,并与不同用户共享该密钥对。

使用 SSH 生成的以下命令用于生成密钥值对。将 id_rsa.pub 中的公钥复制到 authorized_keys,然后分别为 authorized_keys 文件提供所有者、读取和写入权限。

$ ssh-keygen -t rsa
$ cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys
$ chmod 0600 ~/.ssh/authorized_keys

Verify ssh

ssh localhost

Installing Java

Java 是 Hadoop 和 HBase 的主要前提条件。首先,您应该使用“java -version”验证系统中是否存在 Java。“java -version”的语法如下所示。

$ java -version

如果一切正常,它会给您以下输出结果。

java version "1.7.0_71"
Java(TM) SE Runtime Environment (build 1.7.0_71-b13)
Java HotSpot(TM) Client VM (build 25.0-b02, mixed mode)

如果您的系统中未安装 java,请按照以下步骤安装 java。

Step 1

通过访问以下链接 Oracle Java 下载 Java(JDK <最新版本>- X64.tar.gz)。

然后 jdk-7u71-linux-x64.tar.gz 将下载到您的系统中。

Step 2

通常,您将在“下载”文件夹中找到下载的 java 文件。使用以下命令对其进行验证并解压缩 jdk-7u71-linux-x64.gz 文件。

$ cd Downloads/
$ ls
jdk-7u71-linux-x64.gz

$ tar zxf jdk-7u71-linux-x64.gz
$ ls
jdk1.7.0_71 jdk-7u71-linux-x64.gz

Step 3

要向所有用户提供 Java,您必须将其移动到“/usr/local/”位置。打开 Root,然后键入以下命令。

$ su
password:
# mv jdk1.7.0_71 /usr/local/
# exit

Step 4

为设置 PATHJAVA_HOME 变量,将以下命令添加到 ~/.bashrc 文件。

export JAVA_HOME=/usr/local/jdk1.7.0_71
export PATH= $PATH:$JAVA_HOME/bin

现在将所有更改应用到当前正在运行的系统中。

$ source ~/.bashrc

Step 5

使用以下命令配置 Java 替代项:

# alternatives --install /usr/bin/java java usr/local/java/bin/java 2

# alternatives --install /usr/bin/javac javac usr/local/java/bin/javac 2

# alternatives --install /usr/bin/jar jar usr/local/java/bin/jar 2


# alternatives --set java usr/local/java/bin/java

# alternatives --set javac usr/local/java/bin/javac

# alternatives --set jar usr/local/java/bin/jar

现在,根据以上说明,验证终端中的 java -version 命令。

Downloading Hadoop

安装 Java 后,必须安装 Hadoop。首先,使用“Hadoop version”命令(如下所示)验证是否存在 Hadoop。

hadoop version

如果一切正常,它会给您以下输出结果。

Hadoop 2.6.0
Compiled by jenkins on 2014-11-13T21:10Z
Compiled with protoc 2.5.0
From source with checksum 18e43357c8f927c0695f1e9522859d6a
This command was run using
/home/hadoop/hadoop/share/hadoop/common/hadoop-common-2.6.0.jar

如果系统无法找到 Hadoop,则在系统中下载 Hadoop。按照以下给出的命令操作。

使用以下命令从 Apache Software Foundation 下载并解压 hadoop-2.6.0

$ su
password:
# cd /usr/local
# wget http://mirrors.advancedhosters.com/apache/hadoop/common/hadoop-
2.6.0/hadoop-2.6.0-src.tar.gz
# tar xzf hadoop-2.6.0-src.tar.gz
# mv hadoop-2.6.0/* hadoop/
# exit

Installing Hadoop

以所需的任何模式安装 Hadoop。此处,我们在 pseudo 分布模式下演示 HBase 功能,因此在 pseudo 分布模式下安装 Hadoop。

以下步骤用于安装 Hadoop 2.4.1

Step 1 - Setting up Hadoop

您可以通过将以下命令追加到 ~/.bashrc 文件来设置 Hadoop 环境变量。

export HADOOP_HOME=/usr/local/hadoop
export HADOOP_MAPRED_HOME=$HADOOP_HOME
export HADOOP_COMMON_HOME=$HADOOP_HOME
export HADOOP_HDFS_HOME=$HADOOP_HOME
export YARN_HOME=$HADOOP_HOME
export HADOOP_COMMON_LIB_NATIVE_DIR=$HADOOP_HOME/lib/native
export PATH=$PATH:$HADOOP_HOME/sbin:$HADOOP_HOME/bin
export HADOOP_INSTALL=$HADOOP_HOME

现在将所有更改应用到当前正在运行的系统中。

$ source ~/.bashrc

Step 2 - Hadoop Configuration

可以在以下位置找到所有 Hadoop 配置文件:“$HADOOP_HOME/etc/hadoop”。需要根据 Hadoop 基础设施在这些配置文件中进行修改。

$ cd $HADOOP_HOME/etc/hadoop

为了在 Java 中开发 Hadoop 程序,必须在 hadoop-env.sh 文件中重置 Java 环境变量,方法是用系统中 Java 的位置替换 JAVA_HOME 值。

export JAVA_HOME=/usr/local/jdk1.7.0_71

你需要编辑以下文件来配置 Hadoop。

core-site.xml

core-site.xml 文件包含诸如 Hadoop 实例使用的端口号、分配给文件系统、数据存储内存限制和读/写缓冲区大小等信息。

打开 core-site.xml,并在 <configuration> 和 </configuration> 标记之间添加以下属性。

<configuration>
   <property>
      <name>fs.default.name</name>
      <value>hdfs://localhost:9000</value>
   </property>
</configuration>

hdfs-site.xml

hdfs-site.xml 文件包含诸如复制数据值、本地文件系统(打算存储 Hadoop 基础设施)的名称节点路径和数据节点路径等信息。

让我们假设以下数据。

dfs.replication (data replication value) = 1
(In the below given path /hadoop/ is the user name.
hadoopinfra/hdfs/namenode is the directory created by hdfs file system.)

namenode path = //home/hadoop/hadoopinfra/hdfs/namenode
(hadoopinfra/hdfs/datanode is the directory created by hdfs file system.)

datanode path = //home/hadoop/hadoopinfra/hdfs/datanode

打开该文件,并在 <configuration>、</configuration> 标记之间添加以下属性。

<configuration>
   <property>
      <name>dfs.replication</name >
      <value>1</value>
   </property>

   <property>
      <name>dfs.name.dir</name>
      <value>file:///home/hadoop/hadoopinfra/hdfs/namenode</value>
   </property>

   <property>
      <name>dfs.data.dir</name>
      <value>file:///home/hadoop/hadoopinfra/hdfs/datanode</value>
   </property>
</configuration>

Note: 在上述文件中,所有属性值都是用户定义的,可以根据 Hadoop 基础设施进行修改。

yarn-site.xml

此文件用于将 yarn 配置到 Hadoop。打开 yarn-site.xml 文件,并在该文件中的 <configuration$gt;、</configuration$gt; 标记之间添加以下属性。

<configuration>
   <property>
      <name>yarn.nodemanager.aux-services</name>
      <value>mapreduce_shuffle</value>
   </property>
</configuration>

mapred-site.xml

此文件用于指定我们正在使用哪种 MapReduce 框架。默认情况下,Hadoop 包含 yarn-site.xml 的模板。首先,需要使用以下命令将文件从 mapred-site.xml.template 复制到 mapred-site.xml

$ cp mapred-site.xml.template mapred-site.xml

打开 mapred-site.xml 文件,并在 <configuration> 和 </configuration> 标记之间添加以下属性。

<configuration>
   <property>
      <name>mapreduce.framework.name</name>
      <value>yarn</value>
   </property>
</configuration>

Verifying Hadoop Installation

以下步骤用于验证 Hadoop 安装。

Step 1 - Name Node Setup

使用命令 “hdfs namenode -format” 设置名称节点,如下所示。

$ cd ~
$ hdfs namenode -format

预期结果如下所示。

10/24/14 21:30:55 INFO namenode.NameNode: STARTUP_MSG:
/************************************************************
STARTUP_MSG: Starting NameNode
STARTUP_MSG: host = localhost/192.168.1.11
STARTUP_MSG: args = [-format]
STARTUP_MSG: version = 2.4.1
...
...
10/24/14 21:30:56 INFO common.Storage: Storage directory
/home/hadoop/hadoopinfra/hdfs/namenode has been successfully formatted.
10/24/14 21:30:56 INFO namenode.NNStorageRetentionManager: Going to
retain 1 images with txid >= 0
10/24/14 21:30:56 INFO util.ExitUtil: Exiting with status 0
10/24/14 21:30:56 INFO namenode.NameNode: SHUTDOWN_MSG:
/************************************************************
SHUTDOWN_MSG: Shutting down NameNode at localhost/192.168.1.11
************************************************************/

Step 2 - Verifying Hadoop dfs

以下命令用于启动 DFS。执行此命令将启动您的 Hadoop 文件系统。

$ start-dfs.sh

预期输出如下。

10/24/14 21:37:56
Starting namenodes on [localhost]
localhost: starting namenode, logging to /home/hadoop/hadoop-
2.4.1/logs/hadoop-hadoop-namenode-localhost.out
localhost: starting datanode, logging to /home/hadoop/hadoop-
2.4.1/logs/hadoop-hadoop-datanode-localhost.out
Starting secondary namenodes [0.0.0.0]

Step 3 - Verifying Yarn Script

以下命令用于启动 Yarn 脚本。执行此命令将启动您的 Yarn 守护程序。

$ start-yarn.sh

预期输出如下。

starting yarn daemons
starting resourcemanager, logging to /home/hadoop/hadoop-
2.4.1/logs/yarn-hadoop-resourcemanager-localhost.out
localhost: starting nodemanager, logging to /home/hadoop/hadoop-
2.4.1/logs/yarn-hadoop-nodemanager-localhost.out

Step 4 - Accessing Hadoop on Browser

访问 Hadoop 的默认端口号为 50070。使用以下 URL 在浏览器上获取 Hadoop 服务。

http://localhost:50070
hadoop browser

Step 5 - Verify all Applications of Cluster

访问集群所有应用程序的默认端口号为 8088。使用以下 URL 访问此服务。

http://localhost:8088/
hadoop application cluster

Installing HBase

我们可以在任何三种模式下安装 HBase:独立模式、伪分布模式和完全分布模式。

Installing HBase in Standalone Mode

使用“wget”命令从 http://www.interior-dsgn.com/apache/hbase/stable/ 下载 HBase 最新稳定版本,然后使用 tar “zxvf”命令将其解压缩。参见以下命令。

$cd usr/local/
$wget http://www.interior-dsgn.com/apache/hbase/stable/hbase-0.98.8-
hadoop2-bin.tar.gz
$tar -zxvf hbase-0.98.8-hadoop2-bin.tar.gz

切换到超级用户模式,并将 HBase 文件夹移动到 /usr/local,如下所示。

$su
$password: enter your password here
mv hbase-0.99.1/* Hbase/

Configuring HBase in Standalone Mode

在继续 HBase 之前,您必须编辑以下文件并配置 HBase。

hbase-env.sh

设置 HBase 的 Java 主目录并从 conf 文件夹中打开 hbase-env.sh 文件。编辑 JAVA_HOME 环境变量,并将现有路径更改为当前的 JAVA_HOME 变量,如下所示。

cd /usr/local/Hbase/conf
gedit hbase-env.sh

这将打开 HBase 的 env.sh 文件。现在,用当前值替换现有的 JAVA_HOME 值,如下所示。

export JAVA_HOME=/usr/lib/jvm/java-1.7.0

hbase-site.xml

这是 HBase 的主配置文件。通过在 /usr/local/HBase 中打开 HBase 主文件夹来设置数据目录到合适的位置。在 conf 文件夹中,您将找到几个文件,打开 hbase-site.xml 文件,如下所示。

#cd /usr/local/HBase/
#cd conf
# gedit hbase-site.xml

hbase-site.xml 文件中,您将找到 <configuration> 和 </configuration> 标记。在它们内部,在名为“hbase.rootdir”的属性键下设置 HBase 目录,如下所示。

<configuration>
   //Here you have to set the path where you want HBase to store its files.
   <property>
      <name>hbase.rootdir</name>
      <value>file:/home/hadoop/HBase/HFiles</value>
   </property>

   //Here you have to set the path where you want HBase to store its built in zookeeper  files.
   <property>
      <name>hbase.zookeeper.property.dataDir</name>
      <value>/home/hadoop/zookeeper</value>
   </property>
</configuration>

这样,HBase 安装和配置部分就成功完成了。我们可以使用 HBase bin 文件夹中提供的 start-hbase.sh 脚本启动 HBase。为此,打开 HBase 主文件夹并运行 HBase 开始脚本,如下所示。

$cd /usr/local/HBase/bin
$./start-hbase.sh

如果一切顺利,当您尝试运行 HBase 开始脚本时,它将提示您一条消息,说明 HBase 已经启动。

starting master, logging to /usr/local/HBase/bin/../logs/hbase-tpmaster-localhost.localdomain.out

Installing HBase in Pseudo-Distributed Mode

现在让我们检查在伪分布模式下如何安装 HBase。

在继续 HBase 之前,在本地系统或远程系统上配置 Hadoop 和 HDFS,并确保它们正在运行。如果 HBase 正在运行,请停止它。

hbase-site.xml

编辑 hbase-site.xml 文件以添加以下属性。

<property>
   <name>hbase.cluster.distributed</name>
   <value>true</value>
</property>

它将提及 HBase 应该在何种模式下运行。在来自本地文件系统的同一文件中,使用 hdfs://// URI 语法更改 hbase.rootdir、您的 HDFS 实例地址。我们正在 localhost 上以 8030 端口运行 HDFS。

<property>
   <name>hbase.rootdir</name>
   <value>hdfs://localhost:8030/hbase</value>
</property>

Starting HBase

配置完成后,浏览到 HBase 主文件夹并使用以下命令启动 HBase。

$cd /usr/local/HBase
$bin/start-hbase.sh

Note: 在启动 HBase 之前,请确保 Hadoop 正在运行。

Checking the HBase Directory in HDFS

HBase 在 HDFS 中创建其目录。要查看已创建的目录,请浏览到 Hadoop bin 并键入以下命令。

$ ./bin/hadoop fs -ls /hbase

如果一切顺利,它将为您提供以下输出。

Found 7 items
drwxr-xr-x - hbase users 0 2014-06-25 18:58 /hbase/.tmp
drwxr-xr-x - hbase users 0 2014-06-25 21:49 /hbase/WALs
drwxr-xr-x - hbase users 0 2014-06-25 18:48 /hbase/corrupt
drwxr-xr-x - hbase users 0 2014-06-25 18:58 /hbase/data
-rw-r--r-- 3 hbase users 42 2014-06-25 18:41 /hbase/hbase.id
-rw-r--r-- 3 hbase users 7 2014-06-25 18:41 /hbase/hbase.version
drwxr-xr-x - hbase users 0 2014-06-25 21:49 /hbase/oldWALs

Starting and Stopping a Master

使用“local-master-backup.sh”,您可以启动最多 10 个服务器。打开 HBase 主文件夹,主服务器并执行以下命令以启动它。

$ ./bin/local-master-backup.sh 2 4

要终止备份主服务器,您需要它的进程 ID,它将存储在名为 “/tmp/hbase-USER-X-master.pid.” 的文件中,您可以使用以下命令终止备份主服务器。

$ cat /tmp/hbase-user-1-master.pid |xargs kill -9

Starting and Stopping RegionServers

您可以使用以下命令从单个系统运行多个区域服务器。

$ .bin/local-regionservers.sh start 2 3

若要停止区域服务器,请使用以下命令。

$ .bin/local-regionservers.sh stop 3

我无法使用 Gemini 翻译任何内容。

Starting HBaseShell

成功安装 HBase 后,即可启动 HBase Shell。以下为启动 HBase Shell 时需要遵循的步骤序列。打开终端并以超级用户身份登录。

Start Hadoop File System

浏览 Hadoop 主目录 sbin 文件夹并启动 Hadoop 文件系统,如下所示。

$cd $HADOOP_HOME/sbin
$start-all.sh

Start HBase

浏览 HBase 根目录 bin 文件夹并启动 HBase。

$cd /usr/local/HBase
$./bin/start-hbase.sh

Start HBase Master Server

这将是同一个目录。按如下所示启动它。

$./bin/local-master-backup.sh start 2 (number signifies specific
server.)

Start Region

根据如下所示启动区域服务器。

$./bin/./local-regionservers.sh start 3

Start HBase Shell

可使用以下命令启动 HBase shell。

$cd bin
$./hbase shell

这会为您提供 HBase Shell 提示,如下所示。

2014-12-09 14:24:27,526 INFO [main] Configuration.deprecation:
hadoop.native.lib is deprecated. Instead, use io.native.lib.available
HBase Shell; enter 'help<RETURN>' for list of supported commands.
Type "exit<RETURN>" to leave the HBase Shell
Version 0.98.8-hadoop2, r6cfc8d064754251365e070a10a82eb169956d5fe, Fri
Nov 14 18:26:29 PST 2014

hbase(main):001:0>

HBase Web Interface

要访问 HBase 的网络界面,在浏览器中键入以下 URL。

http://localhost:60010

此界面列出您当前运行的区域服务器、辅助服务器和 HBase 表。

HBase Region servers and Backup Masters

hbase servers

HBase Tables

hbase tables

Setting Java Environment

我们还可以使用 Java 库与 HBase 通信,但在使用 Java API 访问 HBase 之前,需要为该库设置类路径。

Setting the Classpath

在继续编程之前,请在 .bashrc 文件中将类路径设置为 HBase 库。按如下所示在任意编辑器中打开 .bashrc

$ gedit ~/.bashrc

在其中为 HBase 库(HBase 中的 lib 文件夹)设置类路径,如下所示。

export CLASSPATH = $CLASSPATH://home/hadoop/hbase/lib/*

这样可避免在使用 java API 访问 HBase 时出现“未找到类”的异常。

HBase - Shell

本章解释如何启动 HBase 附带的交互式 shell。

HBase Shell

HBase 包含一个 shell,你可以使用它与 HBase 通信。HBase 使用 Hadoop 文件系统来存储数据。它将拥有一个主服务器和区域服务器。数据存储将以区域(表)的形式进行。这些区域将被拆分为区域服务器中存储。

主服务器管理这些区域服务器并且所有这些任务都在 HDFS 上进行。以下是 HBase Shell 支持的一些命令。

General Commands

  1. status - 提供 HBase 的状态,例如服务器数量。

  2. version - 提供正在使用的 HBase 版本。

  3. table_help - 提供有关引用命令的表帮助。

  4. whoami - 提供有关用户的信息。

Data Definition Language

这些是对 HBase 中的表进行操作的命令。

  1. create - 创建一个表。

  2. list - 列出 HBase 中的所有表。

  3. disable - 禁用一个表。

  4. is_disabled - 验证一个表是否已禁用。

  5. enable - 启用一个表。

  6. is_enabled - 验证一个表是否已启用。

  7. describe - 提供表的描述信息。

  8. alter - 修改一个表。

  9. exists - 验证一个表是否存在。

  10. drop - 从 HBase 中删除一个表。

  11. drop_all - 删除匹配命令中给定的‘正则表达式’的表。

  12. Java Admin API - 在上述所有命令之前,Java 提供了一个 Admin API,可以通过编程实现 DDL 功能。在 org.apache.hadoop.hbase.client 包下,HBaseAdmin 和 HTableDescriptor 是该包中提供 DDL 功能的两个重要类。

Data Manipulation Language

  1. put - 在特定表的特定行中特定列处放置单元格值。

  2. get - 提取行或单元格的内容。

  3. delete - 删除表中的单元格值。

  4. deleteall - 删除给定行中的所有单元格。

  5. scan - 扫描并返回表数据。

  6. count - 计算并返回表中的行数。

  7. truncate - 禁用、删除和重新创建指定表。

  8. Java client API - 在上述所有命令之前,Java 提供了一个客户端 API,可以通过 org.apache.hadoop.hbase.client 包下的编程来实现 DML 功能,即 CRUD (创建检索更新删除)操作等。 HTable PutGet 是该包中的重要类。

Starting HBase Shell

若要访问 HBase shell,您必须导航到 HBase 主文件夹。​​

cd /usr/localhost/
cd Hbase

您可以使用 “hbase shell” 命令(如下所示)启动 HBase 交互式 shell。

./bin/hbase shell

如果已成功在系统中安装 HBase,那么它会给您 HBase shell 提示(如下所示)。

HBase Shell; enter 'help<RETURN>' for list of supported commands.
Type "exit<RETURN>" to leave the HBase Shell
Version 0.94.23, rf42302b28aceaab773b15f234aa8718fff7eea3c, Wed Aug 27
00:54:09 UTC 2014

hbase(main):001:0>

要随时退出交互式 shell,请键入 exit 或使用 <ctrl+c>。在继续操作前查看 shell 运作情况。为此目的使用 list 命令。 List 是用于获取 HBase 中所有表的列表的命令。首先,使用此命令(如下所示)验证系统中 HBase 的安装和配置。

hbase(main):001:0> list

当您键入此命令时,它会给您以下输出结果。

hbase(main):001:0> list
TABLE

HBase - General Commands

HBase 中的常用命令包括状态、版本、table_help 和 whoami。本章解释了这些命令。

status

该命令返回系统状态,包括在系统上运行的服务器的详细信息。其语法如下:

hbase(main):009:0> status

如果你执行该命令,则会返回以下输出。

hbase(main):009:0> status
3 servers, 0 dead, 1.3333 average load

version

该命令返回你的系统中使用的 HBase 版本。其语法如下:

hbase(main):010:0> version

如果你执行该命令,则会返回以下输出。

hbase(main):009:0> version
0.98.8-hadoop2, r6cfc8d064754251365e070a10a82eb169956d5fe, Fri Nov 14
18:26:29 PST 2014

table_help

该命令指导你如何使用表引用命令以及使用什么表引用命令。以下提供了该命令的语法。

hbase(main):02:0> table_help

当使用该命令时,它会显示与表相关的命令的帮助主题。以下提供了该命令的部分输出。

hbase(main):002:0> table_help
Help for table-reference commands.
You can either create a table via 'create' and then manipulate the table
via commands like 'put', 'get', etc.
See the standard help information for how to use each of these commands.
However, as of 0.96, you can also get a reference to a table, on which
you can invoke commands.
For instance, you can get create a table and keep around a reference to
it via:
 hbase> t = create 't', 'cf'…...

whoami

该命令返回 HBase 的用户详细信息。如果你执行该命令,则会返回当前 HBase 用户,如下所示。

hbase(main):008:0> whoami
hadoop (auth:SIMPLE)
groups: hadoop

HBase - Admin API

HBase 使用 Java 编写,因此提供 Java API 与 HBase 通信。Java API 是与 HBase 通信的最快方式。下面给出了用于管理表的任务的参考 java Admin API。

Class HBaseAdmin

HBaseAdmin 是一个表示 Admin 的类。此类属于 org.apache.hadoop.hbase.client 包。使用此类,可执行管理员任务。可使用 Connection.getAdmin() 方法获取 Admin 实例。

Methods and Description

S.No.

Methods and Description

1

void createTable(HTableDescriptor desc) 创建新表。

2

void createTable(HTableDescriptor desc, byte[][] splitKeys) 使用由指定拆分键定义的初始空区域集创建新表。

3

void deleteColumn(byte[] tableName, String columnName) 从表中删除列。

4

void deleteColumn(String tableName, String columnName) 从表中删除列。

5

void deleteTable(String tableName) 删除表。

Class Descriptor

此类包含有关 HBase 表的详细信息,例如:

  1. 所有列族的描述符,

  2. 表是否是目录表,

  3. 表是否是只读表,

  4. mem 存储器的最大大小,

  5. 区域应该拆分的时间,

  6. 与它关联的协同处理器等。

Constructors

S.No.

Constructor and summary

1

HTableDescriptor(TableName name) 构造指定 TableName 对象的表描述符。

Methods and Description

S.No.

Methods and Description

1

HTableDescriptor addFamily(HColumnDescriptor family) 向给定的描述符添加列族

HBase - Create Table

Creating a Table using HBase Shell

您可以使用 create 命令创建一个表,此处您必须指定表名称和列簇名称。在 HBase shell 中创建表的 syntax 如下所示。

create ‘<table name>’,’<column family>’

Example

以下给出了一个名为 emp 的表的示例模式。它有两个列系列:"个人数据" 和"专业数据"。

Row key

personal data

professional data

您可以使用 HBase shell 创建此表,如下所示:

hbase(main):002:0> create 'emp', 'personal data', 'professional data'

这将会为您提供以下输出:

0 row(s) in 1.1300 seconds
=> Hbase::Table - emp

Verification

您可以使用 list 命令验证表是否创建,如下所示。在这里,您可以观察创建的 emp 表。

hbase(main):002:0> list
TABLE
emp
2 row(s) in 0.0340 seconds

Creating a Table Using java API

可以使用 HBaseAdmin 类的 createTable() 方法在 HBase 中创建一个表。此类属于 org.apache.hadoop.hbase.client 包。以下是使用 Java API 在 HBase 中创建表的步骤。

Step1: Instantiate HBaseAdmin

此类需要 Configuration 对象作为参数,因此,首先实例化 Configuration 类并将此实例传递给 HBaseAdmin。

Configuration conf = HBaseConfiguration.create();
HBaseAdmin admin = new HBaseAdmin(conf);

Step2: Create TableDescriptor

HTableDescriptor 是属于 org.apache.hadoop.hbase 类的类。此类类似于表名称和列系列的容器。

//creating table descriptor
HTableDescriptor table = new HTableDescriptor(toBytes("Table name"));

//creating column family descriptor
HColumnDescriptor family = new HColumnDescriptor(toBytes("column family"));

//adding coloumn family to HTable
table.addFamily(family);

Step 3: Execute through Admin

使用 HBaseAdmin 类的 createTable() 方法,您可以在 Admin 模式下执行所创建的表。

admin.createTable(table);

以下是通过管理员创建表的完整程序。

import java.io.IOException;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.client.HBaseAdmin;
import org.apache.hadoop.hbase.TableName;

import org.apache.hadoop.conf.Configuration;

public class CreateTable {

   public static void main(String[] args) throws IOException {

      // Instantiating configuration class
      Configuration con = HBaseConfiguration.create();

      // Instantiating HbaseAdmin class
      HBaseAdmin admin = new HBaseAdmin(con);

      // Instantiating table descriptor class
      HTableDescriptor tableDescriptor = new
      HTableDescriptor(TableName.valueOf("emp"));

      // Adding column families to table descriptor
      tableDescriptor.addFamily(new HColumnDescriptor("personal"));
      tableDescriptor.addFamily(new HColumnDescriptor("professional"));

      // Execute the table through admin
      admin.createTable(tableDescriptor);
      System.out.println(" Table created ");
   }
}

编译并执行上述程序,如下所示:

$javac CreateTable.java
$java CreateTable

输出应如下所示:

Table created

HBase - Listing Table

Listing a Table using HBase Shell

list 是用于列出 HBase 中所有表的命令。以下是 list 命令的语法。

hbase(main):001:0 > list

当你键入此命令并在 HBase 提示符中执行它时,它会显示 HBase 中所有表的列表,如下所示。

hbase(main):001:0> list
TABLE
emp

此处你可以看到一个名为 emp 的表。

Listing Tables Using Java API

按照以下步骤使用 java API 从 HBase 获取表格列表。

Step 1

HBaseAdmin 中有一个名为 listTables() 的方法,可用于获取 HBase 中所有表的列表。此方法返回 HTableDescriptor 对象的数组。

//creating a configuration object
Configuration conf = HBaseConfiguration.create();

//Creating HBaseAdmin object
HBaseAdmin admin = new HBaseAdmin(conf);

//Getting all the list of tables using HBaseAdmin object
HTableDescriptor[] tableDescriptor = admin.listTables();

Step 2

可以使用 HTableDescriptor 类的 length 变量获取 HTableDescriptor[] 数组的长度。使用 getNameAsString() 方法从该对象获取表的名称。使用这些来运行“for”循环,并获取 HBase 中的表格列表。

下面给出了使用 Java API 列出 HBase 中所有表的程序。

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.MasterNotRunningException;
import org.apache.hadoop.hbase.client.HBaseAdmin;

public class ListTables {

   public static void main(String args[])throws MasterNotRunningException, IOException{

      // Instantiating a configuration class
      Configuration conf = HBaseConfiguration.create();

      // Instantiating HBaseAdmin class
      HBaseAdmin admin = new HBaseAdmin(conf);

      // Getting all the list of tables using HBaseAdmin object
      HTableDescriptor[] tableDescriptor = admin.listTables();

      // printing all the table names.
      for (int i=0; i<tableDescriptor.length;i++ ){
         System.out.println(tableDescriptor[i].getNameAsString());
      }

   }
}

编译并执行上述程序,如下所示:

$javac ListTables.java
$java ListTables

输出应如下所示:

User
emp

HBase - Disabling a Table

Disabling a Table using HBase Shell

要删除表或更改其设置,你首先需要使用 disable 命令禁用该表。你可以使用 enable 命令重新启用它。

以下是禁用表语法的说明:

disable ‘emp’

Example

下面是一个示例,显示如何禁用一个表。

hbase(main):025:0> disable 'emp'
0 row(s) in 1.2760 seconds

Verification

在禁用表之后,你仍然可以通过 listexists 命令感知它的存在。你无法扫描它。它将给出以下错误。

hbase(main):028:0> scan 'emp'
ROW         COLUMN + CELL
ERROR: emp is disabled.

is_disabled

该命令用于查找表是否已禁用。其语法如下。

hbase> is_disabled 'table name'

以下示例验证名为 emp 的表是否已禁用。如果禁用,则返回 true,否则返回 false。

hbase(main):031:0> is_disabled 'emp'
true
0 row(s) in 0.0440 seconds

disable_all

该命令用于禁用与给定正则表达式匹配的所有表。 disable_all 命令的语法如下。

hbase> disable_all 'r.*'

假设 HBase 中有 5 张表,即 raja、rajani、rajendra、rajesh 和 raju。以下代码将禁用所有以 raj. 开头的表

hbase(main):002:07> disable_all 'raj.*'
raja
rajani
rajendra
rajesh
raju
Disable the above 5 tables (y/n)?
y
5 tables successfully disabled

Disable a Table Using Java API

要验证表是否已被禁用,使用 isTableDisabled() 方法,要禁用表,使用 disableTable() 方法。这些方法属于 HBaseAdmin 类。遵循以下步骤来禁用表。

Step 1

按如下所示实例化 HBaseAdmin 类。

// Creating configuration object
Configuration conf = HBaseConfiguration.create();

// Creating HBaseAdmin object
HBaseAdmin admin = new HBaseAdmin(conf);

Step 2

按如下所示使用 isTableDisabled() 方法验证表是否已禁用。

Boolean b = admin.isTableDisabled("emp");

Step 3

如果该表未禁用,按如下所示禁用它。

if(!b){
   admin.disableTable("emp");
   System.out.println("Table disabled");
}

以下是用来验证表是否已被禁用的完整程序;如果没有,如何禁用它。

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.MasterNotRunningException;
import org.apache.hadoop.hbase.client.HBaseAdmin;

public class DisableTable{

   public static void main(String args[]) throws MasterNotRunningException, IOException{

      // Instantiating configuration class
      Configuration conf = HBaseConfiguration.create();

      // Instantiating HBaseAdmin class
      HBaseAdmin admin = new HBaseAdmin(conf);

      // Verifying weather the table is disabled
      Boolean bool = admin.isTableDisabled("emp");
      System.out.println(bool);

      // Disabling the table using HBaseAdmin object
      if(!bool){
         admin.disableTable("emp");
         System.out.println("Table disabled");
      }
   }
}

编译并执行上述程序,如下所示:

$javac DisableTable.java
$java DsiableTable

输出应如下所示:

false
Table disabled

HBase - Enabling a Table

Enabling a Table using HBase Shell

启用表的语法:

enable ‘emp’

Example

以下是启用表的示例。

hbase(main):005:0> enable 'emp'
0 row(s) in 0.4580 seconds

Verification

启用表后,扫描它。如果能看到该架构,则说明表已成功启用。

hbase(main):006:0> scan 'emp'

   ROW                        COLUMN + CELL

1 column = personal data:city, timestamp = 1417516501, value = hyderabad

1 column = personal data:name, timestamp = 1417525058, value = ramu

1 column = professional data:designation, timestamp = 1417532601, value = manager

1 column = professional data:salary, timestamp = 1417524244109, value = 50000

2 column = personal data:city, timestamp = 1417524574905, value = chennai

2 column = personal data:name, timestamp = 1417524556125, value = ravi

2 column = professional data:designation, timestamp = 14175292204, value = sr:engg

2 column = professional data:salary, timestamp = 1417524604221, value = 30000

3 column = personal data:city, timestamp = 1417524681780, value = delhi

3 column = personal data:name, timestamp = 1417524672067, value = rajesh

3 column = professional data:designation, timestamp = 14175246987, value = jr:engg

3 column = professional data:salary, timestamp = 1417524702514, value = 25000

3 row(s) in 0.0400 seconds

is_enabled

此命令用于查找表是否已启用。其语法如下:

hbase> is_enabled 'table name'

以下代码验证名为 emp 的表是否已启用。如果已启用,它将返回 true;如果未启用,它将返回 false。

hbase(main):031:0> is_enabled 'emp'
true
0 row(s) in 0.0440 seconds

Enable a Table Using Java API

要验证表是否已启用,使用 isTableEnabled() 方法;要启用表,使用 enableTable() 方法。这些方法属于 HBaseAdmin 类。按照以下步骤启用表。

Step1

按如下所示实例化 HBaseAdmin 类。

// Creating configuration object
Configuration conf = HBaseConfiguration.create();

// Creating HBaseAdmin object
HBaseAdmin admin = new HBaseAdmin(conf);

Step 2

使用 isTableEnabled() 方法验证表是否已启用,如下所示。

Boolean bool = admin.isTableEnabled("emp");

Step 3

如果该表未禁用,按如下所示禁用它。

if(!bool){
   admin.enableTable("emp");
   System.out.println("Table enabled");
}

以下是完整的程序,用于验证表是否已启用,如果未启用,则如何启用它。

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.MasterNotRunningException;
import org.apache.hadoop.hbase.client.HBaseAdmin;

public class EnableTable{

   public static void main(String args[]) throws MasterNotRunningException, IOException{

      // Instantiating configuration class
      Configuration conf = HBaseConfiguration.create();

      // Instantiating HBaseAdmin class
      HBaseAdmin admin = new HBaseAdmin(conf);

      // Verifying whether the table is disabled
      Boolean bool = admin.isTableEnabled("emp");
      System.out.println(bool);

      // Enabling the table using HBaseAdmin object
      if(!bool){
         admin.enableTable("emp");
         System.out.println("Table Enabled");
      }
   }
}

编译并执行上述程序,如下所示:

$javac EnableTable.java
$java EnableTable

输出应如下所示:

false
Table Enabled

HBase - Describe & Alter

describe

此命令返回表的描述。其语法如下:

hbase> describe 'table name'

以下是 emp 表上 describe 命令的输出:

hbase(main):006:0> describe 'emp'
   DESCRIPTION
      ENABLED

'emp', {NAME ⇒ 'READONLY', DATA_BLOCK_ENCODING ⇒ 'NONE', BLOOMFILTER
⇒ 'ROW', REPLICATION_SCOPE ⇒ '0', COMPRESSION ⇒ 'NONE', VERSIONS ⇒
'1', TTL true

⇒ 'FOREVER', MIN_VERSIONS ⇒ '0', KEEP_DELETED_CELLS ⇒ 'false',
BLOCKSIZE ⇒ '65536', IN_MEMORY ⇒ 'false', BLOCKCACHE ⇒ 'true'}, {NAME
⇒ 'personal

data', DATA_BLOCK_ENCODING ⇒ 'NONE', BLOOMFILTER ⇒ 'ROW',
REPLICATION_SCOPE ⇒ '0', VERSIONS ⇒ '5', COMPRESSION ⇒ 'NONE',
MIN_VERSIONS ⇒ '0', TTL

⇒ 'FOREVER', KEEP_DELETED_CELLS ⇒ 'false', BLOCKSIZE ⇒ '65536',
IN_MEMORY ⇒ 'false', BLOCKCACHE ⇒ 'true'}, {NAME ⇒ 'professional
data', DATA_BLO

CK_ENCODING ⇒ 'NONE', BLOOMFILTER ⇒ 'ROW', REPLICATION_SCOPE ⇒ '0',
VERSIONS ⇒ '1', COMPRESSION ⇒ 'NONE', MIN_VERSIONS ⇒ '0', TTL ⇒
'FOREVER', K

EEP_DELETED_CELLS ⇒ 'false', BLOCKSIZE ⇒ '65536', IN_MEMORY ⇒
'false', BLOCKCACHE ⇒ 'true'}, {NAME ⇒ 'table_att_unset',
DATA_BLOCK_ENCODING ⇒ 'NO

NE', BLOOMFILTER ⇒ 'ROW', REPLICATION_SCOPE ⇒ '0', COMPRESSION ⇒
'NONE', VERSIONS ⇒ '1', TTL ⇒ 'FOREVER', MIN_VERSIONS ⇒ '0',
KEEP_DELETED_CELLS

⇒ 'false', BLOCKSIZE ⇒ '6

alter

Alter 是用于对现有表进行更改的命令。使用此命令,您可以更改列系列的最大单元格数,设置和删除表范围运算符,以及从表中删除列系列。

Changing the Maximum Number of Cells of a Column Family

以下是更改列系列的最大单元格数的语法:

hbase> alter 't1', NAME ⇒ 'f1', VERSIONS ⇒ 5

在以下示例中,单元格的最大数目设置为 5。

hbase(main):003:0> alter 'emp', NAME ⇒ 'personal data', VERSIONS ⇒ 5
Updating all regions with the new schema...
0/1 regions updated.
1/1 regions updated.
Done.
0 row(s) in 2.3050 seconds

Table Scope Operators

使用 alter,您可以设置和删除表范围运算符,例如 MAX_FILESIZE、READONLY、MEMSTORE_FLUSHSIZE、DEFERRED_LOG_FLUSH 等。

Setting Read Only

以下是使表变为只读的语法:

hbase>alter 't1', READONLY(option)

在以下示例中,我们使 emp 表变为只读。

hbase(main):006:0> alter 'emp', READONLY
Updating all regions with the new schema...
0/1 regions updated.
1/1 regions updated.
Done.
0 row(s) in 2.2140 seconds

Removing Table Scope Operators

我们还可以移除表作用域运算符。以下是从 emp 表中移除 "MAX_FILESIZE" 的语法:

hbase> alter 't1', METHOD ⇒ 'table_att_unset', NAME ⇒ 'MAX_FILESIZE'

Deleting a Column Family

使用 alter,您还可以删除一个列系列。以下是使用 alter 删除一个列系列的语法:

hbase> alter ‘ table name ’, ‘delete’ ⇒ ‘ column family ’

以下是从 "emp" 表中删除一个列系列的示例:

假设 HBase 中有一个名为 employee 的表。它包含以下数据:

hbase(main):006:0> scan 'employee'

   ROW                   COLUMN+CELL

row1 column = personal:city, timestamp = 1418193767, value = hyderabad

row1 column = personal:name, timestamp = 1418193806767, value = raju

row1 column = professional:designation, timestamp = 1418193767, value = manager

row1 column = professional:salary, timestamp = 1418193806767, value = 50000

1 row(s) in 0.0160 seconds

现在让我们使用 alter 命令删除名为 professional 的列系列。

hbase(main):007:0> alter 'employee','delete'⇒'professional'
Updating all regions with the new schema...
0/1 regions updated.
1/1 regions updated.
Done.
0 row(s) in 2.2380 seconds

现在验证更改后的表中的数据。观察列系列 "professional" 不存在了,因为我们已经将其删除了。

hbase(main):003:0> scan 'employee'
   ROW             COLUMN + CELL
row1 column = personal:city, timestamp = 14181936767, value = hyderabad

row1 column = personal:name, timestamp = 1418193806767, value = raju

1 row(s) in 0.0830 seconds

Adding a Column Family Using Java API

您可以使用 HBAseAdmin 类的 addColumn() 方法向表中添加一个列系列。按照以下步骤向表中添加一个列系列。

Step 1

实例化 HBaseAdmin 类。

// Instantiating configuration object
Configuration conf = HBaseConfiguration.create();

// Instantiating HBaseAdmin class
HBaseAdmin admin = new HBaseAdmin(conf);

Step 2

addColumn() 方法需要一个表名和一个 HColumnDescriptor 类对象。因此实例化 HColumnDescriptor 类。 HColumnDescriptor 的构造函数又需要一个要添加的列系列名称。这里我们向现有的 "employee" 表中添加一个名为 "contactDetails" 的列系列。

// Instantiating columnDescriptor object

HColumnDescriptor columnDescriptor = new
HColumnDescriptor("contactDetails");

Step 3

使用 addColumn 方法添加列系列。将表名和 HColumnDescriptor 类对象作为参数传递给此方法。

// Adding column family
admin.addColumn("employee", new HColumnDescriptor("columnDescriptor"));

以下是向现有表中添加列系列的完整程序。

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.MasterNotRunningException;
import org.apache.hadoop.hbase.client.HBaseAdmin;

public class AddColoumn{

   public static void main(String args[]) throws MasterNotRunningException, IOException{

      // Instantiating configuration class.
      Configuration conf = HBaseConfiguration.create();

      // Instantiating HBaseAdmin class.
      HBaseAdmin admin = new HBaseAdmin(conf);

      // Instantiating columnDescriptor class
      HColumnDescriptor columnDescriptor = new HColumnDescriptor("contactDetails");

      // Adding column family
      admin.addColumn("employee", columnDescriptor);
      System.out.println("coloumn added");
   }
}

编译并执行上述程序,如下所示:

$javac AddColumn.java
$java AddColumn

只有在您在 " .bashrc " 中设置了类路径时,上述编译才有效。如果您还没有,请按照以下步骤编译您的 .java 文件。

//if "/home/home/hadoop/hbase " is your Hbase home folder then.

$javac -cp /home/hadoop/hbase/lib/*: Demo.java

如果一切顺利,它将生成以下输出:

column added

Deleting a Column Family Using Java API

您可以使用 HBAseAdmin 类的 deleteColumn() 方法从表中删除一个列系列。按照以下步骤向表中添加一个列系列。

Step1

实例化 HBaseAdmin 类。

// Instantiating configuration object
Configuration conf = HBaseConfiguration.create();

// Instantiating HBaseAdmin class
HBaseAdmin admin = new HBaseAdmin(conf);

Step2

使用 deleteColumn() 方法添加列系列。将表名和列系列名称作为参数传递给此方法。

// Deleting column family
admin.deleteColumn("employee", "contactDetails");

以下是从现有表中删除一个列系列的完整程序。

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.MasterNotRunningException;
import org.apache.hadoop.hbase.client.HBaseAdmin;

public class DeleteColoumn{

   public static void main(String args[]) throws MasterNotRunningException, IOException{

      // Instantiating configuration class.
      Configuration conf = HBaseConfiguration.create();

      // Instantiating HBaseAdmin class.
      HBaseAdmin admin = new HBaseAdmin(conf);

      // Deleting a column family
      admin.deleteColumn("employee","contactDetails");
      System.out.println("coloumn deleted");
   }
}

编译并执行上述程序,如下所示:

$javac DeleteColumn.java
$java DeleteColumn

输出应如下所示:

column deleted

HBase - Exists

Existence of Table using HBase Shell

使用 exists 命令验证表是否存在。以下示例展示如何使用此命令。

hbase(main):024:0> exists 'emp'
Table emp does exist

0 row(s) in 0.0750 seconds

==================================================================

hbase(main):015:0> exists 'student'
Table student does not exist

0 row(s) in 0.0480 seconds

Verifying the Existence of Table Using Java API

可以使用 HBaseAdmin 类的 tableExists() 方法验证 HBase 中是否存在表。按照以下步骤操作以验证 HBase 中是否存在表。

Step 1

Instantiate the HBaseAdimn class

// Instantiating configuration object
Configuration conf = HBaseConfiguration.create();

// Instantiating HBaseAdmin class
HBaseAdmin admin = new HBaseAdmin(conf);

Step 2

使用 tableExists( ) 方法验证表是否存在。

下面是使用 Java API 测试 HBase 表是否存在的一个 Java 程序。

import java.io.IOException;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.client.HBaseAdmin;

public class TableExists{

   public static void main(String args[])throws IOException{

      // Instantiating configuration class
      Configuration conf = HBaseConfiguration.create();

      // Instantiating HBaseAdmin class
      HBaseAdmin admin = new HBaseAdmin(conf);

      // Verifying the existance of the table
      boolean bool = admin.tableExists("emp");
      System.out.println( bool);
   }
}

编译并执行上述程序,如下所示:

$javac TableExists.java
$java TableExists

输出应如下所示:

true

HBase - Drop a Table

Dropping a Table using HBase Shell

您可以使用 drop 命令删除一个表。在删除表之前,您必须禁用它。

hbase(main):018:0> disable 'emp'
0 row(s) in 1.4580 seconds

hbase(main):019:0> drop 'emp'
0 row(s) in 0.3060 seconds

使用 exists 命令验证表是否已删除。

hbase(main):020:07gt; exists 'emp'
Table emp does not exist
0 row(s) in 0.0730 seconds

drop_all

此命令用于删除与该命令中给定的 "regex" 匹配的表。它的语法如下:

hbase> drop_all ‘t.*’

Note: 在删除表格之前,您必须禁用表格。

Example

假设有名称为 raja、rajani、rajendra、rajesh 和 raju 的表格。

hbase(main):017:0> list
TABLE
raja
rajani
rajendra
rajesh
raju
9 row(s) in 0.0270 seconds

所有这些表格均以字母 raj 开头。首先,让我们使用 disable_all 命令禁用所有这些表格,如下所示。

hbase(main):002:0> disable_all 'raj.*'
raja
rajani
rajendra
rajesh
raju
Disable the above 5 tables (y/n)?
y
5 tables successfully disabled

现在您可以使用 drop_all 命令删除它们,如下所示。

hbase(main):018:0> drop_all 'raj.*'
raja
rajani
rajendra
rajesh
raju
Drop the above 5 tables (y/n)?
y
5 tables successfully dropped

Deleting a Table Using Java API

您可以使用 deleteTable() 类中的 HBaseAdmin 方法删除表格。按照以下步骤使用 Java API 删除表格。

Step 1

实例化 HBaseAdmin 类。

// creating a configuration object
Configuration conf = HBaseConfiguration.create();

// Creating HBaseAdmin object
HBaseAdmin admin = new HBaseAdmin(conf);

Step 2

使用 HBaseAdmin 类的 disableTable() 方法禁用表格。

admin.disableTable("emp1");

Step 3

现在使用 HBaseAdmin 类的 deleteTable() 方法删除表格。

admin.deleteTable("emp12");

下面给出了在 HBase 中删除表格的完整 Java 程序。

import java.io.IOException;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.client.HBaseAdmin;

public class DeleteTable {

   public static void main(String[] args) throws IOException {

      // Instantiating configuration class
      Configuration conf = HBaseConfiguration.create();

      // Instantiating HBaseAdmin class
      HBaseAdmin admin = new HBaseAdmin(conf);

      // disabling table named emp
      admin.disableTable("emp12");

      // Deleting emp
      admin.deleteTable("emp12");
      System.out.println("Table deleted");
   }
}

编译并执行上述程序,如下所示:

$javac DeleteTable.java
$java DeleteTable

输出应如下所示:

Table deleted

HBase - Shutting Down

exit

通过键入 exit 命令来退出 shell。

hbase(main):021:0> exit

Stopping HBase

若要停止 HBase,请浏览到 HBase 主文件夹并键入以下命令。

./bin/stop-hbase.sh

Stopping HBase Using Java API

可以使用 HBaseAdmin 类的 shutdown() 方法关闭 HBase。执行以下步骤以关闭 HBase:

Step 1

实例化 HbaseAdmin 类。

// Instantiating configuration object
Configuration conf = HBaseConfiguration.create();

// Instantiating HBaseAdmin object
HBaseAdmin admin = new HBaseAdmin(conf);

Step 2

使用 HBaseAdmin 类中的 shutdown() 方法关闭 HBase。

admin.shutdown();

以下是用于停止 HBase 的程序。

import java.io.IOException;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.client.HBaseAdmin;

public class ShutDownHbase{

   public static void main(String args[])throws IOException {

      // Instantiating configuration class
      Configuration conf = HBaseConfiguration.create();

      // Instantiating HBaseAdmin class
      HBaseAdmin admin = new HBaseAdmin(conf);

      // Shutting down HBase
      System.out.println("Shutting down hbase");
      admin.shutdown();
   }
}

编译并执行上述程序,如下所示:

$javac ShutDownHbase.java
$java ShutDownHbase

输出应如下所示:

Shutting down hbase

HBase - Client API

本章介绍 HBase 的 Java 客户端 API,用于对 HBase 表执行 CRUD 操作。HBase 用 Java 编写,并有一个 Java Native API。因此,它提供了对数据操作语言 (Data Manipulation Language, DML) 的编程访问。

Class HBase Configuration

将 HBase 配置文件添加到 Configuration。此类属于 org.apache.hadoop.hbase 包。

Methods and description

S.No.

Methods and Description

1

static org.apache.hadoop.conf.Configuration create() 此方法创建一个包含 HBase 资源的 Configuration。

Class HTable

HTable 是 HBase 内部类,表示 HBase 表。它是用于与单个 HBase 表通信的表的实现。此类属于 org.apache.hadoop.hbase.client 类。

Constructors

S.No.

Constructors and Description

1

HTable()

2

HTable(TableName tableName, ClusterConnection connection, ExecutorService pool) 使用此构造函数,您可以创建对象以访问 HBase 表。

Methods and description

S.No.

Methods and Description

1

void close() 释放 HTable 的所有资源。

2

void delete(Delete delete) 删除指定的单元格/行。

3

boolean exists(Get get) 使用此方法,您可以测试 Get 指定的表中是否存在列。

4

Result get(Get get) 从给定行中检索特定单元格。

5

org.apache.hadoop.conf.Configuration getConfiguration() 返回此实例使用的 Configuration 对象。

6

TableName getName() 返回此表的表名实例。

7

HTableDescriptor getTableDescriptor() 返回此表的表描述符。

8

byte[] getTableName() 返回此表的名称。

9

void put(Put put) 使用此方法,您可以向表中插入数据。

Class Put

此类用于对单个行执行 Put 操作。它属于 org.apache.hadoop.hbase.client 包。

Constructors

S.No.

Constructors and Description

1

Put(byte[] row) 使用此构造函数,您可以为指定行创建一个 Put 操作。

2

Put(byte[] rowArray, int rowOffset, int rowLength) 使用此构造函数,您可以对传入的行键进行复制以供本地保存。

3

Put(byte[] rowArray, int rowOffset, int rowLength, long ts) 使用此构造函数,您可以对传入行键进行复制以供本地保存。

4

Put(byte[] row, long ts) 使用此构造函数,我们可以为指定行创建一个 Put 操作,使用指定的时间戳。

Methods

S.No.

Methods and Description

1

Put add(byte[] family, byte[] qualifier, byte[] value) 将指定的列和值添加到此 Put 操作中。

2

Put add(byte[] family, byte[] qualifier, long ts, byte[] value) 将指定的列和值(指定的时间戳为其版本)添加到此 Put 操作中。

3

Put add(byte[] family, ByteBuffer qualifier, long ts, ByteBuffer value) 将指定的列和值(指定的时间戳为其版本)添加到此 Put 操作中。

4

Put add(byte[] family, ByteBuffer qualifier, long ts, ByteBuffer value) 将指定的列和值(指定的时间戳为其版本)添加到此 Put 操作中。

Class Get

此类用于对单行执行 Get 操作。此类属于 org.apache.hadoop.hbase.client 包。

Constructor

S.No.

Constructor and Description

1

Get(byte[] row) 使用此构造函数,您可以为指定行创建一个 Get 操作。

2

Get(Get get)

Methods

S.No.

Methods and Description

1

Get addColumn(byte[] family, byte[] qualifier) 从指定限定符的特定族中检索列。

2

Get addFamily(byte[] family) 从指定族中检索所有列。

Class Delete

此类用于对单行执行 Delete 操作。要删除整行,请实例化一个 Delete 对象,其中包含要删除的行。此类属于 org.apache.hadoop.hbase.client 包。

Constructor

S.No.

Constructor and Description

1

Delete(byte[] row) 为指定行创建 Delete 操作。

2

Delete(byte[] rowArray, int rowOffset, int rowLength) 为指定行和时间戳创建 Delete 操作。

3

Delete(byte[] rowArray, int rowOffset, int rowLength, long ts) 为指定行和时间戳创建 Delete 操作。

4

Delete(byte[] row, long timestamp) 为指定行和时间戳创建 Delete 操作。

Methods

S.No.

Methods and Description

1

Delete addColumn(byte[] family, byte[] qualifier) 删除指定列的最新版本。

2

Delete addColumns(byte[] family, byte[] qualifier, long timestamp) 删除所有版本的时间戳小于或等于指定时间戳的指定列。

3

Delete addFamily(byte[] family) 删除指定族的所有列的所有版本。

4

Delete addFamily(byte[] family, long timestamp) 删除时间戳小于或等于指定时间戳的指定族的所有列。

Class Result

此类用于获取 Get 或 Scan 查询的单行结果。

Constructors

S.No.

Constructors

1

Result() 使用此构造函数,您可以创建一个不带 KeyValue 有效负载的空结果;如果您调用原始 Cells(),将返回 null。

Methods

S.No.

Methods and Description

1

byte[] getValue(byte[] family, byte[] qualifier) 此方法用于获取指定列的最新版本。

2

byte[] getRow() 此方法用于检索与创建此 Result 的行相对应的行键。

HBase - Create Data

Inserting Data using HBase Shell

本章演示如何在 HBase 表中创建数据。要创建 HBase 表中的数据,请使用以下命令和方法:

  1. put command,

  2. Put 类的 add() 方法;和

  3. HTable 类的 put() 方法。

例如,我们要在 HBase 中创建以下表。

table

使用 put 命令,你可以向表中插入行。其语法如下:

put ’<table name>’,’row1’,’<colfamily:colname>’,’<value>’

Inserting the First Row

让我们按如下所示向 emp 表中插入第一行值。

hbase(main):005:0> put 'emp','1','personal data:name','raju'
0 row(s) in 0.6600 seconds
hbase(main):006:0> put 'emp','1','personal data:city','hyderabad'
0 row(s) in 0.0410 seconds
hbase(main):007:0> put 'emp','1','professional
data:designation','manager'
0 row(s) in 0.0240 seconds
hbase(main):007:0> put 'emp','1','professional data:salary','50000'
0 row(s) in 0.0240 seconds

以相同的方式使用 put 命令插入其余行。如果你插入整个表,你将获得以下输出。

hbase(main):022:0> scan 'emp'

   ROW                        COLUMN+CELL
1 column=personal data:city, timestamp=1417524216501, value=hyderabad

1 column=personal data:name, timestamp=1417524185058, value=ramu

1 column=professional data:designation, timestamp=1417524232601,

 value=manager

1 column=professional data:salary, timestamp=1417524244109, value=50000

2 column=personal data:city, timestamp=1417524574905, value=chennai

2 column=personal data:name, timestamp=1417524556125, value=ravi

2 column=professional data:designation, timestamp=1417524592204,

 value=sr:engg

2 column=professional data:salary, timestamp=1417524604221, value=30000

3 column=personal data:city, timestamp=1417524681780, value=delhi

3 column=personal data:name, timestamp=1417524672067, value=rajesh

3 column=professional data:designation, timestamp=1417524693187,

value=jr:engg
3 column=professional data:salary, timestamp=1417524702514,

value=25000

Inserting Data Using Java API

您可以使用 Put 类的 add() 方法向 HBase 插入数据。您可以使用 HTable 类的 put() 方法进行保存。这些类属于 org.apache.hadoop.hbase.client 包。以下是创建 HBase 表中的数据的步骤

Step 1:Instantiate the Configuration Class

Configuration 类将 HBase 配置文件添加到其对象中。您可以使用 HbaseConfiguration 类的 create() 方法创建一个配置对象,如下所示。

Configuration conf = HbaseConfiguration.create();

Step 2:Instantiate the HTable Class

您有一个名为 HTable 的类,它是 HBase 中 Table 的实现。该类用于与单个 HBase 表进行通信。在实例化该类时,它接受配置对象和表名作为参数。您可以如下所示实例化 HTable 类。

HTable hTable = new HTable(conf, tableName);

Step 3: Instantiate the PutClass

若要将数据插入 HBase 表,请使用 add() 方法及其变体。该方法属于 Put ,因此实例化 put 类。该类需要以字符串格式的你要向其插入数据的行名称。您可以如下所示实例化 Put 类。

Put p = new Put(Bytes.toBytes("row1"));

Step 4: InsertData

使用 Put 类的 add() 方法插入数据。它需要分别表示列族、列限定符(列名)和要插入的值的 3 个字节数组。使用 add() 方法将数据插入 HBase 表,如下所示。

p.add(Bytes.toBytes("coloumn family "), Bytes.toBytes("column
name"),Bytes.toBytes("value"));

Step 5: Save the Data in Table

在插入所需行之后,通过将 put 实例添加到 HTable 类的 put() 方法中保存更改,如下所示。

hTable.put(p);

Step 6: Close the HTable Instance

在 HBase 表中创建数据后,使用 close() 方法关闭 HTable 实例,如下所示。

hTable.close();

以下是创建 HBase 表中数据的完整程序。

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.util.Bytes;

public class InsertData{

   public static void main(String[] args) throws IOException {

      // Instantiating Configuration class
      Configuration config = HBaseConfiguration.create();

      // Instantiating HTable class
      HTable hTable = new HTable(config, "emp");

      // Instantiating Put class
      // accepts a row name.
      Put p = new Put(Bytes.toBytes("row1"));

      // adding values using add() method
      // accepts column family name, qualifier/row name ,value
      p.add(Bytes.toBytes("personal"),
      Bytes.toBytes("name"),Bytes.toBytes("raju"));

      p.add(Bytes.toBytes("personal"),
      Bytes.toBytes("city"),Bytes.toBytes("hyderabad"));

      p.add(Bytes.toBytes("professional"),Bytes.toBytes("designation"),
      Bytes.toBytes("manager"));

      p.add(Bytes.toBytes("professional"),Bytes.toBytes("salary"),
      Bytes.toBytes("50000"));

      // Saving the put Instance to the HTable.
      hTable.put(p);
      System.out.println("data inserted");

      // closing HTable
      hTable.close();
   }
}

编译并执行上述程序,如下所示:

$javac InsertData.java
$java InsertData

输出应如下所示:

data inserted

HBase - Update Data

Updating Data using HBase Shell

你可以使用 put 命令更新现有单元格值。为此,只需遵循相同的语法,然后提及你的新值,如下所示。

put ‘table name’,’row ’,'Column family:column name',’new value’

新给定的值将替换现有值,从而更新该行。

Example

假设 HBase 中有一个名为 emp 的表,其中包含如下数据。

hbase(main):003:0> scan 'emp'
 ROW              COLUMN + CELL
row1 column = personal:name, timestamp = 1418051555, value = raju
row1 column = personal:city, timestamp = 1418275907, value = Hyderabad
row1 column = professional:designation, timestamp = 14180555,value = manager
row1 column = professional:salary, timestamp = 1418035791555,value = 50000
1 row(s) in 0.0100 seconds

以下命令会将名为“Raju”的员工的所在地更新为德里。

hbase(main):002:0> put 'emp','row1','personal:city','Delhi'
0 row(s) in 0.0400 seconds

更新后的表格如下所示,你可以看到 Raju 所在城市已变更为“德里”。

hbase(main):003:0> scan 'emp'
  ROW          COLUMN + CELL
row1 column = personal:name, timestamp = 1418035791555, value = raju
row1 column = personal:city, timestamp = 1418274645907, value = Delhi
row1 column = professional:designation, timestamp = 141857555,value = manager
row1 column = professional:salary, timestamp = 1418039555, value = 50000
1 row(s) in 0.0100 seconds

Updating Data Using Java API

你可以使用 put() 方法更新特定单元格中的数据。按照以下给定的步骤更新表的现有单元格值。

Step 1: Instantiate the Configuration Class

Configuration 类将其 HBase 配置文件添加到其对象中。你可以使用 HbaseConfiguration 类的 create() 方法创建一个配置对象,如下所示。

Configuration conf = HbaseConfiguration.create();

Step 2: Instantiate the HTable Class

你有一个名为 HTable 的类,是 Table 在 HBase 中的一个实现。该类用于与单个 HBase 表通信。在实例化该类时,它将接受配置对象和表名作为参数。你可以如下所示实例化 HTable 类。

HTable hTable = new HTable(conf, tableName);

Step 3: Instantiate the Put Class

要将数据插入到 HBase 表中,可以使用 add() 方法及其变体。该方法属于 Put ,因此实例化 put 类。此类需要你想要在其中插入数据的行名(字符串格式)。你可以如下所示实例化 Put 类。

Put p = new Put(Bytes.toBytes("row1"));

Step 4: Update an Existing Cell

Put 类的 add() 方法用于插入数据。它需要 3 个字节数组,分别表示列族、列限定符(列名)和要插入的值。如下所示使用 add() 方法将数据插入到 HBase 表中。

p.add(Bytes.toBytes("coloumn family "), Bytes.toBytes("column
name"),Bytes.toBytes("value"));
p.add(Bytes.toBytes("personal"),
Bytes.toBytes("city"),Bytes.toBytes("Delih"));

Step 5: Save the Data in Table

插入所需行后,将 put 实例添加到 HTable 类的 put() 方法中保存更改,如下所示。

hTable.put(p);

Step 6: Close HTable Instance

在 HBase 表中创建数据后,使用 close() 方法关闭 HTable 实例,如下所示。

hTable.close();

下面给出了用于更新特定表中数据的完整程序。

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.util.Bytes;

public class UpdateData{

   public static void main(String[] args) throws IOException {

      // Instantiating Configuration class
      Configuration config = HBaseConfiguration.create();

      // Instantiating HTable class
      HTable hTable = new HTable(config, "emp");

      // Instantiating Put class
      //accepts a row name
      Put p = new Put(Bytes.toBytes("row1"));

      // Updating a cell value
      p.add(Bytes.toBytes("personal"),
      Bytes.toBytes("city"),Bytes.toBytes("Delih"));

      // Saving the put Instance to the HTable.
      hTable.put(p);
      System.out.println("data Updated");

      // closing HTable
      hTable.close();
   }
}

编译并执行上述程序,如下所示:

$javac UpdateData.java
$java UpdateData

输出应如下所示:

data Updated

HBase - Read Data

Reading Data using HBase Shell

get 命令和 get() 方法的 HTable 类用于从 HBase 中某张表读取数据。使用 get 命令,您一次只能获取一行数据。它的语法如下所示:

get ’<table name>’,’row1’

Example

以下示例显示如何使用 get 命令。让我们扫描 emp 表的第一行。

hbase(main):012:0> get 'emp', '1'

   COLUMN                     CELL

personal : city timestamp = 1417521848375, value = hyderabad

personal : name timestamp = 1417521785385, value = ramu

professional: designation timestamp = 1417521885277, value = manager

professional: salary timestamp = 1417521903862, value = 50000

4 row(s) in 0.0270 seconds

Reading a Specific Column

下面给出使用 get 方法读取特定列的语法。

hbase> get 'table name', ‘rowid’, {COLUMN ⇒ ‘column family:column name ’}

Example

下面给出在 HBase 表中读取特定列的示例。

hbase(main):015:0> get 'emp', 'row1', {COLUMN ⇒ 'personal:name'}
  COLUMN                CELL
personal:name timestamp = 1418035791555, value = raju
1 row(s) in 0.0080 seconds

Reading Data Using Java API

要从 HBase 表中读取数据,请使用 HTable 类的 get() 方法。此方法需要 Get 类的实例。按照以下步骤从 HBase 表中检索数据。

Step 1: Instantiate the Configuration Class

Configuration 类将其 HBase 配置文件添加到其对象中。你可以使用 HbaseConfiguration 类的 create() 方法创建一个配置对象,如下所示。

Configuration conf = HbaseConfiguration.create();

Step 2: Instantiate the HTable Class

你有一个名为 HTable 的类,是 Table 在 HBase 中的一个实现。该类用于与单个 HBase 表通信。在实例化该类时,它将接受配置对象和表名作为参数。你可以如下所示实例化 HTable 类。

HTable hTable = new HTable(conf, tableName);

Step 3: Instantiate the Get Class

您可以使用 HTable 类的 get() 方法从 HBase 表中检索数据。此方法从给定行中提取一个单元格。它需要一个 Get 类对象作为参数。如下所示创建它。

Get get = new Get(toBytes("row1"));

Step 4: Read the Data

在检索数据时,您可以按 ID 获取单行,或按一组行 ID 获取一组行,或扫描整个表或一组行。

可以使用 Get 类中的 add 方法变量来检索 HBase 表数据。

要从特定列族获取特定列,请使用以下方法。

get.addFamily(personal)

要从特定列族获取所有列,请使用以下方法。

get.addColumn(personal, name)

Step 5: Get the Result

通过将 Get 类实例传递给 HTable 类的 get 方法来获取结果。此方法返回 Result 类对象,该对象保存所请求的结果。下面是 get() 方法的用法。

Result result = table.get(g);

Step 6: Reading Values from the Result Instance

Result 类提供了 getValue() 方法来读取其实例中的值。如下所示使用它从 Result 实例中读取值。

byte [] value = result.getValue(Bytes.toBytes("personal"),Bytes.toBytes("name"));
byte [] value1 = result.getValue(Bytes.toBytes("personal"),Bytes.toBytes("city"));

下面给出从 HBase 表中读取值的完整程序。

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.util.Bytes;

public class RetriveData{

   public static void main(String[] args) throws IOException, Exception{

      // Instantiating Configuration class
      Configuration config = HBaseConfiguration.create();

      // Instantiating HTable class
      HTable table = new HTable(config, "emp");

      // Instantiating Get class
      Get g = new Get(Bytes.toBytes("row1"));

      // Reading the data
      Result result = table.get(g);

      // Reading values from Result class object
      byte [] value = result.getValue(Bytes.toBytes("personal"),Bytes.toBytes("name"));

      byte [] value1 = result.getValue(Bytes.toBytes("personal"),Bytes.toBytes("city"));

      // Printing the values
      String name = Bytes.toString(value);
      String city = Bytes.toString(value1);

      System.out.println("name: " + name + " city: " + city);
   }
}

编译并执行上述程序,如下所示:

$javac RetriveData.java
$java RetriveData

输出应如下所示:

name: Raju city: Delhi

HBase - Delete Data

Deleting a Specific Cell in a Table

使用 delete 命令,您可以在表中删除特定单元格。 delete 命令的语法如下所示:

delete ‘<table name>’, ‘<row>’, ‘<column name >’, ‘<time stamp>’

Example

这是一个示例,用以删除特定 cell。这里我们正在删除薪水。

hbase(main):006:0> delete 'emp', '1', 'personal data:city',
1417521848375
0 row(s) in 0.0060 seconds

Deleting All Cells in a Table

使用 “deleteall” 命令,您可以删除一行中的所有 cell。下面给出了 deleteall 命令的语法。

deleteall ‘<table name>’, ‘<row>’,

Example

这是一个“deleteall”命令的示例,在这里我们正在删除 emp 表的第一行所有 cell。

hbase(main):007:0> deleteall 'emp','1'
0 row(s) in 0.0240 seconds

使用 scan 命令验证表。下面给出了删除表后的表快照。

hbase(main):022:0> scan 'emp'

ROW                  COLUMN + CELL

2 column = personal data:city, timestamp = 1417524574905, value = chennai

2 column = personal data:name, timestamp = 1417524556125, value = ravi

2 column = professional data:designation, timestamp = 1417524204, value = sr:engg

2 column = professional data:salary, timestamp = 1417524604221, value = 30000

3 column = personal data:city, timestamp = 1417524681780, value = delhi

3 column = personal data:name, timestamp = 1417524672067, value = rajesh

3 column = professional data:designation, timestamp = 1417523187, value = jr:engg

3 column = professional data:salary, timestamp = 1417524702514, value = 25000

Deleting Data Using Java API

您可以使用 HTable 类的 delete() 方法从 HBase 表中删除数据。按照以下步骤从表中删除数据。

Step 1: Instantiate the Configuration Class

Configuration 类将 HBase 配置文件添加到其对象中。您可以使用 HbaseConfiguration 类的 create() 方法创建配置对象,如下所示。

Configuration conf = HbaseConfiguration.create();

Step 2: Instantiate the HTable Class

你有一个名为 HTable 的类,是 Table 在 HBase 中的一个实现。该类用于与单个 HBase 表通信。在实例化该类时,它将接受配置对象和表名作为参数。你可以如下所示实例化 HTable 类。

HTable hTable = new HTable(conf, tableName);

Step 3: Instantiate the Delete Class

通过传递要删除的行 rowid(以字节数组格式)来实例化 Delete 类。您还可以将时间戳和 Rowlock 传递到此构造函数。

Delete delete = new Delete(toBytes("row1"));

Step 4: Select the Data to be Deleted

您可以使用 Delete 类的 delete 方法删除数据。这个类有各种删除方法。使用这些方法选择要删除的列或列系列。查看显示 Delete 类方法用法以下示例。

delete.deleteColumn(Bytes.toBytes("personal"), Bytes.toBytes("name"));
delete.deleteFamily(Bytes.toBytes("professional"));

Step 5: Delete the Data

delete 实例传递给 HTable 类的 delete() 方法,如下所示,删除所选数据。

table.delete(delete);

Step 6: Close the HTableInstance

删除数据后,关闭 HTable 实例。

table.close();

下面给出从 HBase 表中删除数据的完整程序。

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.Delete;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.util.Bytes;

public class DeleteData {

   public static void main(String[] args) throws IOException {

      // Instantiating Configuration class
      Configuration conf = HBaseConfiguration.create();

      // Instantiating HTable class
      HTable table = new HTable(conf, "employee");

      // Instantiating Delete class
      Delete delete = new Delete(Bytes.toBytes("row1"));
      delete.deleteColumn(Bytes.toBytes("personal"), Bytes.toBytes("name"));
      delete.deleteFamily(Bytes.toBytes("professional"));

      // deleting the data
      table.delete(delete);

      // closing the HTable object
      table.close();
      System.out.println("data deleted.....");
   }
}

编译并执行上述程序,如下所示:

$javac Deletedata.java
$java DeleteData

输出应如下所示:

data deleted

HBase - Scan

Scaning using HBase Shell

scan 命令用于查看 HTable 中的数据。使用 scan 命令,您可以获取表数据。它的语法如下:

scan ‘<table name>’

Example

以下示例演示如何使用 scan 命令从表中读取数据。这里我们正在读取 emp 表。

hbase(main):010:0> scan 'emp'

ROW                           COLUMN + CELL

1 column = personal data:city, timestamp = 1417521848375, value = hyderabad

1 column = personal data:name, timestamp = 1417521785385, value = ramu

1 column = professional data:designation, timestamp = 1417585277,value = manager

1 column = professional data:salary, timestamp = 1417521903862, value = 50000

1 row(s) in 0.0370 seconds

Scanning Using Java API

使用 java API 扫描整个表数据的完整程序如下。

import java.io.IOException;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.util.Bytes;

import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.ResultScanner;
import org.apache.hadoop.hbase.client.Scan;


public class ScanTable{

   public static void main(String args[]) throws IOException{

      // Instantiating Configuration class
      Configuration config = HBaseConfiguration.create();

      // Instantiating HTable class
      HTable table = new HTable(config, "emp");

      // Instantiating the Scan class
      Scan scan = new Scan();

      // Scanning the required columns
      scan.addColumn(Bytes.toBytes("personal"), Bytes.toBytes("name"));
      scan.addColumn(Bytes.toBytes("personal"), Bytes.toBytes("city"));

      // Getting the scan result
      ResultScanner scanner = table.getScanner(scan);

      // Reading values from scan result
      for (Result result = scanner.next(); result != null; result = Scanner.next())

      System.out.println("Found row : " + result);
      //closing the scanner
      scanner.close();
   }
}

编译并执行上述程序,如下所示:

$javac ScanTable.java
$java ScanTable

输出应如下所示:

Found row :
keyvalues={row1/personal:city/1418275612888/Put/vlen=5/mvcc=0,
row1/personal:name/1418035791555/Put/vlen=4/mvcc=0}

HBase - Count & Truncate

count

您可以使用 count 命令计算表的行数。它的语法如下:

count ‘<table name>’

删除第一行后,emp 表将有两行。如下所示进行验证。

hbase(main):023:0> count 'emp'
2 row(s) in 0.090 seconds
⇒ 2

truncate

此命令禁用删除并重新创建表。 truncate 的语法如下:

hbase> truncate 'table name'

Example

下面给出了 truncate 命令的示例。在这里我们截断了 emp 表。

hbase(main):011:0> truncate 'emp'
Truncating 'one' table (it may take a while):
   - Disabling table...
   - Truncating table...
   0 row(s) in 1.5950 seconds

截断表后,使用 scan 命令进行验证。您将得到一个零行的表。

hbase(main):017:0> scan ‘emp’
ROW                  COLUMN + CELL
0 row(s) in 0.3110 seconds

HBase - Security

我们可以在 HBase 中向用户授予和撤销权限。出于安全目的,有三个命令:授予、撤销和用户权限。

grant

grant 命令授予特定权限,例如对某个表的读、写、执行和管理权限。grant 命令的语法如下:

hbase> grant <user> <permissions> [<table> [<column family> [&ltcolumn; qualifier>]]

我们可以从 RWXCA 集合中向用户授予零个或更多权限,其中

  1. R - 表示读取权限。

  2. W - 表示写入权限。

  3. X - 表示执行权限。

  4. C - 表示创建权限。

  5. A - 表示管理权限。

下面给出的示例授予名为“Tutorialspoint”的用户所有权限。

hbase(main):018:0> grant 'Tutorialspoint', 'RWXCA'

revoke

revoke 命令用于撤销用户对某个表的访问权限。其语法如下:

hbase> revoke <user>

以下代码撤销了名为“Tutorialspoint”用户的权限。

hbase(main):006:0> revoke 'Tutorialspoint'

user_permission

此命令用于列出某个特定表的权限。 user_permission 的语法如下:

hbase>user_permission ‘tablename’

以下代码列出了“emp”表的权限。

hbase(main):013:0> user_permission 'emp'