HBase 快速指南

---

---

HBase - 概述

自1970年以来，关系数据库管理系统 (RDBMS) 一直是解决数据存储和维护相关问题的方案。在大数据出现后，公司意识到处理大数据的益处，并开始选择 Hadoop 等解决方案。

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

Hadoop 的局限性

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

处理海量数据集时会产生另一个海量数据集，也必须顺序处理。此时，需要一种新的解决方案来在单个时间单位内访问数据的任何点（随机访问）。

Hadoop 随机访问数据库

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

什么是 HBase？

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

HBase 是一种与 Google 的 Bigtable 类似的数据模型，旨在提供对海量结构化数据的快速随机访问。它利用 Hadoop 分布式文件系统 (HDFS) 提供的容错能力。

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

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

HBase 和 HDFS

HBase 中的存储机制

HBase 是一个列式数据库，其中的表按行排序。表模式仅定义列族，它们是键值对。一个表可以有多个列族，每个列族可以有任意数量的列。后续的列值连续存储在磁盘上。表的每个单元格值都有一个时间戳。简而言之，在 HBase 中

• 表是行的集合。
• 行是列族的集合。
• 列族是列的集合。
• 列是键值对的集合。

下面是 HBase 表的示例模式。

列式和行式

列式数据库是指将数据表存储为数据列的节，而不是数据的行。简而言之，它们将具有列族。

下图显示了列式数据库中的列族

HBase 和 RDBMS

HBase 的特性

• HBase 具有线性可扩展性。
• 它具有自动故障支持。
• 它提供一致的读写。
• 它与 Hadoop 集成，既作为源也作为目标。
• 它具有简单的 Java 客户端 API。
• 它提供跨集群的数据复制。

HBase 的使用场景

• Apache HBase 用于对大数据进行随机、实时的读/写访问。

• 它在商用硬件集群之上托管超大型表。

• Apache HBase 是一个非关系数据库，其模型参考了 Google 的 Bigtable。Bigtable 运行在 Google 文件系统上，同样，Apache HBase 运行在 Hadoop 和 HDFS 之上。

HBase 的应用

• 每当需要编写重量级应用程序时，都可以使用它。
• 每当我们需要对可用数据提供快速随机访问时，就使用 HBase。
• Facebook、Twitter、Yahoo 和 Adobe 等公司在内部使用 HBase。

HBase 历史

HBase - 架构

在 HBase 中，表被分割成区域，并由区域服务器提供服务。区域被列族垂直划分为“存储”。存储作为文件保存在 HDFS 中。下图显示了 HBase 的架构。

注意：术语“存储”用于解释区域的存储结构。

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

主服务器

主服务器 -

• 将区域分配给区域服务器，并为此任务借助 Apache ZooKeeper。

• 处理跨区域服务器的区域负载均衡。它卸载繁忙的服务器并将区域转移到占用率较低的服务器。

• 通过协商负载均衡来维护集群的状态。

• 负责模式更改和其他元数据操作，例如创建表和列族。

区域

区域只不过是分割并分布在区域服务器上的表。

区域服务器

区域服务器具有以下区域 -

• 与客户端通信并处理与数据相关的操作。
• 处理其下所有区域的读写请求。
• 通过遵循区域大小阈值来确定区域的大小。

当我们深入研究区域服务器时，它包含如下所示的区域和存储

存储包含内存存储和 HFile。Memstore 就像缓存内存一样。最初输入 HBase 的任何内容都存储在这里。稍后，数据将被传输并保存到 HFile 中作为块，并且 memstore 将被刷新。

ZooKeeper

• ZooKeeper 是一个开源项目，它提供维护配置信息、命名、提供分布式同步等服务。

• ZooKeeper 具有表示不同区域服务器的短暂节点。主服务器使用这些节点来发现可用的服务器。

• 除了可用性之外，这些节点还用于跟踪服务器故障或网络分区。

• 客户端通过 ZooKeeper 与区域服务器通信。

• 在伪分布式和独立模式下，HBase 本身将负责 ZooKeeper。

