HBase 常用操作

￡神魔★判官ぃ 2022-06-05 07:48 470阅读 0赞

![Center][]

hbase只支持行级事务，不支持多行事务。

![Center 1][]

进入shell:hbase shell:

![Center 2][]

![Center 3][]

![Center 4][]

![Center 5][]

![Center 6][]

![Center 7][]

配置完分布式zk后：

![Center 8][]

单启Hmaster：hbase-daemon.sh start master

![Center 9][]

![Center 10][]

![Center 11][]

![Center 12][]

![Center 13][]

![Center 14][]

![Center 15][]![Center 15][]

![Center 16][]

HFile默认是十亿字节进行拆分                           hbase是版本化数据库

![Center 17][]  
![Center 18][]

![Center 19][]

![Center 20][]

缓冲区默认大小：2M       也可用API的HTable.setWriteBufferSize();

![Center 21][]

![Center 22][]

![Center 23][]

![Center 24][]

![Center 25][]

上述代码运行报错，原因：scan在扫描的时候返回一个iterator,而这个iterator的cursor是指向一个单元格的

Cell：在HBase表中，是由rowkey + (colomn family:colomn qualifier) + version来标识一个cell，用户保存的具体数据是保存在这个cell中的，它的值时byte\[\]类型的，需要在客户端将之改为需要的类型。

所以要想得到下一列，每次都要进行迭代。然而在hbase的存储模型中，列名是排序的，所以第一列得到的是age的值，上面写的是no，所以出现了空指针异常。

hbase不能直接查询以下操作：

![Center 26][]

得采用过虐器filter

![Center 27][]

\-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

![Center 28][]

![Center 29][]

![Center 30][]

没有value,value长度为0

![Center 31][]

![Center 32][]

![Center 33][]

![Center 34][]

用户可以通过继承FilterBase来定义自己的过滤器。maven clean package -DskipTests打成jar包分发到hbase/lib下。

![Center 35][]

![Center 36][]

![Center 37][]

![Center 38][]

![Center 39][]

![Center 40][]

优先级决定了处理器执行的先后顺序，优先级相同，通过序号决定。                                               coprocessorHost:对协处理器提供了一些公共的运行时服务

![Center 41][]

![Center 42][]

配置文件写的是系统或者自定义的协处理器类的全限定名称。

![Center 43][]

![Center 44][]

log()是自定义的写入日志的方法

![Center 45][]

\---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

![Center 46][]

放在  META-INF/persisience.xml

![Center 47][]

"ns1:t1"对应的是表名

创建实体类：

![Center 48][]

![Center 49][]

![Center 50][]

![Center 51][]

![Center 52][]

![Center 53][]

![Center 54][]

![Center 55][]

move后的第二个参数为   ‘host，port，startcode’

compact:物理上的，把磁盘上的存储文件合并在一起

![Center 56][]

assign 是没有force的 unassign可以设置force       指定区域名或者区域编码名    下线依然能够提供服务    上线下线类似于move

hbase  MR   wordcount：hbase作为数据来源，hdfs作为数据输出目的地：

![Center 57][]

![Center 58][]

![Center 59][]

![Center 60][]

![Center 61][]

![Center 62][]

![Center 63][]

![Center 64][]

![Center 65][]

![Center 66][]

hbase作为输出路径：

![Center 67][]

![Center 68][]

内存优化：Java -X

![Center 69][]

使用压缩必须保证所有节点都安装了所用压缩类类库

![Center 70][]

![Center 71][]

![Center 72][]后面的3是整个表拆分的区域

也可以用$hbase>create 'ns1:t1',splits=>\{'10','20','30'\}

![Center 73][]一般我们不关闭写前日志

![Center 74][]

**3. Observer协处理器的实现**

相对来说Observer的实现来的简单点，只需要实现服务端代码逻辑即可。通过实现一个RegionserverObserver来加深了解。

所要实现的功能：

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

假定某个表有A和B两个列--------------------------------便于后续描述我们称之为coprocessor_table
    1. 当我们向A列插入数据的时候通过协处理器像B列也插入数据。
    2.在读取数据的时候只允许客户端读取B列数据而不能读取A列数据。换句话说A列是只写 B列是只读的。（为了简单起见，用户在读取数据的时候需要制定列名）
    3. A列值必须是整数，换句话说B列值也自然都是整数
    
    4.当删除操作的时候不能指定删除B列
    5.当删除A列的时候同时需要删除B列
    6.对于其他列的删除不做检查

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

在上述功能点确定后，我们就要开始实现这两个功能。好在HBase API中有BaseRegionObserver，这个类已经帮助我们实现了大部分的默认实现，我们只要专注于业务上的方法重载即可。

代码框架：

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

public class 协处理器类名称 extends BaseRegionObserver {
        private static final Log LOG = LogFactory.getLog(协处理器类名称.class);
        private RegionCoprocessorEnvironment env = null;// 协处理器是运行于region中的，每一个region都会加载协处理器
        // 这个方法会在regionserver打开region时候执行（还没有真正打开）
        @Override
        public void start(CoprocessorEnvironment e) throws IOException {
            env = (RegionCoprocessorEnvironment) e;
        }
    
        // 这个方法会在regionserver关闭region时候执行（还没有真正关闭）
        @Override
        public void stop(CoprocessorEnvironment e) throws IOException {
            // nothing to do here
        }
    
        /**
         * 出发点，比如可以重写prePut postPut等方法，这样就可以在数据插入前和插入后做逻辑控制了。
         */
        @Override

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

业务代码实现 ：

根据上述需求和代码框架，具体逻辑实现如下。

*  在插入需要做检查所以重写了prePut方法
 *  在删除前需要做检查所以重写了preDelete方法

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

public class MyRegionObserver extends BaseRegionObserver {
        private static final Log LOG = LogFactory.getLog(MyRegionObserver.class);
        
        private RegionCoprocessorEnvironment env = null;
        // 设定只有F族下的列才能被操作，且A列只写，B列只读。的语言
        private static final String FAMAILLY_NAME = "F";
        private static final String ONLY_PUT_COL = "A";
        private static final String ONLY_READ_COL = "B";
    
        // 协处理器是运行于region中的，每一个region都会加载协处理器
        // 这个方法会在regionserver打开region时候执行（还没有真正打开）
        @Override
        public void start(CoprocessorEnvironment e) throws IOException {
            env = (RegionCoprocessorEnvironment) e;
        }
    
        // 这个方法会在regionserver关闭region时候执行（还没有真正关闭）
        @Override
        public void stop(CoprocessorEnvironment e) throws IOException {
            // nothing to do here
        }
    
        /**
         * 需求 1.不允许插入B列 2.只能插入A列 3.插入的数据必须为整数 4.插入A列的时候自动插入B列
         */
        @Override
        public void prePut(final ObserverContext<RegionCoprocessorEnvironment> e,
                final Put put, final WALEdit edit, final Durability durability)
                throws IOException {
    
            // 首先查看单个put中是否有对只读列有写操作
            List<Cell> cells = put.get(Bytes.toBytes(FAMAILLY_NAME),
                    Bytes.toBytes(ONLY_READ_COL));
            if (cells != null && cells.size() != 0) {
                LOG.warn("User is not allowed to write read_only col.");
                throw new IOException("User is not allowed to write read_only col.");
            }
    
            // 检查A列
            cells = put.get(Bytes.toBytes(FAMAILLY_NAME),
                    Bytes.toBytes(ONLY_PUT_COL));
            if (cells == null || cells.size() == 0) {
                // 当不存在对于A列的操作的时候则不做任何的处理，直接放行即可
                LOG.info("No A col operation, just do it.");
                return;
            }
    
            // 当A列存在的情况下在进行值得检查，查看是否插入了整数
            byte[] aValue = null;
            for (Cell cell : cells) {
                try {
                    aValue = CellUtil.cloneValue(cell);
                    LOG.warn("aValue = " + Bytes.toString(aValue));
                    Integer.valueOf(Bytes.toString(aValue));
                } catch (Exception e1) {
                    LOG.warn("Can not put un number value to A col.");
                    throw new IOException("Can not put un number value to A col.");
                }
            }
    
            // 当一切都ok的时候再去构建B列的值，因为按照需求，插入A列的时候需要同时插入B列
            LOG.info("B col also been put value!");
            put.addColumn(Bytes.toBytes(FAMAILLY_NAME),
                    Bytes.toBytes(ONLY_READ_COL), aValue);
        }
    
