【HBase】Java 操作 HBase 超详细示例（转）

淡淡的烟草味﹌ 2022-11-19 07:54 641阅读 0赞

> 原文链接：[http://blog.csdn.net/u010967382/article/details/37878701][http_blog.csdn.net_u010967382_article_details_37878701]。本文做了一些简单补充和排版。

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

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

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

关于 HBase 的基本命令，可以参考[这篇文章][Link 1]。接下来，我们就来分别看看Table、Put、Delete、Get、Scan 这些基本操作如何通过 Java 代码实现。

首先，引入相关依赖：

<dependency>
        <groupId>org.apache.hbase</groupId>
        <artifactId>hbase-client</artifactId>
        <version>2.2.5</version>
    </dependency>
    <dependency>
        <groupId>org.apache.hbase</groupId>
        <artifactId>hbase-server</artifactId>
        <version>2.2.5</version>
    </dependency>
        <dependency>
        <groupId>org.apache.hbase</groupId>
        <artifactId>hbase-common</artifactId>
        <version>2.2.5</version>
    </dependency>

## 1.表操作 ##

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

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

命名空间可以被创建、移除、修改。表和命名空间的隶属关系在在创建表时决定：

# namespace=foo and table qualifier=bar（指定命名空间 foo）
    create 'foo:bar', 'fam'
    
    # namespace=default and table qualifier=bar（默认命名空间 default）
    create 'bar', 'fam'

### 1.1 创建表 ###

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

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** 级别。

### 1.2 删除表 ###

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

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

### 1.3 修改表 ###

**1.删除列族、新增列族**

hbase(main):014:0> describe 'rd_ns:itable'
    Table  rd_ns:itable is ENABLED
    rd_ns:itable
    COLUMN FAMILY DESCRIPTION                                                                                      
    {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'}
    {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 => 'true'}
    {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', BLOOMFILTER => 'ROW', REPLICATION_SCOPE => '0', COMPRESSION => 'NONE', VERSIONS => '10', TTL => '2147483647', MIN_VERSIONS => '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'
    Table rd_ns:itable is ENABLED
    rd_ns:itable
    COLUMN FAMILY DESCRIPTION      
    {NAME => ' action_log', DATA_BLOCK_ENCODING => 'NONE', BLOOMFILTER => 'ROW', REPLICATION_SCOPE =>  true, COMPRESSION => 'NONE', VERSIONS => '10', TTL => '2147483647', MIN_VERSIONS => '0', KEEP_DELETED_CELLS => 'true', 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

**2.修改现有列族的属性（setMaxVersions)**

## 2.Put：新增、更新数据 ##

Put 常用构造函数：

// 指定行键
    public Put(byte[] row)
        
    // 指定行键和时间戳
    public Put(byte[] row,  long ts)
        
    // 从目标字符串中提取子串，作为行键
    Put(byte[] rowArray, int rowOffset, int rowLength)
        
    // 从目标字符串中提取子串，作为行键，并加上时间戳
    Put(byte[] rowArray, int rowOffset, int rowLength, long ts)

Put 常用方法：

// 指定列族、限定符，添加值
    add(byte[] family, byte[] qualifier, byte[] value)  
    
    // 指定列族、限定符、时间戳，添加值
    add(byte[] family, byte[] qualifier, long ts, byte[] value)
    
    // 设置写 WAL（Write-Ahead-Log）的级别
    // ASYNC_WAL：当数据变动时，异步写WAL日志
    // SYNC_WAL：当数据变动时，同步写WAL日志
    // FSYNC_WAL：当数据变动时，同步写WAL日志，并且，强制将数据写入磁盘
    // SKIP_WAL：不写WAL日志
    // USE_DEFAULT：使用HBase全局默认的WAL写入级别，即SYNC_WAL
    public void setDurability(Durability d)

### 2.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.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。

### 2.3 子串构建 Put ###

从目标字符串中提取子串，作为行键，构建 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 子串作为目标行的行键。

## 3.Delete：删除数据 ##

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

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

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

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

Delete 构造函数：

// 删除行键指定行的数据。
    // 如果没有进一步的操作，使用该构造函数将删除行键指定的行中 所有列族中所有列的所有版本 ！
    Delete(byte[] row)
    
    // 指定要删除的行键和时间戳
    // 如果没有进一步的操作，使用该构造函数将删除行键指定的行中，所有列族中所有列的时间戳小于等于指定时间戳的数据版本。
    // 注意：该时间戳仅仅和删除行有关，如果需要进一步指定列族或者列，你必须分别为它们指定时间戳。
    Delete(byte[] row, long timestamp)
    
    // 给定一个字符串，目标行键的偏移，截取的长度
    Delete(byte[] rowArray, int rowOffset, int rowLength)
        
    // 给定一个字符串，目标行键的偏移，截取的长度，时间戳
    Delete(byte[] rowArray, int rowOffset, int rowLength, long ts)

Delete 常用方法：

// 删除指定列的最新版本的数据。
    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)    
    
    // 为Delete对象设置时间戳。
    voidsetTimestamp(long timestamp)

### 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();

### 3.2 删除指定列的最新版本 ###

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

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了！其余值均不变：

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.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 列都没了：

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:age, timestamp=1405390959464, value=301
     100003                   column=info:name, timestamp=1405390959464, value=show1
    3 row(s) in 0.0240 seconds

### 3.4 删除指定列族中所有列的时间戳等于指定时间戳的版本数据 ###

为了演示效果，我已经向 100003 行的 info:address 列新插入一条数据

hbase(main):010: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= 1405391883886, value=shangdi
     100003                   column=info:age, timestamp= 1405390959464, value=301
     100003                   column=info:name, timestamp= 1405390959464, value=show1
    3 row(s) in 0.0250 seconds

现在，我们的目的是删除 info 列族中，时间戳为 1405390959464 的所有列数据：

Configuration conf = HBaseConfiguration.create();
    HTable table = new HTable(conf, "rd_ns:leetable");
            
    Delete delete = new Delete(Bytes.toBytes("100003"));
    delete.deleteFamilyVersion(Bytes.toBytes("info"), 1405390959464L);
            
    table.delete(delete);
    table.close();

hbase(main):011: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= 1405391883886, value=shangdi
     100003                   column=info:age, timestamp= 1405390728175, value=30
     100003                   column=info:name, timestamp= 1405390728175, value=show
    3 row(s) in 0.0250 seconds

可以看到，100003 行的 info 列族，已经不存在时间戳为 1405390959464 的数据，比它更早版本的数据被查询出来，而 info 列族中时间戳不等于 1405390959464 的 address 列，不受该 delete 的影响 。

## 4.Get：获取单行 ##

如果希望获取整行数据，用行键初始化一个 Get 对象就可以，如果希望进一步缩小获取的数据范围，可以使用 Get 对象的以下方法：

*  如果希望取得指定列族的所有列数据，使用 **addFamily** 添加所有的目标列族即可；
 *  如果希望取得指定列的数据，使用 **addColumn** 添加所有的目标列即可；
 *  如果希望取得目标列的指定时间戳范围的数据版本，使用 **setTimeRange**；
 *  如果仅希望获取目标列的指定时间戳版本，则使用 **setTimestamp**；
 *  如果希望限制每个列返回的版本数，使用 **setMaxVersions**；
 *  如果希望添加过滤器，使用 **setFilter**

Get 构造函数：

// Get 只有一个构造函数，参数是行键 
    Get(byte[] row)

Get 常用方法：

// 指定希望获取的列族
    Get addFamily(byte[] family)  
    // 指定希望获取的列 
    Get addColumn(byte[] family, byte[] qualifier)  
    // 设置获取数据的时间戳范围
    Get setTimeRange(long minStamp, long maxStamp)  
    // 设置获取数据的时间戳
    Get setTimeStamp(long timestamp)  
    // 设定获取数据的版本数
    Get setMaxVersions(int maxVersions) 
    // 设定获取数据的所有版本
    Get setMaxVersions()  
    // 为Get对象添加过滤器，过滤器详解请参见：http://blog.csdn.net/u010967382/article/details/37653177
    Get setFilter(Filter filter)  
    // 设置该Get获取的数据是否缓存在内存中
    void setCacheBlocks(boolean cacheBlocks)

测试表的所有数据：

hbase(main):016: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=1405407883218, value=qinghe
     100003                   column=info:age, timestamp=1405407883218, value=28
     100003                   column=info:name, timestamp=1405407883218, value=shichao
    3 row(s) in 0.0250 seconds

### 4.1 获取行键指定行的所有列族、所有列的最新版本数据 ###

Configuration conf = HBaseConfiguration.create();
    HTable table = new HTable(conf, "rd_ns:leetable");
    
    Get get = new Get(Bytes.toBytes("100003"));
    Result r = table.get(get);
    for (Cell cell : r.rawCells()) {
        
        System.out.println(
                "Rowkey : " + Bytes.toString(r.getRow())+
                "   Familiy:Quilifier : " + Bytes.toString(CellUtil.cloneQualifier(cell))+
                "   Value : " + Bytes.toString(CellUtil.cloneValue(cell))
         );
    }
    
    table.close();

Rowkey : 100003   Familiy:Quilifier : address   Value : qinghe
    Rowkey : 100003   Familiy:Quilifier : age   Value : 28
    Rowkey : 100003   Familiy:Quilifier : name   Value : shichao

### 4.2 获取行键指定行中，指定列的最新版本数据 ###

Configuration conf = HBaseConfiguration.create();
    HTable table = new HTable(conf, "rd_ns:leetable");
    
    Get get = new Get(Bytes.toBytes("100003"));
    get.addColumn(Bytes.toBytes("info"), Bytes.toBytes("name"));
    
    Result r = table.get(get);
    for (Cell cell : r.rawCells()) {
        
        System.out.println(
                "Rowkey : "+Bytes.toString(r.getRow())+
                "   Familiy:Quilifier : "+Bytes.toString(CellUtil.cloneQualifier(cell))+
                "   Value : "+Bytes.toString(CellUtil.cloneValue(cell))
                );
    }
    
    table.close();

Rowkey : 100003   Familiy:Quilifier : name   Value : shichao

### 4.3 获取行键指定的行中，指定时间戳的数据 ###

Configuration conf = HBaseConfiguration.create();
    HTable table = new HTable(conf, "rd_ns:leetable");
    
    Get get = new Get(Bytes.toBytes("100003"));
    get.setTimeStamp(1405407854374L);
    
    Result r = table.get(get);
    for (Cell cell : r.rawCells()) {
        
        System.out.println(
                "Rowkey : "+Bytes.toString(r.getRow())+
                "   Familiy:Quilifier : "+Bytes.toString(CellUtil.cloneQualifier(cell))+
                "   Value : "+Bytes.toString(CellUtil.cloneValue(cell))
                );
    }
    
    table.close();

代码输出了上面 scan 命令输出中没有展示的历史数据：

Rowkey : 100003   Familiy:Quilifier : address   Value : huangzhuang
    Rowkey : 100003   Familiy:Quilifier : age   Value : 32
    Rowkey : 100003   Familiy:Quilifier : name   Value : lily

### 4.4 获取行键指定的行中，所有版本的数据 ###

Configuration conf = HBaseConfiguration.create();
    HTable table = new HTable(conf, "rd_ns:itable");
    
    Get get = new Get(Bytes.toBytes("100003"));
    get.setMaxVersions();
    
    Result r = table.get(get);
    for (Cell cell : r.rawCells()) {
        
        System.out.println(
                "Rowkey : "+Bytes.toString(r.getRow())+
                "   Familiy:Quilifier : "+Bytes.toString(CellUtil.cloneQualifier(cell))+
                "   Value : "+Bytes.toString(CellUtil.cloneValue(cell))+
                "   Time : "+cell.getTimestamp()
                );
    }
    
    table.close();

Rowkey : 100003   Familiy:Quilifier : address   Value : xierqi   Time : 1405417500485
    Rowkey : 100003   Familiy:Quilifier : address   Value : shangdi   Time : 1405417477465
    Rowkey : 100003   Familiy:Quilifier : address   Value : longze   Time : 1405417448414
    Rowkey : 100003   Familiy:Quilifier : age   Value : 29   Time : 1405417500485
    Rowkey : 100003   Familiy:Quilifier : age   Value : 30   Time : 1405417477465
    Rowkey : 100003   Familiy:Quilifier : age   Value : 31   Time : 1405417448414
    Rowkey : 100003   Familiy:Quilifier : name   Value : leon   Time : 1405417500485
    Rowkey : 100003   Familiy:Quilifier : name   Value : lee   Time : 1405417477465
    Rowkey : 100003   Familiy:Quilifier : name   Value : lion   Time : 1405417448414

注意：能输出多版本数据的前提是当前列族能保存多版本数据，列族可以保存的数据版本数通过 HColumnDescriptor 的 setMaxVersions(Int) 方法设置。

## 5.Scan：获取多行 ##

Scan 对象可以返回满足给定条件的多行数据。 如果希望获取所有的行，直接初始化一个 Scan 对象即可。 如果希望限制扫描的行范围，可以使用以下方法：

*  如果希望获取指定列族的所有列，可使用 **addFamily** 方法来添加所有希望获取的列族
 *  如果希望获取指定列，使用 **addColumn** 方法来添加所有列
 *  通过 **setTimeRange** 方法设定获取列的时间范围
 *  通过 **setTimestamp** 方法指定具体的时间戳，只返回该时间戳的数据
 *  通过 **setMaxVersions** 方法设定最大返回的版本数
 *  通过 **setBatch** 方法设定返回数据的最大行数
 *  通过 **setFilter** 方法为Scan对象添加过滤器，过滤器详解请参见 [http://blog.csdn.net/u010967382/article/details/37653177][http_blog.csdn.net_u010967382_article_details_37653177]
 *  Scan 的结果数据是可以缓存在内存中的，可以通过 getCaching() 方法来查看当前设定的缓存条数，也可以通过 setCaching(int caching) 来设定缓存在内存中的行数，缓存得越多，以后查询结果越快，同时也消耗更多内存。此外，通过 setCacheBlocks 方法设置是否缓存 Scan 的结果数据块，默认为 true
 *  我们可以通过 setMaxResultSize(long) 方法来设定 Scan 返回的结果行数。

Scan 常用构造函数：

// 创建扫描所有行的Scan
    Scan()
    
    // 创建Scan，从指定行开始扫描
    // 参数： startRow 行键
    // 注意：如果指定行不存在，从下一个最近的行开始
    Scan(byte[] startRow)
    
    
    // 创建Scan，指定起止行
    // 参数： startRow 起始行， stopRow 终止行
    // 注意： startRow <= 结果集 <  stopRow
    Scan(byte[] startRow, byte[] stopRow)
    
    
    // 创建Scan，指定起始行和过滤器
    // 参数： startRow 起始行， filter 过滤器
    // 注意：过滤器的功能和构造参见 http://blog.csdn.net/u010967382/article/details/37653177
    Scan(byte[] startRow, Filter filter)

Scan 常用方法：

// 设置Scan的开始行，默认结果集包含该行。如果希望结果集不包含该行，可以在行键末尾加上0。
    Scan  setStartRow(byte[] startRow)  
    // 设置Scan的结束行，默认结果集不包含该行。如果希望结果集包含该行，可以在行键末尾加上0。
    Scan  setStopRow(byte[] stopRow)  
    // 扫描指定时间范围的数据
    Scan  setTimeRange(long minStamp, long maxStamp)  
    // 扫描指定时间的数据
    Scan  setTimeStamp(long timestamp)  
    // 指定扫描的列
    Scan  addColumn(byte[] family, byte[] qualifier)  
    // 指定扫描的列族
    Scan  addFamily(byte[] family) 
    // 为Scan设置过滤器
    Scan  setFilter(Filter filter)  
    // 设置Scan的扫描顺序，默认是正向扫描（false），可以设置为逆向扫描（true）。
    // 注意：该方法0.98版本以后才可用！！
    Scan  setReversed(boolean reversed)  
    // 获取所有版本的数据
    Scan  setMaxVersions()  
    // 设置获取的最大版本数
    Scan  setMaxVersions(int maxVersions)  
    // 设定缓存在内存中的行数，缓存得越多，以后查询结果越快，同时也消耗更多内存
    void  setCaching(int caching)  
    // 激活或者禁用raw模式。如果raw模式被激活，Scan将返回所有已经被打上删除标记但尚未被真正删除的数据。
    // 该功能仅用于激活了KEEP_DELETED_ROWS的列族，即列族开启了hcd.setKeepDeletedCells(true)。
    // 注：Scan激活raw模式后，就不能指定任意的列，否则会报错
    voidsetRaw(boolean raw)

### 5.1 扫描表中的所有行的最新版本数据 ###

Configuration conf = HBaseConfiguration.create();
    HTable table = new HTable(conf, "rd_ns:itable");
            
    Scan s = new Scan();
    
    ResultScanner rs = table.getScanner(s);
    for (Result r : rs) {
        
        for (Cell cell : r.rawCells()) {
        
            System.out.println(
                    "Rowkey : "+Bytes.toString(r.getRow())+
                    "   Familiy:Quilifier : "+Bytes.toString(CellUtil.cloneQualifier(cell))+
                    "   Value : "+Bytes.toString(CellUtil.cloneValue(cell))+
                    "   Time : "+cell.getTimestamp()
                    );
        }
    }
    table.close();

Rowkey : 100001   Familiy:Quilifier : address   Value : anywhere   Time : 1405417403438
    Rowkey : 100001   Familiy:Quilifier : age   Value : 24   Time : 1405417403438
    Rowkey : 100001   Familiy:Quilifier : name   Value : zhangtao   Time : 1405417403438
    Rowkey : 100002   Familiy:Quilifier : address   Value : shangdi   Time : 1405417426693
    Rowkey : 100002   Familiy:Quilifier : age   Value : 28   Time : 1405417426693
    Rowkey : 100002   Familiy:Quilifier : name   Value : shichao   Time : 1405417426693
    Rowkey : 100003   Familiy:Quilifier : address   Value : xierqi   Time : 1405417500485
    Rowkey : 100003   Familiy:Quilifier : age   Value : 29   Time : 1405417500485
    Rowkey : 100003   Familiy:Quilifier : name   Value : leon   Time : 1405417500485

### 5.2 扫描指定行键范围，通过末尾加0，使得结果集包含StopRow ###

Configuration conf = HBaseConfiguration.create();
    HTable table = new HTable(conf, "rd_ns:itable");
    
    Scan s = new Scan();
    s.setStartRow(Bytes.toBytes("100001"));
    s.setStopRow(Bytes.toBytes("1000020"));
            
    ResultScanner rs = table.getScanner(s);
    for (Result r : rs) {
        
        for (Cell cell : r.rawCells()) {
        
            System.out.println(
                    "Rowkey : "+Bytes.toString(r.getRow())+
                    "   Familiy:Quilifier : "+Bytes.toString(CellUtil.cloneQualifier(cell))+
                    "   Value : "+Bytes.toString(CellUtil.cloneValue(cell))+
                    "   Time : "+cell.getTimestamp()
                    );
        }
    }
    table.close();

### 5.3 返回所有已经被打上删除标记但尚未被真正删除的数据 ###

本测试针对 rd\_ns:itable 表的 100003 行。

如果使用 get 结合 setMaxVersions() 方法能返回所有未删除的数据，输出如下：

Rowkey : 100003   Familiy:Quilifier : address   Value : huilongguan   Time : 1405494141522
    Rowkey : 100003   Familiy:Quilifier : address   Value : shangdi   Time : 1405417477465
    Rowkey : 100003   Familiy:Quilifier : age   Value : new29   Time : 1405494141522
    Rowkey : 100003   Familiy:Quilifier : name   Value : liyang   Time : 1405494141522

然而，使用 Scan强大的 s.setRaw(true) 方法，可以获得所有已经被打上删除标记但尚未被真正删除的数据

Configuration conf = HBaseConfiguration.create();
    HTable table = new HTable(conf, "rd_ns:itable");
    
    Scan s = new Scan();
    s.setStartRow(Bytes.toBytes("100003"));
    s.setRaw(true);
    s.setMaxVersions();
            
    ResultScanner rs = table.getScanner(s);
    for (Result r : rs) {
        
        for (Cell cell : r.rawCells()) {
        
            System.out.println(
                    "Rowkey : "+Bytes.toString(r.getRow())+
                  "   Familiy:Quilifier : "+Bytes.toString(CellUtil.cloneQualifier(cell))+
                            "   Value : "+Bytes.toString(CellUtil.cloneValue(cell))+
                    "   Time : "+cell.getTimestamp()
                    );
        }
    }
    table.close();

Rowkey : 100003   Familiy:Quilifier : address   Value : huilongguan   Time : 1405494141522
    Rowkey : 100003   Familiy:Quilifier : address   Value :    Time : 1405417500485
    Rowkey : 100003   Familiy:Quilifier : address   Value : xierqi   Time : 1405417500485
    Rowkey : 100003   Familiy:Quilifier : address   Value : shangdi   Time : 1405417477465
    Rowkey : 100003   Familiy:Quilifier : address   Value :    Time : 1405417448414
    Rowkey : 100003   Familiy:Quilifier : address   Value : longze   Time : 1405417448414
    Rowkey : 100003   Familiy:Quilifier : age   Value : new29   Time : 1405494141522
    Rowkey : 100003   Familiy:Quilifier : age   Value :    Time : 1405417500485
    Rowkey : 100003   Familiy:Quilifier : age   Value :    Time : 1405417500485
    Rowkey : 100003   Familiy:Quilifier : age   Value : 29   Time : 1405417500485
    Rowkey : 100003   Familiy:Quilifier : age   Value : 30   Time : 1405417477465
    Rowkey : 100003   Familiy:Quilifier : age   Value : 31   Time : 1405417448414
    Rowkey : 100003   Familiy:Quilifier : name   Value : liyang   Time : 1405494141522
    Rowkey : 100003   Familiy:Quilifier : name   Value :    Time : 1405493879419
    Rowkey : 100003   Familiy:Quilifier : name   Value : leon   Time : 1405417500485
    Rowkey : 100003   Familiy:Quilifier : name   Value : lee   Time : 1405417477465
    Rowkey : 100003   Familiy:Quilifier : name   Value : lion   Time : 1405417448414

### 5.4 结合过滤器，获取所有age在25到30之间的行 ###

目前的数据：

hbase(main):049:0> scan 'rd_ns:itable'
    ROW                                           COLUMN+CELL
     100001                                       column=info:address, timestamp=1405417403438, value=anywhere
     100001                                       column=info:age, timestamp=1405417403438, value=24
     100001                                       column=info:name, timestamp=1405417403438, value=zhangtao
     100002                                       column=info:address, timestamp=1405417426693, value=shangdi
     100002                                       column=info:age, timestamp=1405417426693, value=28
     100002                                       column=info:name, timestamp=1405417426693, value=shichao
     100003                                       column=info:address, timestamp=1405494141522, value=huilongguan
     100003                                       column=info:age, timestamp=1405494999631, value=29
     100003                                       column=info:name, timestamp=1405494141522, value=liyang
    3 row(s) in 0.0240 seconds

代码：

Configuration conf = HBaseConfiguration.create();
    HTable table = new HTable(conf, "rd_ns:itable");
    
    FilterList filterList = new FilterList(FilterList.Operator.MUST_PASS_ALL);
    SingleColumnValueFilter filter1 = new SingleColumnValueFilter(
            Bytes.toBytes("info"),
            Bytes.toBytes("age"),
            CompareOp.GREATER_OR_EQUAL,
            Bytes.toBytes("25")
            );
    SingleColumnValueFilter filter2 = new SingleColumnValueFilter(
            Bytes.toBytes("info"),
            Bytes.toBytes("age"),
            CompareOp.LESS_OR_EQUAL,
            Bytes.toBytes("30")
            );
    filterList.addFilter(filter1);
    filterList.addFilter(filter2);
            
    Scan scan = new Scan();
    scan.setFilter(filterList);
            
    ResultScanner rs = table.getScanner(scan);
    for (Result r : rs) {
        
        for (Cell cell : r.rawCells()) {
        
            System.out.println(
                    "Rowkey : "+Bytes.toString(r.getRow())+
                    "   Familiy:Quilifier : "+Bytes.toString(CellUtil.cloneQualifier(cell))+
                    "   Value : "+Bytes.toString(CellUtil.cloneValue(cell))+
                    "   Time : "+cell.getTimestamp()
                    );
        }
    }
    
    table.close();

代码输出：

Rowkey : 100002   Familiy:Quilifier : address   Value : shangdi   Time : 1405417426693
    Rowkey : 100002   Familiy:Quilifier : age   Value : 28   Time : 1405417426693
    Rowkey : 100002   Familiy:Quilifier : name   Value : shichao   Time : 1405417426693
    Rowkey : 100003   Familiy:Quilifier : address   Value : huilongguan   Time : 1405494141522
    Rowkey : 100003   Familiy:Quilifier : age   Value : 29   Time : 1405494999631
    Rowkey : 100003   Familiy:Quilifier : name   Value : liyang   Time : 1405494141522

注意：

1.  HBase对列族、列名大小写敏感
2.  关于过滤器请参考 [http://blog.csdn.net/u010967382/article/details/37653177][http_blog.csdn.net_u010967382_article_details_37653177]

[http_blog.csdn.net_u010967382_article_details_37878701]: http://blog.csdn.net/u010967382/article/details/37878701
[Link 1]: https://blog.csdn.net/weixin_43935927/article/details/113203856
[http_blog.csdn.net_u010967382_article_details_37653177]: http://blog.csdn.net/u010967382/article/details/37653177