HBase - 安装

本章解释了如何安装和初始配置 HBase。需要 Java 和 Hadoop 才能继续使用 HBase，因此您必须在系统中下载和安装 Java 和 Hadoop。

预安装设置

在将 Hadoop 安装到 Linux 环境之前，我们需要使用ssh（安全外壳）设置 Linux。请按照以下步骤设置 Linux 环境。

创建用户

首先，建议为 Hadoop 创建一个单独的用户，以将 Hadoop 文件系统与 Unix 文件系统隔离。请按照以下步骤创建用户。

• 使用命令“su”打开 root。
• 使用命令“useradd 用户名”从 root 帐户创建用户。
• 现在，您可以使用命令“su 用户名”打开现有用户帐户。

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

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

SSH 设置和密钥生成

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

验证 ssh

ssh localhost

安装 Java

Java 是 Hadoop 和 HBase 的主要先决条件。首先，您应该使用“java -version”验证系统中 Java 的存在。java 版本命令的语法如下所示。

$ 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。

步骤 1

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

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

步骤 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

步骤 3

为了使 Java 可供所有用户使用，您必须将其移动到“/usr/local/”位置。打开 root 并键入以下命令。

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

步骤 4

为了设置PATH 和JAVA_HOME 变量，请将以下命令添加到~/.bashrc 文件中。

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

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

$ source ~/.bashrc

步骤 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命令。

下载 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 软件基金会下载并解压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

安装 Hadoop

您可以以任何所需的模式安装 Hadoop。这里，我们演示的是伪分布式模式下的 HBase 功能，因此请以伪分布式模式安装 Hadoop。

安装Hadoop 2.4.1的步骤如下：

步骤 1 - 设置 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

步骤 2 - Hadoop 配置

您可以在“$HADOOP_HOME/etc/hadoop”位置找到所有 Hadoop 配置文件。您需要根据您的 Hadoop 基础架构更改这些配置文件。

$ cd $HADOOP_HOME/etc/hadoop

为了用 Java 开发 Hadoop 程序，您必须通过将JAVA_HOME值替换为系统中 Java 的位置来重置hadoop-env.sh文件中的 Java 环境变量。

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://127.0.0.1:9000</value>
   </property>
</configuration>

hdfs-site.xml

hdfs-site.xml文件包含诸如复制数据的值、namenode 路径以及您希望存储 Hadoop 基础架构的本地文件系统的 datanode 路径等信息。

让我们假设以下数据。

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>

注意：在以上文件中，所有属性值都是用户定义的，您可以根据您的 Hadoop 基础架构进行更改。

yarn-site.xml

此文件用于将 yarn 配置到 Hadoop 中。打开 yarn-site.xml 文件，并将以下属性添加到此文件中的<configuration>和</configuration>标签之间。

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

验证 Hadoop 安装

验证 Hadoop 安装的步骤如下：

步骤 1 - Name Node 设置

使用命令“hdfs namenode -format”设置 namenode，如下所示。

$ 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
************************************************************/

步骤 2 - 验证 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]

步骤 3 - 验证 Yarn 脚本

以下命令用于启动 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

步骤 4 - 在浏览器上访问 Hadoop

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

https://127.0.0.1:50070

步骤 5 - 验证集群的所有应用程序

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

https://127.0.0.1:8088/

安装 HBase

我们可以以三种模式中的任何一种安装 HBase：独立模式、伪分布式模式和完全分布式模式。

以独立模式安装 HBase

使用“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/

以独立模式配置 HBase

在继续使用 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

以伪分布式模式安装 HBase

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

配置 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 实例地址。我们正在 8030 端口的 localhost 上运行 HDFS。

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

启动 HBase

配置完成后，浏览到 HBase 主目录并使用以下命令启动 HBase。

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

注意：启动 HBase 之前，请确保 Hadoop 正在运行。

检查 HDFS 中的 HBase 目录

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

启动和停止主服务器

使用“local-master-backup.sh”，您可以启动多达 10 个服务器。打开 HBase 的主目录，master 并执行以下命令启动它。

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

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

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