        /**
         * 需求 1.不能删除B列 2.只能删除A列 3.删除A列的时候需要一并删除B列
         */
        @Override
        public void preDelete(
                final ObserverContext<RegionCoprocessorEnvironment> e,
                final Delete delete, final WALEdit edit, final Durability durability)
                throws IOException {
    
            // 首先查看是否对于B列进行了指定删除
            List<Cell> cells = delete.getFamilyCellMap().get(
                    Bytes.toBytes(FAMAILLY_NAME));
            if (cells == null || cells.size() == 0) {
                // 如果客户端没有针对于FAMAILLY_NAME列族的操作则不用关心，让其继续操作即可。
                LOG.info("NO F famally operation ,just do it.");
                return;
            }
    
            // 开始检查F列族内的操作情况
            byte[] qualifierName = null;
            boolean aDeleteFlg = false;
            for (Cell cell : cells) {
                qualifierName = CellUtil.cloneQualifier(cell);
    
                // 检查是否对B列进行了删除，这个是不允许的
                if (Arrays.equals(qualifierName, Bytes.toBytes(ONLY_READ_COL))) {
                    LOG.info("Can not delete read only B col.");
                    throw new IOException("Can not delete read only B col.");
                }
    
                // 检查是否存在对于A队列的删除
                if (Arrays.equals(qualifierName, Bytes.toBytes(ONLY_PUT_COL))) {
                    LOG.info("there is A col in delete operation!");
                    aDeleteFlg = true;
                }
            }
    
            // 如果对于A列有删除，则需要对B列也要删除
            if (aDeleteFlg)
            {
                LOG.info("B col also been deleted!");
                delete.addColumn(Bytes.toBytes(FAMAILLY_NAME), Bytes.toBytes(ONLY_READ_COL));
            }
        }
    
    }

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

**4. Observer协处理器上传加载**

完成实现后需要将协处理器类打包成jar文件，对于协处理器的加载通常有三种方法：

1.配置文件加载：即通过hbase-site.xml文件配置加载，一般这样的协处理器是系统级别的，全局的协处理器，如权限控制等检查。

2.shell加载：可以通过alter命令来对表进行scheme进行修改来加载协处理器。

3.通过API代码实现：即通过API的方式来加载协处理器。

上述加载方法中，1，3都需要将协处理器jar文件放到集群的hbase的classpath中。而2方法只需要将jar文件上传至集群环境的hdfs即可。

下面我们只介绍如何通过2方法进行加载。

步骤1：通过如下方法创建表

hbase(main):001:0> create 'coprocessor_table','F'
    0 row(s) in 2.7570 seconds
    