启动和停止 RegionServers

您可以使用以下命令从单个系统运行多个 region server。

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

要停止 region server，请使用以下命令。

$ .bin/local-regionservers.sh stop 3

 

启动 HBase Shell

成功安装 HBase 后，您可以启动 HBase Shell。以下是启动 HBase shell 的步骤序列。打开终端，并以超级用户身份登录。

启动 Hadoop 文件系统

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

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

启动 HBase

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

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

启动 HBase 主服务器

这将是相同的目录。启动它，如下所示。

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

启动 Region

启动 region server，如下所示。

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

启动 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 界面

要访问 HBase 的 Web 界面，请在浏览器中键入以下 URL。

https://127.0.0.1:60010

此界面列出了您当前正在运行的 Region server、备份主服务器和 HBase 表。

HBase Region server 和备份主服务器

HBase 表

设置 Java 环境

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

设置类路径

在继续编程之前，请在.bashrc文件中设置 HBase 库的类路径。在任何编辑器中打开.bashrc，如下所示。

$ gedit ~/.bashrc

在其中设置 HBase 库（HBase 中的 lib 文件夹）的类路径，如下所示。

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

这是为了防止在使用 Java API 访问 HBase 时出现“类未找到”异常。

HBase - Shell

本章介绍如何启动 HBase 交互式 shell，该 shell 附带 HBase。

HBase Shell

HBase 包含一个 shell，您可以使用它与 HBase 通信。HBase 使用 Hadoop 文件系统来存储其数据。它将拥有一个主服务器和 region server。数据存储将采用区域（表）的形式。这些区域将被分割并存储在 region server 中。

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

常规命令

• status - 提供 HBase 的状态，例如服务器数量。

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

• table_help - 提供表引用命令的帮助。

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

数据定义语言

这些是在 HBase 中操作表的命令。

• create - 创建表。

• list - 列出 HBase 中的所有表。

• disable - 禁用表。

• is_disabled - 验证表是否被禁用。

• enable - 启用表。

• is_enabled - 验证表是否已启用。

• describe - 提供表的描述。

• alter - 更改表。

• exists - 验证表是否存在。

• drop - 从 HBase 中删除表。

• drop_all - 删除与命令中给定的“正则表达式”匹配的表。

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

数据操纵语言

• put - 将单元格值放在特定表中特定行中的指定列中。

• get - 获取行或单元格的内容。

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

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

• scan - 扫描并返回表数据。

• count - 计数并返回表中的行数。

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

• Java 客户端 API - 在所有上述命令之前，Java 提供了一个客户端 API，可以通过编程实现 DML 功能、CRUD（创建检索更新删除）操作以及更多功能，在 org.apache.hadoop.hbase.client 包下。HTable Put 和Get 是此包中的重要类。

启动 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 - 常用命令

HBase中的常用命令包括status、version、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 - 管理员API

HBase是用Java编写的，因此它提供Java API来与HBase通信。Java API是与HBase通信的最快方式。以下是涵盖用于管理表的任务的参考Java Admin API。

类HBaseAdmin

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

方法和描述

类Descriptor

此类包含有关HBase表的信息，例如：

• 所有列族的描述符；
• 表是否是目录表；
• 表是否是只读的；
• memstore的最大大小；
• 何时应进行区域分割；
• 与其关联的协处理器等。

构造函数

方法和描述

HBase - 创建表

使用HBase Shell创建表

您可以使用create命令创建表，您必须在此处指定表名和列族名。在HBase shell中创建表的语法如下所示：

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

示例

以下是名为emp表的示例模式。它有两个列族：“个人数据”和“职业数据”。

您可以在HBase shell中创建此表，如下所示：

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

它将为您提供以下输出。

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

验证

您可以使用list命令验证表是否已创建，如下所示。在这里您可以看到已创建的emp表。

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

使用Java API创建表

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

步骤1：实例化HBaseAdmin

此类需要Configuration对象作为参数，因此最初实例化Configuration类并将此实例传递给HBaseAdmin。

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