    => Hbase::Table - coprocessor_table

步骤2：通过alter命令将协处理器加载到表中

alter 'coprocessor_table' , METHOD =>'table_att','coprocessor'=>'hdfs://ns1/testdata/Test-HBase-Observer.jar|cn.com.newbee.feng.MyRegionObserver|1001'

其中：'coprocessor'=>'jar文件在hdfs上的绝对路径|协处理器主类|优先级|协处理器参数

上述协处理器并没有参数，所以未给出参数，对于协处理器的优先级不在此做讨论。

步骤3：检查协处理器的加载

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

hbase(main):021:0> describe 'coprocessor_table'
    Table coprocessor_table is ENABLED                                              
    coprocessor_table, {TABLE_ATTRIBUTES => {coprocessor$1 => 'hdfs://ns1/testdata/T
    est-HBase-Observer.jar|cn.com.newbee.feng.MyRegionObserver|1001'}               
    COLUMN FAMILIES DESCRIPTION                                                     
    {NAME => 'F', DATA_BLOCK_ENCODING => 'NONE', BLOOMFILTER => 'ROW', REPLICATION_S
    COPE => '0', VERSIONS => '1', COMPRESSION => 'NONE', MIN_VERSIONS => '0', TTL =>
     'FOREVER', KEEP_DELETED_CELLS => 'FALSE', BLOCKSIZE => '65536', IN_MEMORY => 'f
    alse', BLOCKCACHE => 'true'}                                                    
    1 row(s) in 0.0300 seconds

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

可以看到协处理器被表成功加载，其实内部是将update所有此表的region去加载协处理器的。

**5. Observer协处理器测试**

**　　**经过上述代码完成和加载完成后我们进行简单的协处理器测试，由于Observer并不需要我们去定制客户端代码，所以我们可以直接通过shell命令环境来测试。

用例1： 正常插入A列

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

hbase(main):024:0> scan 'coprocessor_table'
    ROW                   COLUMN+CELL                                               
    0 row(s) in 0.0100 seconds
    
    hbase(main):025:0> put 'coprocessor_table','row1','F:A',123
    0 row(s) in 0.0210 seconds
    
    hbase(main):026:0> scan 'coprocessor_table'
    ROW                   COLUMN+CELL                                               
     row1                 column=F:A, timestamp=1469838240645, value=123            
     row1                 column=F:B, timestamp=1469838240645, value=123            
    1 row(s) in 0.0180 seconds

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

结果：B列也被插入，OK

用例2：插入A列，但是值不为整数

hbase(main):027:0> put 'coprocessor_table','row1','F:A','cc'
    
    ERROR: Failed 1 action: IOException: 1 time,

结果：插入失败，服务端报如下错误，OK

2016-07-29 20:25:45,406 WARN  [B.defaultRpcServer.handler=3,queue=0,port=60020] feng.MyRegionObserver: Can not put un number value to A col.

用例3：插入B列

hbase(main):028:0> put 'coprocessor_table','row1','F:B',123
    
    ERROR: Failed 1 action: IOException: 1 time,

结果：插入失败，服务器报如下错误，OK

2016-07-29 20:27:13,342 WARN  [B.defaultRpcServer.handler=20,queue=2,port=60020] feng.MyRegionObserver: User is not allowed to write read_only col.

用例4：删除B列

hbase(main):029:0> delete 'coprocessor_table','row1','F:B'
    
    ERROR: java.io.IOException: Can not delete read only B col.

结果：删除失败，OK

用例4：删除A列

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

hbase(main):030:0> scan 'coprocessor_table'
    ROW                   COLUMN+CELL                                                
     row1                 column=F:A, timestamp=1469838240645, value=123             
     row1                 column=F:B, timestamp=1469838240645, value=123             
    1 row(s) in 0.0230 seconds
    
    hbase(main):031:0> delete 'coprocessor_table','row1','F:A'
    0 row(s) in 0.0060 seconds
    
    hbase(main):032:0> scan 'coprocessor_table'
    ROW                   COLUMN+CELL                                                
    0 row(s) in 0.0070 seconds

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

结果：A列和B列同时被删除了。

如果想详细了解hbase的安装：http://abloz.com/hbase/book.html 和官网http://hbase.apache.org/

##  ##

1.  快速单击安装

在单机安装Hbase的方法。会引导你通过shell创建一个表，插入一行，然后删除它，最后停止Hbase。只要10分钟就可以完成以下的操作。

### 1.1下载解压最新版本 ###

### 选择一个 [Apache 下载镜像][Apache]：[http://www.apache.org/dyn/closer.cgi/hbase/][Apache]，下载 HBase Releases. 点击 stable目录，然后下载后缀为 .tar.gz 的文件; 例如 hbase-0.90.4.tar.gz. ###

后面需要安装集群，整合到hadoop，所以注意选择与hadoop对应的版本：

选择 Hadoop 版本对HBase部署很关键。下表显示不同HBase支持的Hadoop版本信息。基于HBase版本，应该选择合适的Hadoop版本。我们没有绑定 Hadoop 发行版选择。可以从Apache使用 Hadoop 发行版，或了解一下Hadoop发行商产品： [http://wiki.apache.org/hadoop/Distributions%20and%20Commercial%20Support][http_wiki.apache.org_hadoop_Distributions_20and_20Commercial_20Support]

Table 2.1. Hadoop version support matrix

<table> 
 <thead> 
  <tr> 
   <th style="text-align:left;">&nbsp;</th> 
   <th style="text-align:left;">HBase-0.92.x</th> 
   <th style="text-align:left;">HBase-0.94.x</th> 
   <th style="text-align:left;">HBase-0.96</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Hadoop-0.20.205</td> 
   <td>S</td> 
   <td>X</td> 
   <td>X</td> 
  </tr> 
  <tr> 
   <td>Hadoop-0.22.x</td> 
   <td>S</td> 
   <td>X</td> 
   <td>X</td> 
  </tr> 
  <tr> 
   <td>Hadoop-1.0.x</td> 
   <td>S</td> 
   <td>S</td> 
   <td>S</td> 
  </tr> 
  <tr> 
   <td>Hadoop-1.1.x</td> 
   <td>NT</td> 
   <td>S</td> 
   <td>S</td> 
  </tr> 
  <tr> 
   <td>Hadoop-0.23.x</td> 
   <td>X</td> 
   <td>S</td> 
   <td>NT</td> 
  </tr> 
  <tr> 
   <td>Hadoop-2.x</td> 
   <td>X</td> 
   <td>S</td> 
   <td>S</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>S = supported and tested,支持</td> 
  </tr> 
  <tr> 
   <td>X = not supported,不支持</td> 
  </tr> 
  <tr> 
   <td>NT = not tested enough.可以运行但测试不充分</td> 
  </tr> 
 </tbody> 
</table>

由于 HBase 依赖 Hadoop，它配套发布了一个Hadoop jar 文件在它的 lib 下。该套装jar仅用于独立模式。在分布式模式下，Hadoop版本必须和HBase下的版本一致。用你运行的分布式Hadoop版本jar文件替换HBase lib目录下的Hadoop jar文件，以避免版本不匹配问题。确认替换了集群中所有HBase下的jar文件。Hadoop版本不匹配问题有不同表现，但看起来都像挂掉了。

安装：

$ tar xfz hbase-0.90.4.tar.gz  
$ cd hbase-0.90.4

现在你已经可以启动Hbase了。但是你可能需要先编辑 conf/hbase-site.xml 去配置hbase.rootdir，来选择Hbase将数据写到哪个目录 .

单机配置，只需要如下配置hbase-site.xml：

\[html\]  [view plain][]  [copy][view plain]

1.  **<?****xml** version="1.0"**?>**  
2.  **<?****xml-stylesheet** type="text/xsl" href="configuration.xsl"**?>**  
3.  **<****configuration****>**  
4.    **<****property****>**  
5.      **<****name****>**hbase.rootdir**</****name****>**  
6.      **<****value****>**file:///DIRECTORY/hbase**</****value****>**  
7.    **</****property****>**  
8.  **</****configuration****>**

将 DIRECTORY 替换成你期望写文件的目录. 默认 hbase.rootdir 是指向 /tmp/hbase-$\{user.name\} ，也就说你会在重启后丢失数据(重启的时候操作系统会清理/tmp目录)

## 1.2. 启动 HBase ##

现在启动Hbase:

$ ./bin/start-hbase.sh

starting Master, logging to logs/hbase-user-master-example.org.out

现在你运行的是单机模式的Hbaes。所以的服务都运行在一个JVM上，包括Hbase和Zookeeper。Hbase的日志放在`logs`目录,当你启动出问题的时候，可以检查这个日志。

## 1.3. Hbase Shell 练习 ##

用shell连接你的Hbase

$ ./bin/hbase shell

HBase Shell; enter 'help<RETURN>' for list of supported commands.

Type "exit<RETURN>" to leave the HBase Shell

Version: 0.90.0, r1001068, Fri Sep 24 13:55:42 PDT 2010

hbase(main):001:0>

输入 help 然后 <RETURN> 可以看到一列shell命令。这里的帮助很详细，要注意的是表名，行和列需要加引号。

创建一个名为 `test` 的表，这个表只有一个column family 为 `cf`。可以列出所有的表来检查创建情况，然后插入些值。

hbase(main):003:0> create 'test', 'cf'

0 row(s) in 1.2200 seconds

hbase(main):003:0> list 'table'

test

1 row(s) in 0.0550 seconds

hbase(main):004:0> put 'test', 'row1', 'cf:a', 'value1'

0 row(s) in 0.0560 seconds

hbase(main):005:0> put 'test', 'row2', 'cf:b', 'value2'

0 row(s) in 0.0370 seconds

hbase(main):006:0> put 'test', 'row3', 'cf:c', 'value3'

0 row(s) in 0.0450 seconds

以上我们分别插入了3行。第一个行key为`row1`, 列为 `cf:a`， 值是 `value1`。Hbase中的列是由 column family前缀和列的名字组成的，以冒号间隔。例如这一行的列名就是`a`.

检查插入情况.

Scan这个表，操作如下

hbase(main):007:0> scan 'test'

ROW        COLUMN+CELL

row1       column=cf:a, timestamp=1288380727188, value=value1

row2       column=cf:b, timestamp=1288380738440, value=value2

row3       column=cf:c, timestamp=1288380747365, value=value3

3 row(s) in 0.0590 seconds

Get一行，操作如下

hbase(main):008:0> get 'test', 'row1'

COLUMN      CELL

cf:a        timestamp=1288380727188, value=value1

1 row(s) in 0.0400 seconds

disable 再 drop 这张表，可以清除你刚刚的操作

hbase(main):012:0> disable 'test'

0 row(s) in 1.0930 seconds

hbase(main):013:0> drop 'test'

0 row(s) in 0.0770 seconds

关闭shell

hbase(main):014:0> exit

## 1.4. 停止 HBase ##

运行停止脚本来停止HBase.

$ ./bin/stop-hbase.sh

stopping hbase...............

##  ##

2.  Hbase集群安装前注意

1）  Java：（hadoop已经安装了）

2）  [Hadoop 0.20.x][] / Hadoop-2.x 已经正确安装，并且可以启动 HDFS 系统, 可参考的Hadoop安装文档：Hadoop集群配置（最全面总结）[http://blog.csdn.net/hguisu/article/details/7237395][http_blog.csdn.net_hguisu_article_details_7237395]

3）  ssh 必须安装ssh ， sshd 也必须运行，这样Hadoop的脚本才可以远程操控其他的Hadoop和Hbase进程。ssh之间必须都打通，不用密码都可以登录，详细方法可以        Google一下 ("ssh passwordless login").

4）  NTP：集群的时钟要保证基本的一致。稍有不一致是可以容忍的，但是很大的不一致会 造成奇怪的行为。 运行 [NTP][] 或者其他什么东西来同步你的时间.

如果你查询的时候或者是遇到奇怪的故障，可以检查一下系统时间是否正确!

设置集群各个节点时钟：date -s “2012-02-13 14:00:00”

`5）  ``ulimit` 和 `nproc:`

Base是数据库，会在同一时间使用很多的文件句柄。大多数linux系统使用的默认值1024是不能满足的，会导致FAQ: Why do I see "java.io.IOException...(Too manyopen files)" in my logs?异常。还可能会发生这样的异常

2010-04-06 03:04:37,542 INFO org.apache.hadoop.hdfs.DFSClient: ExceptionincreateBlockOutputStream java.io.EOFException

2010-04-06 03:04:37,542 INFO org.apache.hadoop.hdfs.DFSClient:Abandoning block blk\_-6935524980745310745\_1391901

所以你需要修改你的最大文件句柄限制。可以设置到10k. 你还需要修改 hbase 用户的 nproc，如果过低会造成 OutOfMemoryError异常。 \[2\] \[3\].

需要澄清的，这两个设置是针对操作系统的，不是Hbase本身的。有一个常见的错误是Hbase运行的用户，和设置最大值的用户不是一个用户。在Hbase启动的时候，第一行日志会现在ulimit信息，所以你最好检查一下。

可以先查看当前用户 ulimit：

ulimit -n

设置`ulimit:`

`     `如果你使用的是Ubuntu,你可以这样设置:

在文件 /etc/security/limits.conf 添加一行，如:

hadoop  -       nofile 32768

可以把 hadoop 替换成你运行Hbase和Hadoop的用户。如果你用两个用户，你就需要配两个。还有配nproc hard 和 softlimits. 如:

hadoop soft/hard nproc 32000

在 /etc/pam.d/common-session 加上这一行:

session required pam\_limits.so

否则在 /etc/security/limits.conf上的配置不会生效.

还有注销再登录，这些配置才能生效!

7 ）修改Hadoop HDFS Datanode同时处理文件的上限：`dfs.datanode.max.xcievers`

一个 Hadoop HDFS Datanode 有一个同时处理文件的上限. 这个参数叫 xcievers (Hadoop的作者把这个单词拼错了). 在你加载之前，先确认下你有没有配置这个文件conf/hdfs-site.xml里面的xceivers参数，至少要有4096:

<name>dfs.datanode.max.xcievers</name>

</property>

对于HDFS修改配置要记得重启.

如果没有这一项配置，你可能会遇到奇怪的失败。你会在Datanode的日志中看到xcievers exceeded，但是运行起来会报 missing blocks错误。例如: 02/12/1220:10:31 INFO hdfs.DFSClient: Could not obtain blockblk\_XXXXXXXXXXXXXXXXXXXXXX\_YYYYYYYY from any node: java.io.IOException: No livenodes contain current block. Will get new block locations from namenode andretry...

8）继承hadoop安装的说明：

每个机子/etc/hosts

10.64.56.74  node2 （master）

10.64.56.76  node1  （slave）

10.64.56.77  node3 （slave）

9) 继续使用hadoop用户安装

Chown –R hadoop /usr/local/hbase

##  ##

3.  分布式模式配置

## 3.1配置`conf/hbase-env.sh` ##

\# exportJAVA\_HOME=/usr/java/jdk1.6.0/

exportJAVA\_HOME=/usr/lib/jvm/java-6-sun-1.6.0.26

\# Tell HBase whether it should manage it'sown instance of Zookeeper or not.

export HBASE\_MANAGES\_ZK=true

不管是什么模式，你都需要编辑 `conf/hbase-env.sh`来告知Hbase java的安装路径.在这个文件里你还可以设置Hbase的运行环境，诸如 heapsize和其他 JVM有关的选项, 还有Log文件地址，等等. 设置 `JAVA_HOME`指向 java安装的路径.

一个分布式运行的Hbase依赖一个zookeeper集群。所有的节点和客户端都必须能够访问zookeeper。默认的情况下Hbase会管理一个zookeep集群。这个集群会随着Hbase的启动而启动。当然，你也可以自己管理一个zookeeper集群，但需要配置Hbase。你需要修改`conf/hbase-env.sh`里面的`HBASE_MANAGES_ZK` 来切换。这个值默认是true的，作用是让Hbase启动的时候同时也启动zookeeper.

让Hbase使用一个现有的不被Hbase托管的Zookeep集群，需要设置 `conf/hbase-env.sh`文件中的`HBASE_MANAGES_ZK` 属性为 false

\# Tell HBase whether it should manage it's own instanceof Zookeeper or not.

exportHBASE\_MANAGES\_ZK=false

## 3.2 配置conf/hbase-site.xml ##

\[html\]  [view plain][]  [copy][view plain]

1.  **<****configuration****>**  
2.    
3.      **<****property****>**  
4.    
5.      **<****name****>**hbase.rootdir**</****name****>**  
6.    
7.      **<****value****>**hdfs://node1:49002/hbase**</****value****>**  
8.    
9.      **<****description****>**The directory shared byRegionServers.  
10.   
11.     **</****description****>**  
12.   
13.   **</****property****>**  
14.   
15.   **<****property****>**  
16.   
17.     **<****name****>**hbase.cluster.distributed**</****name****>**  
18.   
19.     **<****value****>**true**</****value****>**  
20.   
21.     **<****description****>**The mode the clusterwill be in. Possible values are  
22.   
23.       false: standalone and pseudo-distributedsetups with managed Zookeeper  
24.   
25.       true: fully-distributed with unmanagedZookeeper Quorum (see hbase-env.sh)  
26.   
27.     **</****description****>**  
28.   
29.   **</****property****>**  
30.   
31.    
32.   
33.     **<****property****>**  
34.   
35.       **<****name****>**hbase.zookeeper.property.clientPort**</****name****>**  
36.   
37.       **<****value****>**2222**</****value****>**  
38.   
39.       **<****description****>**Property fromZooKeeper's config zoo.cfg.  
40.   
41.       The port at which the clients willconnect.  
42.   
43.       **</****description****>**  
44.   
45.     **</****property****>**  
46.   
47.     **<****property****>**  
48.   
49.       **<****name****>**hbase.zookeeper.quorum**</****name****>**  
50.   
51.       **<****value****>**node1,node2,node3**</****value****>**  
52.   
53.       **<****description****>**Comma separated listof servers in the ZooKeeper Quorum.  
54.   
55.       For example,"host1.mydomain.com,host2.mydomain.com,host3.mydomain.com".  
56.   
57.       By default this is set to localhost forlocal and pseudo-distributed modes  
58.   
59.       of operation. For a fully-distributedsetup, this should be set to a full  
60.   
61.       list of ZooKeeper quorum servers. IfHBASE\_MANAGES\_ZK is set in hbase-env.sh  
62.   
63.       this is the list of servers which we willstart/stop ZooKeeper on.  
64.   
65.       **</****description****>**  
66.   
67.     **</****property****>**  
68.   
69.     **<****property****>**  
70.   
71.       **<****name****>**hbase.zookeeper.property.dataDir**</****name****>**  
72.   
73.       **<****value****>**/home/hadoop/zookeeper**</****value****>**  
74.   
75.       **<****description****>**Property fromZooKeeper's config zoo.cfg.  
76.   
77.       The directory where the snapshot isstored.  
78.   
79.       **</****description****>**  
80.   
81.     **</****property****>**  
82.   
83.   **</****configuration****>**

要想运行完全分布式模式，加一个属性 `hbase.cluster.distributed` 设置为 `true` 然后把 `hbase.rootdir` 设置为HDFS的NameNode的位置。 例如，你的namenode运行在node1，端口是49002 你期望的目录是 `/hbase`,使用如下的配置：hdfs://node1:49002/hbase

hbase.rootdir：这个目录是region server的共享目录，用来持久化Hbase。URL需要是'完全正确'的，还要包含文件系统的scheme。例如，要表示hdfs中的'/hbase'目录，namenode 运行在node1的49002端口。则需要设置为hdfs://node1:49002/hbase。默认情况下Hbase是写到/tmp的。不改这个配置，数据会在重启的时候丢失。默认: file:///tmp/hbase-$\{user.name\}/hbase

hbase.cluster.distributed ：Hbase的运行模式。false是单机模式，true是分布式模式。若为false,Hbase和Zookeeper会运行在同一个JVM里面。

默认: false

在hbase-site.xml配置zookeeper：

当Hbase管理zookeeper的时候，你可以通过修改zoo.cfg来配置zookeeper，

一个更加简单的方法是在 conf/hbase-site.xml里面修改zookeeper的配置。Zookeeer的配置是作为property写在 hbase-site.xml里面的。

对于zookeepr的配置，你至少要在 hbase-site.xml中列出zookeepr的ensemble servers，具体的字段是 hbase.zookeeper.quorum. 该这个字段的默认值是 localhost，这个值对于分布式应用显然是不可以的. (远程连接无法使用)。

hbase.zookeeper.property.clientPort：ZooKeeper的zoo.conf中的配置。 客户端连接的端口。

**hbase.zookeeper.quorum**：Zookeeper集群的地址列表，用逗号分割。例如："host1.mydomain.com,host2.mydomain.com,host3.mydomain.com".默认是localhost,是给伪分布式用的。要修改才能在完全分布式的情况下使用。如果在hbase-env.sh设置了HBASE\_MANAGES\_ZK，这些ZooKeeper节点就会和Hbase一起启动。

默认: localhost

运行一个zookeeper也是可以的，但是在生产环境中，你最好部署3，5，7个节点。部署的越多，可靠性就越高，当然只能部署奇数个，偶数个是不可以的。你需要给每个zookeeper 1G左右的内存，如果可能的话，最好有独立的磁盘。 (独立磁盘可以确保zookeeper是高性能的。).如果你的集群负载很重，不要把Zookeeper和RegionServer运行在同一台机器上面。就像DataNodes 和 TaskTrackers一样

hbase.zookeeper.property.dataDir：ZooKeeper的zoo.conf中的配置。 快照的存储位置

把ZooKeeper保存数据的目录地址改掉。默认值是 /tmp ，这里在重启的时候会被操作系统删掉，可以把它修改到 /home/hadoop/zookeeper (这个路径hadoop用户拥有操作权限)

对于独立的Zookeeper，要指明Zookeeper的host和端口。可以在 hbase-site.xml中设置, 也可以在Hbase的CLASSPATH下面加一个zoo.cfg配置文件。 HBase 会优先加载 zoo.cfg 里面的配置，把hbase-site.xml里面的覆盖掉.

参见 [http://www.yankay.com/wp-content/hbase/book.html\#hbase\_default\_configurations][http_www.yankay.com_wp-content_hbase_book.html_hbase_default_configurations]可以查找hbase.zookeeper.property 前缀，找到关于zookeeper的配置。

## 3.3 配置conf/regionservers ##

Node1

Node2

完全分布式模式的还需要修改`conf/regionservers`. 在这里列出了你希望运行的全部 HRegionServer，一行写一个host (就像Hadoop里面的 `slaves` 一样). 列在这里的server会随着集群的启动而启动，集群的停止而停止.

### 3.4 替换hadoop的jar包 ###

hbase基本的配置完了。

查看hbase的lib目录下。

ls lib |grep hadoop

hadoop-annotations-2.1.0-beta.jar  
hadoop-auth-2.1.0-beta.jar  
hadoop-client-2.1.0-beta.jar  
hadoop-common-2.1.0-beta.jar  
hadoop-hdfs-2.1.0-beta.jar  
hadoop-hdfs-2.1.0-beta-tests.jar  
hadoop-mapreduce-client-app-2.1.0-beta.jar  
hadoop-mapreduce-client-common-2.1.0-beta.jar  
hadoop-mapreduce-client-core-2.1.0-beta.jar  
hadoop-mapreduce-client-jobclient-2.1.0-beta.jar  
hadoop-mapreduce-client-jobclient-2.1.0-beta-tests.jar  
hadoop-mapreduce-client-shuffle-2.1.0-beta.jar  
hadoop-yarn-api-2.1.0-beta.jar  
hadoop-yarn-client-2.1.0-beta.jar  
hadoop-yarn-common-2.1.0-beta.jar  
hadoop-yarn-server-common-2.1.0-beta.jar  
hadoop-yarn-server-nodemanager-2.1.0-beta.jar

看到它是基于hadoop2.1.0的，所以我们需要用我们的hadoop2.2.0下的jar包来替换2.1的，保证版本的一致性，hadoop下的jar包都是在$HADOOP\_HOME/share/hadoop下的.

我们先cd 到 /home/hadoop/hbase-0.96.0-hadoop2/lib下运行命令： rm -rf hadoop\*.jar删掉所有的hadoop相关的jar包，然后运行：

find /home/hadoop/hadoop-2.2.0/share/hadoop -name "hadoop\*jar" | xargs -i cp \{\} /home/hadoop/hbase-0.96.0-hadoop2/ lib/

拷贝所有hadoop2.2.0下的jar包hbase下进行hadoop版本的统一

##  ##

4.  运行和确认安装

## 4.1当Hbase托管ZooKeeper的时候 ##

当Hbase托管ZooKeeper的时候Zookeeper集群的启动是Hbase启动脚本的一部分

首先确认你的HDFS是运行着的。你可以运行`HADOOP_HOME`中的 `bin/start-hdfs.sh` 来启动HDFS.你可以通过put命令来测试放一个文件，然后有get命令来读这个文件。通常情况下Hbase是不会运行mapreduce的。所以比不需要检查这些。

用如下命令启动Hbase:

bin/start-hbase.sh

这个脚本在`HBASE_HOME`目录里面。

你现在已经启动Hbase了。Hbase把log记在 `logs` 子目录里面. 当Hbase启动出问题的时候，可以看看Log.

Hbase也有一个界面，上面会列出重要的属性。默认是在Master的60010端口上H (HBase RegionServers 会默认绑定 60020端口，在端口60030上有一个展示信息的界面 ).如果Master运行在 `node1`，端口是默认的话，你可以用浏览器在 `http://node:60010`看到主界面. .

一旦Hbase启动，可以看到如何建表，插入数据，scan你的表，还有disable这个表，最后把它删掉。

可以在Hbase Shell停止Hbase

$./bin/stop-hbase.sh

stoppinghbase...............

停止操作需要一些时间，你的集群越大，停的时间可能会越长。如果你正在运行一个分布式的操作，要确认在Hbase彻底停止之前，Hadoop不能停.

## 4.2独立的zookeeper启动， ##

除了启动habse，

执行：bin/start-hbase.sh启动habse

你需要自己去运行zookeeper：

$\{HBASE\_HOME\}/bin/hbase-daemons.sh \{start,stop\} zookeeper

你可以用这条命令启动ZooKeeper而不启动Hbase. HBASE\_MANAGES\_ZK 的值是 false， 如果你想在Hbase重启的时候不重启ZooKeeper,你可以这样。

##  ##

5.  测试

可以使用jps查看进程：在master上：

![aHR0cDovL2hpLmNzZG4ubmV0L2F0dGFjaG1lbnQvMjAxMjAyLzEzLzBfMTMyOTEyMjIyMFh2Z3cuZ2lm][]

在node2，node3（slave节点）上

![aHR0cDovL2hpLmNzZG4ubmV0L2F0dGFjaG1lbnQvMjAxMjAyLzEzLzBfMTMyOTEyMjI1MlI1TzEuZ2lm][]

通过浏览器查看60010端口：

![aHR0cDovL2hpLmNzZG4ubmV0L2F0dGFjaG1lbnQvMjAxMjAyLzEzLzBfMTMyOTEyMjI5M0tDc2suZ2lm][]

##  ##

1.  安装中出现的问题

## 1 ） ##

用./start-hbase.sh启动HBase后，执行hbase shell  
\# bin/hbase shell  
HBase Shell; enter 'help<RETURN>' for list of supported commands.  
Version: 0.20.6, rUnknown, Thu Oct 28 19:02:04 CST 2010  
接着创建表时候出现如下情况：hbase(main):001:0> create 'test',''c  
NativeException: org.apache.hadoop.hbase.MasterNotRunningException: null

jps下，发现主节点上HMaster没有启动，查理HBase log（logs/hbase-hadoop-master-ubuntu.log）里有下面异常：  
FATAL org.apache.hadoop.hbase.master.HMaster: Unhandled exception. Starting shutdown.  
java.io.IOException: Call to node1/10.64.56.76:49002 failed on local exception: java.io.EOFException

解决：

从hadoop\_home/下面cp一个hadoop/hadoop-core-0.20.203.0.jar到hbase\_home/lib下。

因为Hbase建立在Hadoop之上，所以他用到了hadoop.jar,这个Jar在 lib 里面。这个jar是hbase自己打了branch-0.20-append 补丁的hadoop.jar. Hadoop使用的hadoop.jar和Hbase使用的 必须 一致。所以你需要将 Hbaselib 目录下的hadoop.jar替换成Hadoop里面的那个，防止版本冲突。比方说CDH的版本没有HDFS-724而branch-0.20-append里面有，这个HDFS-724补丁修改了RPC协议。如果不替换，就会有版本冲突，继而造成严重的出错，Hadoop会看起来挂了。

再用./start-hbase.sh启动HBase后，jps下，发现主节点上HMaster还是没有启动，在HBase log里有下面异常：  
FATAL org.apache.hadoop.hbase.master.HMaster: Unhandled exception. Starting shutdown.  
java.lang.NoClassDefFoundError: org/apache/commons/configuration/Configuration  
解决：  
在NoClassDefFoundError,缺少 org/apache/commons/configuration/Configuration   
果断给他加一个commons-configuration包，  
从hadoop\_home/lib下面cp一个hadoop/lib/commons-configuration-1.6.jar到hbase\_home/lib下。

（集群上所有机子的hbase配置都需要一样）

创建表报错：

ERROR: java.io.IOException: Table Namespace Manager not ready yet, try again later  
at org.apache.hadoop.hbase.master.HMaster.getNamespaceDescriptor(HMaster.java:3101)  
at org.apache.hadoop.hbase.master.HMaster.createTable(HMaster.java:1738)  
at org.apache.hadoop.hbase.master.HMaster.createTable(HMaster.java:1777)  
at org.apache.hadoop.hbase.protobuf.generated.MasterProtos$MasterService$2.callBlockingMethod(MasterProtos.java:38221)  
at org.apache.hadoop.hbase.ipc.RpcServer.call(RpcServer.java:2146)  
at org.apache.hadoop.hbase.ipc.RpcServer$Handler.run(RpcServer.java:1851)

解决：

1） 查看集群的所有机器上，

HRegionServer和HQuorumPeer进程是否都启动？

2）查看集群的所有机器的logs是不是有错误消息；

tail -f hbase-hadoop-regionserver-XXX..log

## 2  注意事项： ##

1）、先启动hadoop后，再开启hbase  
 2）、去掉hadoop的安全模式：hadoop dfsadmin -safemode leave  
 3）、把/etc/hosts里的ubuntu的IP改为服务器当前的IP  
 4)  、确认hbase的hbase-site.xml中  
                  <name>hbase.rootdir</name>  
                 <value>hdfs://node：49002/hbase</value>  
         与hadoop的core-site.xml中  
                   <name>fs.default.name</name>  
                  <value>hdfs://node：49002/hbase</value>  
       红字部分保持一致

<value>hdfs://localhost:8020/hbase</value>

否则报错：java.lang.RuntimeException: HMaster Aborted

6)、重新执行./start-hbase.sh之前，先kill掉当前的hbase和zookeeper进程

7）hosts注意顺序：

192.168.1.214 master  
192.168.1.205 node1  
192.168.1.207 node2  
192.168.1.209 node3  
192.168.1.205 T205.joy.cc

PS：遇到问题时，先查看logs，很有帮助。

HBase 官方文档，全面介绍hbase安装配置：

[http://www.yankay.com/wp-content/hbase/book.html\#hbase\_default\_configurations][http_www.yankay.com_wp-content_hbase_book.html_hbase_default_configurations]

概述

对于建表，和RDBMS类似，HBase也有namespace的概念，可以指定表空间创建表，也可以直接创建表，进入default表空间。

对于数据操作，HBase支持四类主要的数据操作，分别是：

*  Put：增加一行，修改一行；
 *  Delete：删除一行，删除指定列族，删除指定column的多个版本，删除指定column的制定版本等；
 *  Get：获取指定行的所有信息，获取指定行和指定列族的所有colunm，获取指定column，获取指定column的几个版本，获取指定column的指定版本等；
 *  Scan：获取所有行，获取指定行键范围的行，获取从某行开始的几行，获取满足过滤条件的行等。

这四个类都是org.apache.hadoop.hbase.client的子类，可以到官网API去查看详细信息，本文仅总结常用方法，力争让读者用20%的时间掌握80%的常用功能。

--------------------

1.命名空间Namespace

2.创建表

3.删除表

4.修改表

5.新增、更新数据Put

6.删除数据Delete

7.获取单行Get

8.获取多行Scan

--------------------

1. 命名空间Namespace

在关系数据库系统中，命名空间namespace指的是一个表的逻辑分组，同一组中的表有类似的用途。命名空间的概念为即将到来的多租户特性打下基础：

*  配额管理（Quota Management (HBASE-8410)）：限制一个namespace可以使用的资源，资源包括region和table等；
 *  命名空间安全管理（Namespace Security Administration (HBASE-9206)）：提供了另一个层面的多租户安全管理；
 *  Region服务器组（Region server groups (HBASE-6721)）：一个命名空间或一张表，可以被固定到一组regionservers上，从而保证了数据隔离性。

--------------------

1.1.命名空间管理

命名空间可以被创建、移除、修改。

表和命名空间的隶属关系在在创建表时决定，通过以下格式指定：

Example：hbase shell中创建命名空间、创建命名空间中的表、移除命名空间、修改命名空间

#Create a namespace
    create_namespace 'my_ns'
                create_namespace 'my_ns'

#create my_table in my_ns namespace
    create 'my_ns:my_table', 'fam'
              'my_ns:my_table', 'fam'

#drop namespace
    drop_namespace 'my_ns'
              drop_namespace 'my_ns'

#alter namespace
    alter_namespace 'my_ns', {METHOD => 'set', 'PROPERTY_NAME' => 'PROPERTY_VALUE'}
            alter_namespace 'my_ns', {METHOD => 'set', 'PROPERTY_NAME' => 'PROPERTY_VALUE'}

--------------------

1.2. 预定义的命名空间

有两个系统内置的预定义命名空间：

*  hbase：系统命名空间，用于包含hbase的内部表
 *  default：所有未指定命名空间的表都自动进入该命名空间

Example：指定命名空间和默认命名空间

#namespace=foo and table qualifier=bar
    create 'foo:bar', 'fam'
    
    #namespace=default and table qualifier=bar
    create 'bar', 'fam'

--------------------

2.创建表

废话不多说，直接上样板代码，代码后再说明注意事项和知识点：

Configuration conf = HBaseConfiguration. *create*();

HBaseAdmin admin =  new HBaseAdmin(conf);

//create namespace named "my\_ns"

admin.createNamespace(NamespaceDescriptor. *create*( "my\_ns").build());

//create tableDesc, with namespace name "my\_ns" and table name "mytable"

HTableDescriptor tableDesc =  new HTableDescriptor(TableName. *valueOf*( "my\_ns:mytable"));

tableDesc.setDurability(Durability. SYNC\_WAL );

//add a column family "mycf"

HColumnDescriptor hcd =  new HColumnDescriptor( "mycf");

tableDesc.addFamily(hcd);

admin.createTable(tableDesc);

admin.close();

**关键知识点：**

1.  必须将HBase集群的hbase-site.xml文件添加进工程的classpath中，或者通过Configuration对象设置相关属性，否则程序获取不到集群相关信息，也就无法找到集群，运行程序时会报错；
2.  HTableDescriptor tableDesc = new HTableDescriptor(TableName.valueOf("my\_ns:mytable"))代码是描述表mytable，并将mytable放到了my\_ns命名空间中，前提是该命名空间已存在，如果指定的是不存在命名空间，则会报错org.apache.hadoop.hbase.NamespaceNotFoundException；
3.  命名空间一般在建模阶段通过命令行创建，在java代码中通过admin.createNamespace(NamespaceDescriptor.create("my\_ns").build())创建的机会不多；
4.  创建HBaseAdmin对象时就已经建立了客户端程序与HBase集群的connection，所以在程序执行完成后，务必通过admin.close()关闭connection；
5.  可以通过HTableDescriptor对象设置表的特性，比如：通过tableDesc.setMaxFileSize(512)设置一个region中的store文件的最大size，当一个region中的最大store文件达到这个size时，region就开始分裂；通过tableDesc.setMemStoreFlushSize(512)设置region内存中的memstore的最大值，当memstore达到这个值时，开始往磁盘中刷数据。更多特性请自行查阅官网API；
6.  可以通过HColumnDescriptor对象设置列族的特性，比如：通过hcd.setTimeToLive(5184000)设置数据保存的最长时间；通过hcd.setInMemory(true)设置数据保存在内存中以提高响应速度；通过 hcd.setMaxVersions(10)设置数据保存的最大版本数；通过hcd.setMinVersions(5)设置数据保存的最小版本数（配合TimeToLive使用）。更多特性请自行查阅官网API；
7.  数据的版本数只能通过HColumnDescriptor对象设置，不能通过HTableDescriptor对象设置；
8.  由于HBase的数据是先写入内存，数据累计达到内存阀值时才往磁盘中flush数据，所以，如果在数据还没有flush进硬盘时，regionserver down掉了，内存中的数据将丢失。要想解决这个场景的问题就需要用到WAL（Write-Ahead-Log），tableDesc.setDurability(Durability.SYNC\_WAL)就是设置写WAL日志的级别，示例中设置的是同步写WAL，该方式安全性较高，但无疑会一定程度影响性能，请根据具体场景选择使用；
9.  setDurability(Durability d)方法可以在相关的三个对象中使用，分别是：HTableDescriptor，Delete，Put（其中Delete和Put的该方法都是继承自父类org.apache.hadoop.hbase.client.Mutation）。分别针对表、插入操作、删除操作设定WAL日志写入级别。需要注意的是，Delete和Put并不会继承Table的Durability级别（已实测验证）。Durability是一个枚举变量，可选值参见4.2节。如果不通过该方法指定WAL日志级别，则为默认USE\_DEFAULT级别。

--------------------

3.删除表

删除表没创建表那么多学问，直接上代码：

Configuration conf = HBaseConfiguration. *create*();

HBaseAdmin admin =  new HBaseAdmin(conf);

String tablename =  "my\_ns:mytable";

if(admin.tableExists(tablename)) \{

try \{

admin.disableTable(tablename);

admin.deleteTable(tablename);

\}  catch (Exception e) \{

// TODO: handle exception

e.printStackTrace();

admin.close();

说明：删除表前必须先disable表。

--------------------

4.修改表

4.1.实例代码

（1）删除列族、新增列族

修改之前，四个列族：

hbase(main):014:0> describe 'rd\_ns:itable'

DESCRIPTION                                                                                                        ENABLED

'rd\_ns:itable', \{NAME => 'info', DATA\_BLOCK\_ENCODING => 'NONE', BLOOMFILTER => 'ROW', REPLICATION\_SCOPE => '0', V true

ERSIONS => '10', COMPRESSION => 'NONE', MIN\_VERSIONS => '0', TTL => '2147483647', KEEP\_DELETED\_CELLS => 'false',

BLOCKSIZE => '65536', IN\_MEMORY => 'false', BLOCKCACHE => 'true'\}, \{NAME => 'newcf', DATA\_BLOCK\_ENCODING => 'NONE

', BLOOMFILTER => 'ROW', REPLICATION\_SCOPE => '0', COMPRESSION => 'NONE', VERSIONS => '10', TTL => '2147483647',

MIN\_VERSIONS => '0', KEEP\_DELETED\_CELLS => 'false', BLOCKSIZE => '65536', IN\_MEMORY => 'false', BLOCKCACHE => 'tr

ue'\}, \{NAME => 'note', DATA\_BLOCK\_ENCODING => 'NONE', BLOOMFILTER => 'ROW', REPLICATION\_SCOPE => '0', VERSIONS =>

'10', COMPRESSION => 'NONE', MIN\_VERSIONS => '0', TTL => '2147483647', KEEP\_DELETED\_CELLS => 'false', BLOCKSIZE

=> '65536', IN\_MEMORY => 'false', BLOCKCACHE => 'true'\}, \{NAME => 'sysinfo', DATA\_BLOCK\_ENCODING => 'NONE', BLOOM

FILTER => 'ROW', REPLICATION\_SCOPE => '0', COMPRESSION => 'NONE', VERSIONS => '10', TTL => '2147483647', MIN\_VERS

IONS => '0', KEEP\_DELETED\_CELLS => 'true', BLOCKSIZE => '65536', IN\_MEMORY => 'false', BLOCKCACHE => 'true'\}

1 row(s) in 0.0450 seconds

修改表，删除三个列族，新增一个列族，代码如下：

Configuration conf = HBaseConfiguration. *create*();

HBaseAdmin admin =  new HBaseAdmin(conf);

String tablename =  "rd\_ns:itable";

if(admin.tableExists(tablename)) \{

try \{

admin.disableTable(tablename);

//get the TableDescriptor of target table

HTableDescriptor newtd =  admin.getTableDescriptor (Bytes. *toBytes*( "rd\_ns:itable"));

//remove 3 useless column families

newtd.removeFamily(Bytes. *toBytes*( "note"));

newtd.removeFamily(Bytes. *toBytes*( "newcf"));

newtd.removeFamily(Bytes. *toBytes*( "sysinfo"));

//create HColumnDescriptor for new column family

HColumnDescriptor newhcd =  new HColumnDescriptor( "action\_log");

newhcd.setMaxVersions(10);

newhcd.setKeepDeletedCells( true);

//add the new column family(HColumnDescriptor) to HTableDescriptor

newtd.addFamily(newhcd);

//modify target table struture

admin. modifyTable (Bytes. *toBytes*( "rd\_ns:itable"),newtd);

admin.enableTable(tablename);

\}  catch (Exception e) \{

// TODO: handle exception

e.printStackTrace();

admin.close();

修改之后：

hbase(main):015:0> describe 'rd\_ns:itable'

DESCRIPTION                                                                                                        ENABLED

'rd\_ns:itable', \{NAME => 'action\_log', DATA\_BLOCK\_ENCODING => 'NONE', BLOOMFILTER => 'ROW', REPLICATION\_SCOPE =>  true

'0', COMPRESSION => 'NONE', VERSIONS => '10', TTL => '2147483647', MIN\_VERSIONS => '0', KEEP\_DELETED\_CELLS => 'tr

ue', BLOCKSIZE => '65536', IN\_MEMORY => 'false', BLOCKCACHE => 'true'\}, \{NAME => 'info', DATA\_BLOCK\_ENCODING => '

NONE', BLOOMFILTER => 'ROW', REPLICATION\_SCOPE => '0', VERSIONS => '10', COMPRESSION => 'NONE', MIN\_VERSIONS => '

0', TTL => '2147483647', KEEP\_DELETED\_CELLS => 'false', BLOCKSIZE => '65536', IN\_MEMORY => 'false', BLOCKCACHE =>

'true'\}

1 row(s) in 0.0400 seconds

逻辑很简单：

1.  通过admin.getTableDescriptor(Bytes.*toBytes*("rd\_ns:itable"))取得目标表的描述对象，应该就是取得指向该对象的指针了；
2.  修改目标表描述对象；
3.  通过admin.modifyTable(Bytes.*toBytes*("rd\_ns:itable"),newtd)将修改后的描述对象应用到目标表。

（2）修改现有列族的属性（setMaxVersions）

Configuration conf = HBaseConfiguration. *create*();

HBaseAdmin admin =  new HBaseAdmin(conf);

String tablename =  "rd\_ns:itable";

if(admin.tableExists(tablename)) \{

try \{

admin.disableTable(tablename);

//get the TableDescriptor of target table

HTableDescriptor htd = admin.getTableDescriptor(Bytes. *toBytes*( "rd\_ns:itable"));

HColumnDescriptor infocf = htd.getFamily(Bytes. *toBytes*( "info"));

infocf.setMaxVersions(100);

//modify target table struture

admin.modifyTable(Bytes. *toBytes*( "rd\_ns:itable"),htd);

admin.enableTable(tablename);

\}  catch (Exception e) \{

// TODO: handle exception

e.printStackTrace();

admin.close();

--------------------

5.新增、更新数据Put

5.1.常用构造函数：

（1）指定行键

public Put(byte\[\] row)

参数：row 行键

（2）指定行键和时间戳

public Put(byte\[\] row, long ts)

参数：row 行键，ts 时间戳

（3）从目标字符串中提取子串，作为行键

Put(byte\[\] rowArray, int rowOffset, int rowLength)

（4）从目标字符串中提取子串，作为行键，并加上时间戳

Put(byte\[\] rowArray, int rowOffset, int rowLength, long ts)

5.2.常用方法：

（1）指定 列族、限定符，添加值

add(byte\[\] family, byte\[\] qualifier, byte\[\] value)

（2）指定 列族、限定符、时间戳，添加值

add(byte\[\] family, byte\[\] qualifier, long ts, byte\[\] value)

（3） 设置写WAL （Write-Ahead-Log）的级别

public void setDurability(Durability d)

参数是一个枚举值，可以有以下几种选择：

*  ASYNC\_WAL ： 当数据变动时，异步写WAL日志
 *  SYNC\_WAL ： 当数据变动时，同步写WAL日志
 *  FSYNC\_WAL ： 当数据变动时，同步写WAL日志，并且，强制将数据写入磁盘
 *  SKIP\_WAL ： 不写WAL日志
 *  USE\_DEFAULT ： 使用HBase全局默认的WAL写入级别，即SYNC\_WAL

5.3.实例代码

（1）插入行

Configuration conf = HBaseConfiguration. *create*();

HTable table =  new HTable(conf,  "rd\_ns:leetable");

Put put =  new Put(Bytes. *toBytes*( "100001"));

put.add(Bytes. *toBytes*( "info"), Bytes. *toBytes*( "name"), Bytes. *toBytes*( "lion"));

put.add(Bytes. *toBytes*( "info"), Bytes. *toBytes*( "address"), Bytes. *toBytes*( "shangdi"));

put.add(Bytes. *toBytes*( "info"), Bytes. *toBytes*( "age"), Bytes. *toBytes*( "30"));

put.setDurability(Durability. SYNC\_WAL);

table.put(put);

table.close();

（2）更新行

Configuration conf = HBaseConfiguration. *create*();

HTable table =  new HTable(conf,  "rd\_ns:leetable");

Put put =  new Put(Bytes. *toBytes*( "100001"));

put.add(Bytes. *toBytes*( "info"), Bytes. *toBytes*( "name"), Bytes. *toBytes*( "lee"));

put.add(Bytes. *toBytes*( "info"), Bytes. *toBytes*( "address"), Bytes. *toBytes*( "longze"));

put.add(Bytes. *toBytes*( "info"), Bytes. *toBytes*( "age"), Bytes. *toBytes*( "31"));

put.setDurability(Durability. SYNC\_WAL);

table.put(put);

table.close();

注意：

1.  Put的构造函数都需要指定行键，如果是全新的行键，则新增一行；如果是已有的行键，则更新现有行。
2.  创建Put对象及put.add过程都是在构建一行的数据，创建Put对象时相当于创建了行对象，add的过程就是往目标行里添加cell，直到table.put才将数据插入表格；
3.  以上代码创建Put对象用的是构造函数1，也可用构造函数2，第二个参数是时间戳；
4.  Put还有别的构造函数，请查阅官网API。

（3）从目标字符串中提取子串，作为行键，构建Put

Configuration conf = HBaseConfiguration. *create*();

HTable table =  new HTable(conf,  "rd\_ns:leetable");

Put put =  new Put(Bytes. *toBytes*( "100001\_100002"),7,6);

put.add(Bytes. *toBytes*( "info"), Bytes. *toBytes*( "name"), Bytes. *toBytes*( "show"));

put.add(Bytes. *toBytes*( "info"), Bytes. *toBytes*( "address"), Bytes. *toBytes*( "caofang"));

put.add(Bytes. *toBytes*( "info"), Bytes. *toBytes*( "age"), Bytes. *toBytes*( "30"));

table.put(put);

table.close();

注意，关于：Put put =  new Put(Bytes.toBytes( "100001\_100002"),7,6)

1.  第二个参数是偏移量，也就是行键从第一个参数的第几个字符开始截取；
2.  第三个参数是截取长度；
3.  这个代码实际是从 100001\_100002 中截取了100002子串作为目标行的行键。

--------------------

6.删除数据Delete

Delete类用于删除表中的一行数据，通过HTable.delete来执行该动作。

在执行Delete操作时，HBase并不会立即删除数据，而是对需要删除的数据打上一个“墓碑”标记，直到当Storefile合并时，再清除这些被标记上“墓碑”的数据。

如果希望删除整行，用行键来初始化一个Delete对象即可。如果希望进一步定义删除的具体内容，可以使用以下这些Delete对象的方法：

*  为了删除指定的列族，可以使用deleteFamily
 *  为了删除指定列的多个版本，可以使用deleteColumns
 *  为了删除指定列的指定版本，可以使用deleteColumn，这样的话就只会删除版本号（时间戳）与指定版本相同的列。如果不指定时间戳，默认只删除最新的版本

下面详细说明构造函数和常用方法：

6.1.构造函数

（1）指定要删除的行键

Delete(byte\[\] row)

删除行键指定行的数据。

如果没有进一步的操作，使用该构造函数将删除行键指定的行中 所有列族中所有列的所有版本！

（2）指定要删除的行键和时间戳

Delete(byte\[\] row, long timestamp)

删除行键和时间戳共同确定行的数据。

如果没有进一步的操作，使用该构造函数将删除行键指定的行中，所有列族中所有列的 时间戳小于等于指定时间戳的数据版本。

注意：该时间戳仅仅和删除行有关，如果需要进一步指定列族或者列，你必须分别为它们指定时间戳。

（3）给定一个字符串，目标行键的偏移，截取的长度

Delete(byte\[\] rowArray, int rowOffset, int rowLength)

（4）给定一个字符串，目标行键的偏移，截取的长度，时间戳

Delete(byte\[\] rowArray, int rowOffset, int rowLength, long ts)

6.2.常用方法

*  Delete  deleteColumn(byte\[\] family, byte\[\] qualifier)    删除指定列的最新版本的数据。

*  Delete  deleteColumns(byte\[\] family, byte\[\] qualifier)    删除指定列的所有版本的数据。

*  Delete  deleteColumn(byte\[\] family, byte\[\] qualifier, long timestamp)    删除指定列的指定版本的数据。

*  Delete  deleteColumns(byte\[\] family, byte\[\] qualifier, long timestamp)    删除指定列的，时间戳小于等于给定时间戳的所有版本的数据。

*  Delete  deleteFamily(byte\[\] family)    删除指定列族的所有列的所有版本数据。

*  Delete  deleteFamily(byte\[\] family, long timestamp)    删除指定列族的所有列中时间戳小于等于指定时间戳的所有数据。

*  Delete  deleteFamilyVersion(byte\[\] family, long timestamp)    删除指定列族中所有列的时间戳等于指定时间戳的版本数据。

*  voidsetTimestamp(long timestamp)    为Delete对象设置时间戳。

6.3.实例代码

（1）删除整行的所有列族、所有行、所有版本

Configuration conf = HBaseConfiguration. *create*();

HTable table =  new HTable(conf,  "rd\_ns:leetable");

Delete delete =  new Delete(Bytes. *toBytes*( "000"));

table.delete(delete);

table.close();

（2）删除 指定列的最新版本

以下是删除之前的数据，注意看100003行的info:address，这是该列最新版本的数据，值是caofang1，在这之前的版本值是caofang：

hbase(main):007:0> scan 'rd\_ns:leetable'

ROW                       COLUMN+CELL

100001                   column=info:address, timestamp=1405304843114, value=longze

100001                   column=info:age, timestamp=1405304843114, value=31

100001                   column=info:name, timestamp=1405304843114, value=leon

100002                   column=info:address, timestamp=1405305471343, value=caofang

100002                   column=info:age, timestamp=1405305471343, value=30

100002                   column=info:name, timestamp=1405305471343, value=show

100003                   column=info:address, timestamp=1405390959464, value=caofang1

100003                   column=info:age, timestamp=1405390959464, value=301

100003                   column=info:name, timestamp=1405390959464, value=show1

3 row(s) in 0.0270 seconds

执行以下代码：

Configuration conf = HBaseConfiguration. *create*();

HTable table =  new HTable(conf,  "rd\_ns:leetable");

Delete delete =  new Delete(Bytes. *toBytes*( "100003"));

delete.deleteColumn(Bytes. *toBytes*( "info"), Bytes. *toBytes*( "address"));

table.delete(delete);

table.close();

然后查看数据，发现100003列的info:address列的值显示为前一个版本的caofang了！其余值均不变：

hbase(main):008:0> scan 'rd\_ns:leetable'

ROW                       COLUMN+CELL

100001                   column=info:address, timestamp=1405304843114, value=longze

100001                   column=info:age, timestamp=1405304843114, value=31

100001                   column=info:name, timestamp=1405304843114, value=leon

100002                   column=info:address, timestamp=1405305471343, value=caofang

100002                   column=info:age, timestamp=1405305471343, value=30

100002                   column=info:name, timestamp=1405305471343, value=show

100003                   column=info:address, timestamp=1405390728175, value=caofang

100003                   column=info:age, timestamp=1405390959464, value=301

100003                   column=info:name, timestamp=1405390959464, value=show1

3 row(s) in 0.0560 seconds

（3）删除 指定列的所有版本

接以上场景，执行以下代码：

Configuration conf = HBaseConfiguration. *create*();

HTable table =  new HTable(conf,  "rd\_ns:leetable");

Delete delete =  new Delete(Bytes. *toBytes*( "100003"));

delete. deleteColumns(Bytes. toBytes( "info"), Bytes. toBytes( "address"));

table.delete(delete);

table.close();

然后我们会发现，100003行的整个info:address列都没了：

hbase(main):009:0> scan 'rd\_ns:leetable'