步骤2：创建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);

步骤3：通过Admin执行

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

admin.createTable(table);

以下是通过admin创建表的完整程序。

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 - 列出表

使用HBase Shell列出表

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

hbase(main):001:0 > list

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

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

在这里您可以看到一个名为emp的表。

使用Java API列出表

请按照以下步骤使用Java API从HBase获取表的列表。

步骤 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();

步骤 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 - 禁用表

使用HBase Shell禁用表

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

以下是禁用表的语法：

disable ‘emp’

示例

以下是一个示例，显示如何禁用表。

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

验证

禁用表后，您仍然可以通过list和exists命令感知它的存在。您无法扫描它。它将为您提供以下错误。

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

使用Java API禁用表

要验证表是否已禁用，请使用isTableDisabled()方法；要禁用表，请使用disableTable()方法。这些方法属于HBaseAdmin类。请按照以下步骤禁用表。

步骤 1

实例化HBaseAdmin类，如下所示。

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

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

步骤 2

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

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

步骤 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 - 启用表

使用HBase Shell启用表

启用表的语法：

enable ‘emp’

示例

以下是一个启用表的示例。

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

验证

启用表后，扫描它。如果您可以看到模式，则您的表已成功启用。

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

使用Java API启用表

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

步骤1

实例化HBaseAdmin类，如下所示。

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

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

步骤 2

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

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

步骤 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

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

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是用于对现有表进行更改的命令。使用此命令，您可以更改列族的最大单元格数、设置和删除表范围运算符以及从表中删除列族。

更改列族的最大单元格数

以下是更改列族最大单元格数的语法：

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

表范围运算符

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

设置只读

以下是将表设为只读的语法：

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

删除表范围运算符

我们还可以删除表范围运算符。以下是从emp表中删除“MAX_FILESIZE”的语法：

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

删除列族

使用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

使用Java API添加列族

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

步骤 1

实例化HBaseAdmin类。

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

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

步骤 2

addColumn()方法需要表名和HColumnDescriptor类的一个对象。因此，实例化HColumnDescriptor类。HColumnDescriptor的构造函数反过来需要要添加的列族名。这里我们将名为“contactDetails”的列族添加到现有的“employee”表中。

// Instantiating columnDescriptor object

HColumnDescriptor columnDescriptor = new
HColumnDescriptor("contactDetails");

步骤 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

使用Java API删除列族

可以使用HBaseAdmin类的deleteColumn()方法从表中删除列族。请按照以下步骤将列族添加到表中。

步骤1

实例化HBaseAdmin类。

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

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

步骤2

使用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 - 判断表是否存在

使用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

使用Java API验证表的存在

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

步骤 1

Instantiate the HBaseAdimn class

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

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

步骤 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 - 删除表

使用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.*’ 

注意：删除表之前，必须先禁用它。

示例

假设有名为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

使用Java API删除表

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

步骤 1

实例化HBaseAdmin类。

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

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

步骤 2

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

admin.disableTable("emp1");

步骤 3

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

admin.deleteTable("emp12");

下面是完整的Java程序，用于删除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 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 - 关闭

exit

通过键入exit命令退出shell。

hbase(main):021:0> exit

停止HBase

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

./bin/stop-hbase.sh

使用Java API停止HBase

可以使用HBaseAdmin类的shutdown()方法关闭HBase。请按照以下步骤关闭HBase。

步骤 1

实例化HbaseAdmin类。

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

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

步骤 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 - 客户端API

本章介绍用于对HBase表执行CRUD操作的HBase Java客户端API。HBase是用Java编写的，并且具有Java原生API。因此，它提供了对数据操作语言（DML）的编程访问。

HBase Configuration类

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

方法和描述

HTable类

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

构造函数

方法和描述

Put类

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

构造函数

方法

Get类

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

构造函数

方法

Delete类

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

构造函数

方法

Result类

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

构造函数

方法

HBase - 创建数据

使用HBase Shell插入数据

本章演示如何在HBase表中创建数据。要在HBase表中创建数据，可以使用以下命令和方法：

• put命令，

• Put类的add()方法，以及

• HTable类的put()方法。

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

使用put命令，可以将行插入表中。其语法如下：

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

插入第一行

让我们将第一行值插入到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 

使用Java API插入数据

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

步骤1：实例化Configuration类

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

Configuration conf = HbaseConfiguration.create();

步骤2：实例化HTable类

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

HTable hTable = new HTable(conf, tableName);

步骤3：实例化Put类

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

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

步骤4：插入数据

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

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

步骤5：保存表中的数据

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

hTable.put(p); 

步骤6：关闭HTable实例

在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 - 更新数据

使用HBase Shell更新数据

可以使用put命令更新现有单元格的值。为此，只需遵循相同的语法，并像下面所示那样提及您的新值。

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

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

示例

假设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”的员工的城市值更新为“Delhi”。

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

更新后的表如下所示，您可以看到Raju的城市已更改为“Delhi”。

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

使用Java API更新数据

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

步骤1：实例化Configuration类

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

Configuration conf = HbaseConfiguration.create();

步骤2：实例化HTable类

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

HTable hTable = new HTable(conf, tableName);

步骤3：实例化Put类

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

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

步骤4：更新现有单元格

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"));

步骤5：保存表中的数据

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

hTable.put(p); 

步骤6：关闭HTable实例

在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 - 读取数据

使用HBase Shell读取数据

get命令和HTable类的get()方法用于从HBase中的表读取数据。使用get命令，您可以一次获取一行数据。其语法如下：

get ’<table name>’,’row1’

示例

以下示例演示如何使用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

读取特定列

以下是使用get方法读取特定列的语法。

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

示例

以下是读取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

使用Java API读取数据

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

步骤1：实例化Configuration类

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

Configuration conf = HbaseConfiguration.create();

步骤2：实例化HTable类

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

HTable hTable = new HTable(conf, tableName);

步骤3：实例化Get类

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

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

步骤4：读取数据

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

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

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

get.addFamily(personal) 

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

get.addColumn(personal, name) 

步骤5：获取结果

通过将您的Get类实例传递到HTable类的get方法来获取结果。此方法返回Result类对象，其中包含请求的结果。以下是get()方法的使用方法。

Result result = table.get(g);  

步骤6：从Result实例读取值

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命令，您可以删除表中的特定单元格。delete命令的语法如下：

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

示例

这是一个删除特定单元格的示例。在这里，我们正在删除salary。

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

删除表中的所有单元格

使用“deleteall”命令，您可以删除一行中的所有单元格。“deleteall”命令的语法如下。

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

示例

这是一个“deleteall”命令的示例，我们在这里删除emp表中row1的所有单元格。

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

使用Java API删除数据

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

步骤1：实例化Configuration类

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

Configuration conf = HbaseConfiguration.create();

步骤2：实例化HTable类

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

HTable hTable = new HTable(conf, tableName); 

步骤3：实例化Delete类

通过传递要删除行的rowid（字节数组格式）来实例化Delete类。您还可以将timestamp和Rowlock传递给此构造函数。

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

步骤4：选择要删除的数据

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

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

步骤5：删除数据

通过将delete实例传递到HTable类的delete()方法来删除所选数据，如下所示。

table.delete(delete); 

步骤6：关闭HTable实例

删除数据后，关闭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 - 扫描

使用HBase Shell扫描

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

scan ‘<table name>’ 

示例

以下示例演示如何使用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

使用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命令计算表的行数。其语法如下：

count ‘<table name>’ 

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

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

截断

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

hbase> truncate 'table name'

示例

以下是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 - 安全性

我们可以授予和撤销HBase中用户的权限。出于安全目的，有三个命令：grant、revoke和user_permission。

grant

grant命令向特定用户授予对表的特定权限，例如读取、写入、执行和管理。grant命令的语法如下：

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

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

• R - 代表读取权限。
• W - 代表写入权限。
• X - 代表执行权限。
• C - 代表创建权限。
• 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'