22 hbase（上）_hbase1 默认versions为3-优快云博客

本文链接：https://blog.youkuaiyun.com/rinima438/article/details/107002390

本文介绍了HBase的基础知识，包括HBase与Hadoop的关系、与RDBMS的区别以及主要特性。详细阐述了HBase集群环境的搭建步骤，包括下载、配置、安装和启动。此外，还提供了HBase的Shell操作指南，包括创建表、添加数据、查询和删除数据等操作，以及Java API开发的基本步骤和过滤器的使用，最后简要提及了HBase的底层原理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

文章目录

hbase（上）

hbase（上）

1、HBase的基本介绍

hbase是大数据领域里面一个nosql的非关系型的数据局

谷歌的三驾马车：MapReduce，GFS，bigTable

HBase主要用来存储结构化和半结构化的松散数据。

结构化数据：类似于mysql当中的一张表，字段的个数确定了，字段的类型确定了

半结构化的数据：类似于json或者xml数据

非结构化的数据：类似于音频，视频

hive可以将结构化的数据，映射成为一张表

HBase中的表一般有这样的特点：

² 大：一个表可以有上十亿行，上百万列

² 面向列:面向列(族)的存储和权限控制，列(族)独立检索。

² 稀疏:对于为空(null)的列，并不占用存储空间，因此，表可以设计的非常稀疏。

Doug Cutting hadoop + hbase

nutch ==> 爬虫框架，全网爬虫 ==》数据量太大，如何检索的问题 ==》 lucene 数据量太大，如何存储的问题 hadoop

2、hbase与hadoop的关系

hbase与hadoop是紧耦合的关系，hbase依赖于hadoop

hbase的数据都是存储在hdfs上面的

hbase是一个数据库：适合频繁的读写操作

hdfs：不适合频繁的写入操作，适合一次写入，多次读取

矛盾点：hbase适合频繁的读写操作，数据都是保存在hdfs上面的，hdfs不适合频繁的读写操作，怎么解决。。。。

如果需要运行hbase，一定要保证hadoop的环境正常运行

3、RDBMS与HBase对比

1、关系型数据库
结构：

* 数据库以表的形式存在
* 支持FAT、NTFS、EXT、文件系统
* 使用Commit log存储日志
* 参考系统是坐标系统
* 使用主键（PK）
* 支持分区
* 使用行、列、单元格

功能：

* 支持向上扩展
* 使用SQL查询
* 面向行，即每一行都是一个连续单元
* 数据总量依赖于服务器配置
* 具有ACID支持
* 适合结构化数据
* 传统关系型数据库一般都是中心化的
* 支持事务
* 支持Join

2、HBase
结构：

* 数据库以region的形式存在
* 支持HDFS文件系统
* 使用WAL（Write-Ahead Logs）存储日志
* 参考系统是Zookeeper
* 使用行键（row key）
* 支持分片
* 使用行、列、列族和单元格

功能：

* 支持向外扩展
* 使用API和MapReduce来访问HBase表数据
* 面向列，即每一列都是一个连续的单元
* 数据总量不依赖具体某台机器，而取决于机器数量
* HBase不支持ACID（Atomicity、Consistency、Isolation、Durability）
* 适合结构化数据和非结构化数据
* 一般都是分布式的
* HBase不支持事务
* 不支持Join

4、HBase的简要特征

1：海量数据存储；

2：列式存储；

3：易于扩展，类似于hdfs一样，可以加节点就可以实现HBase扩展；

4：支持客户端访问的高并发的操作；

5：稀疏表。如果某一个列没有值，那么不占用存储空间；

5、hbase的架构

在这里插入图片描述

HMaster：主节点。主要职责，负责分配region，以及管理HRegionServer

HRegionServer：从节点。主要职责，管理region

HRegionServer = 一个HLog + 多个region

region = 一个memoryStore ，内存空间，128M + 多个storeFile 文件，内存当中的数据flush到文件里面来

多个storeFile进行合并，合并成为一个大的HFile，存储在HDFS上面了

6、HBase的集群环境搭建

注意事项：HBase强依赖zookeeper和hadoop，安装HBase之前一定要保证zookeeper和hadoop启动成功，且服务正常运行

第一步：下载对应的HBase的安装包

所有关于CDH版本的软件包下载地址如下
http://archive.cloudera.com/cdh5/cdh/5/
HBase对应的版本下载地址如下
http://archive.cloudera.com/cdh5/cdh/5/hbase-1.2.0-cdh5.14.0.tar.gz

第二步：压缩包上传并解压

将我们的压缩包上传到node1服务器的/export/softwares路径下并解压

cd /export/softwares/
tar -zxvf hbase-1.2.0-cdh5.14.0-bin.tar.gz -C ../servers/
cd /export/servers/hbase-1.2.0-cdh5.14.0
rm -rf ./docs/

第三步：修改配置文件

第一台机器进行修改配置文件

cd /export/servers/hbase-1.2.0-cdh5.14.0/conf

修改第一个配置文件hbase-env.sh

注释掉HBase使用内部zk
vim hbase-env.sh
export JAVA_HOME=/home/scy/softwares/jdk1.8.0_141
export HBASE_MANAGES_ZK=false

修改第二个配置文件hbase-site.xml

修改hbase-site.xml
vim hbase-site.xml

<configuration>
        <property>
                <name>hbase.rootdir</name>
                <value>hdfs://node1:8020/hbase</value>  
        </property>

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

   <!-- 0.98后的新变动，之前版本没有.port,默认端口为60000 -->
        <property>
                <name>hbase.master.port</name>
                <value>16000</value>
        </property>

        <property>
                <name>hbase.zookeeper.quorum</name>
                <value>node1:2181,node2:2181,node3:2181</value>
        </property>

        <property>
                <name>hbase.zookeeper.property.dataDir</name>
         <value>/export/servers/zookeeper-3.4.5-cdh5.14.0/zkdatas</value>
        </property>
</configuration>

修改第三个配置文件regionservers

vim regionservers 
node1
node2
node3

创建back-masters配置文件，实现HMaster的高可用

cd /export/servers/hbase-1.2.0-cdh5.14.0/conf
vim backup-masters

node2

第四步：安装包分发到其他机器

将我们第一台机器的hbase的安装包拷贝到其他机器上面去

cd /export/servers/
scp -r hbase-1.2.0-cdh5.14.0/ node2:$PWD
scp -r hbase-1.2.0-cdh5.14.0/ node3:$PWD

第五步：三台机器创建软连接

因为hbase需要读取hadoop的core-site.xml以及hdfs-site.xml当中的配置文件信息，所以我们三台机器都要执行以下命令创建软连接

ln -s /export/servers/hadoop-2.6.0-cdh5.14.0/etc/hadoop/core-site.xml /export/servers/hbase-1.2.0-cdh5.14.0/conf/core-site.xml
ln -s /export/servers/hadoop-2.6.0-cdh5.14.0/etc/hadoop/hdfs-site.xml /export/servers/hbase-1.2.0-cdh5.14.0/conf/hdfs-site.xml

第六步：三台机器添加HBASE_HOME的环境变量

vim /etc/profile

## HBASE_HOME
export HBASE_HOME=/export/servers/hbase-1.2.0-cdh5.14.0
export PATH=$PATH:$HBASE_HOME/bin

第七步：HBase集群启动

第一台机器执行以下命令进行启动

cd /export/servers/hbase-1.2.0-cdh5.14.0
bin/start-hbase.sh

警告提示：HBase启动的时候会产生一个警告，这是因为jdk7与jdk8的问题导致的，如果linux服务器安装jdk8就会产生这样的一个警告

我们可以只是掉所有机器的hbase-env.sh当中的
“HBASE_MASTER_OPTS”和“HBASE_REGIONSERVER_OPTS”配置来解决这个问题。不过警告不影响我们正常运行，可以不用解决

我们也可以执行以下命令单节点进行启动
启动HMaster命令
bin/hbase-daemon.sh start master
启动HRegionServer命令
bin/hbase-daemon.sh start regionserver

为了解决HMaster单点故障问题，我们可以在node02和node03机器上面都可以启动HMaster节点的进程，以实现HMaster的高可用
bin/hbase-daemon.sh start master

第八步：页面访问

浏览器页面访问
http://node1:60010/master-status

7、HBase常用基本shell操作

1.进入HBase客户端命令操作界面

$ bin/hbase shell

2.查看帮助命令

hbase(main):001:0> help

HBase Shell, version 1.2.0-cdh5.14.0, rUnknown, Sat Jan  6 13:40:03 PST 2018
Type 'help "COMMAND"', (e.g. 'help "get"' -- the quotes are necessary) for help on a specific command.
Commands are grouped. Type 'help "COMMAND_GROUP"', (e.g. 'help "general"') for help on a command group.

COMMAND GROUPS:
  Group name: general
  Commands: status, table_help, version, whoami

  Group name: ddl
  Commands: alter, alter_async, alter_status, create, describe, disable, disable_all, drop, drop_all, enable, enable_all, exists, get_table, is_disabled, is_enabled, list, locate_region, show_filters

  Group name: namespace
  Commands: alter_namespace, create_namespace, describe_namespace, drop_namespace, list_namespace, list_namespace_tables

  Group name: dml
  Commands: append, count, delete, deleteall, get, get_counter, get_splits, incr, put, scan, truncate, truncate_preserve

  Group name: tools
  Commands: assign, balance_switch, balancer, balancer_enabled, catalogjanitor_enabled, catalogjanitor_run, catalogjanitor_switch, close_region, compact, compact_mob, compact_rs, flush, major_compact, major_compact_mob, merge_region, move, normalize, normalizer_enabled, normalizer_switch, split, trace, unassign, wal_roll, zk_dump

  Group name: replication
  Commands: add_peer, append_peer_tableCFs, disable_peer, disable_table_replication, enable_peer, enable_table_replication, get_peer_config, list_peer_configs, list_peers, list_replicated_tables, remove_peer, remove_peer_tableCFs, set_peer_tableCFs, show_peer_tableCFs, update_peer_config

  Group name: snapshots
  Commands: clone_snapshot, delete_all_snapshot, delete_snapshot, list_snapshots, restore_snapshot, snapshot

  Group name: configuration
  Commands: update_all_config, update_config

  Group name: quotas
  Commands: list_quotas, set_quota

  Group name: security
  Commands: grant, list_security_capabilities, revoke, user_permission

  Group name: procedures
  Commands: abort_procedure, list_procedures

  Group name: visibility labels
  Commands: add_labels, clear_auths, get_auths, list_labels, set_auths, set_visibility

  Group name: rsgroup
  Commands: add_rsgroup, balance_rsgroup, get_rsgroup, get_server_rsgroup, get_table_rsgroup, list_rsgroups, move_servers_rsgroup, move_tables_rsgroup, remove_rsgroup

SHELL USAGE:
Quote all names in HBase Shell such as table and column names.  Commas delimit
command parameters.  Type <RETURN> after entering a command to run it.
Dictionaries of configuration used in the creation and alteration of tables are
Ruby Hashes. They look like this:

  {'key1' => 'value1', 'key2' => 'value2', ...}

and are opened and closed with curley-braces.  Key/values are delimited by the
'=>' character combination.  Usually keys are predefined constants such as
NAME, VERSIONS, COMPRESSION, etc.  Constants do not need to be quoted.  Type
'Object.constants' to see a (messy) list of all constants in the environment.

If you are using binary keys or values and need to enter them in the shell, use
double-quote'd hexadecimal representation. For example:

  hbase> get 't1', "key\x03\x3f\xcd"
  hbase> get 't1', "key\003\023\011"
  hbase> put 't1', "test\xef\xff", 'f1:', "\x01\x33\x40"

The HBase shell is the (J)Ruby IRB with the above HBase-specific commands added.
For more on the HBase Shell, see http://hbase.apache.org/book.html

3.查看当前数据库中有哪些表

hbase(main):002:0> list

4.创建一张表

创建user表，包含info、data两个列族

hbase(main):010:0> create 'user', 'info', 'data'
或者
hbase(main):010:0> create 'user', {NAME => 'info', VERSIONS => '3'}，{NAME => 'data'}

5.添加数据操作

向user表中插入信息，row key为rk0001，列族info中添加name列标示符，值为zhangsan
hbase(main):011:0> put ‘user’, ‘rk0001’, ‘info:name’, ‘zhangsan’
向user表中插入信息，row key为rk0001，列族info中添加gender列标示符，值为female
hbase(main):012:0> put ‘user’, ‘rk0001’, ‘info:gender’, ‘female’

向user表中插入信息，row key为rk0001，列族info中添加age列标示符，值为20
hbase(main):013:0> put ‘user’, ‘rk0001’, ‘info:age’, 20

向user表中插入信息，row key为rk0001，列族data中添加pic列标示符，值为picture
hbase(main):014:0> put ‘user’, ‘rk0001’, ‘data:pic’, ‘picture’

6.查询数据操作

hbase的查询比较脆弱，不支持select * from tableName left join

第一种查询方式：get rowkey 通过rowkey直接获取数据效率最高

1.通过rowkey进行查询

获取user表中row key为rk0001的所有信息

hbase(main):015:0> get 'user', 'rk0001'

2.查看rowkey下面的某个列族的信息

获取user表中row key为rk0001，info列族的所有信息

hbase(main):016:0> get 'user', 'rk0001', 'info'

3.查看rowkey指定列族指定字段的值

获取user表中row key为rk0001，info列族的name、age列标示符的信息

hbase(main):017:0> get 'user', 'rk0001', 'info:name', 'info:age'

4.查看rowkey指定多个列族的信息

获取user表中row key为rk0001，info、data列族的信息

hbase(main):018:0> get 'user', 'rk0001', 'info', 'data'
或者你也可以这样写
hbase(main):019:0> get 'user', 'rk0001', {COLUMN => ['info', 'data']}
或者你也可以这样写，也行
hbase(main):020:0> get 'user', 'rk0001', {COLUMN => ['info:name', 'data:pic']}

5.指定rowkey与列值查询

获取user表中row key为rk0001，cell的值为zhangsan的信息

hbase(main):030:0> get 'user', 'rk0001', {FILTER => "ValueFilter(=, 'binary:zhangsan')"}

6.指定rowkey与列值模糊查询

获取user表中row key为rk0001，列标示符中含有a的信息

hbase(main):031:0> get 'user', 'rk0001', {FILTER => "(QualifierFilter(=,'substring:a'))"}

继续插入一批数据

hbase(main):032:0> put 'user', 'rk0002', 'info:name', 'fanbingbing'
hbase(main):033:0> put 'user', 'rk0002', 'info:gender', 'female'
hbase(main):034:0> put 'user', 'rk0002', 'info:nationality', '中国'
hbase(main):035:0> get 'user', 'rk0002', {FILTER => "ValueFilter(=, 'binary:中国')"}

第二种查询方式：scan tableName startRowkey endRowKey 根据rowkey的范围值进行查询、rowkey是按照字典顺序进行排列

7.rowkey的范围值查询

查询user表中列族为info，rk范围是[rk0001, rk0003)的数据

scan 'user', {COLUMNS => 'info', STARTROW => 'rk0001', ENDROW => 'rk0003'}

第三种查询方式 scan tableName 全表扫描

8.查询所有数据

查询user表中的所有信息

scan 'user'

9.列族查询

查询user表中列族为info的信息

scan 'user', {COLUMNS => 'info'}
scan 'user', {COLUMNS => 'info', RAW => true, VERSIONS => 5}
scan 'user', {COLUMNS => 'info', RAW => true, VERSIONS => 3}

10.多列族查询

查询user表中列族为info和data的信息

scan 'user', {COLUMNS => ['info', 'data']}
scan 'user', {COLUMNS => ['info:name', 'data:pic']}

11.指定列族与某个列名查询

查询user表中列族为info、列标示符为name的信息
scan 'user', {COLUMNS => 'info:name'}

12.指定列族与列名以及限定版本查询

查询user表中列族为info、列标示符为name的信息,并且版本最新的5个

scan 'user', {COLUMNS => 'info:name', VERSIONS => 5}

13.指定多个列族与按照数据值模糊查询

查询user表中列族为info和data且列标示符中含有a字符的信息

scan 'user', {COLUMNS => ['info', 'data'], FILTER => "(QualifierFilter(=,'substring:a'))"}

14.指定rowkey模糊查询

查询user表中row key以rk字符开头的

scan 'user',{FILTER=>"PrefixFilter('rk')"}

15.指定数据范围值查询

查询user表中指定范围的数据

scan 'user', {TIMERANGE => [1392368783980, 1392380169184]}

7、更新数据操作

1.更新数据值

更新操作同插入操作一模一样，只不过有数据就更新，没数据就添加

2.更新版本号

将user表的f1列族版本号改为5

hbase(main):050:0> alter 'user', NAME => 'info', VERSIONS => 5

8、删除数据以及删除表操作

1.指定rowkey以及列名进行删除

删除user表row key为rk0001，列标示符为info:name的数据

hbase(main):045:0> delete 'user', 'rk0001', 'info:name'

2.指定rowkey，列名以及字段值进行删除

删除user表row key为rk0001，列标示符为info:name，timestamp为1392383705316的数据

delete 'user', 'rk0001', 'info:name', 1392383705316

3.删除一个列族

删除一个列族：

alter 'user', NAME => 'f1', METHOD => 'delete' 或 alter 'user', 'delete' => 'f1'

4.清空表数据

hbase(main):017:0> truncate 'user'

5.删除表

首先需要先让该表为disable状态，使用命令：

hbase(main):049:0> disable 'user'

然后才能drop这个表，使用命令：

 hbase(main):050:0> drop 'user'

(注意：如果直接drop表，会报错：Drop the named table. Table must first be disabled)

8、HBase的高级shell管理命令

1.status
例如：显示服务器状态

hbase(main):058:0> status 'node1'

2.whoami
显示HBase当前用户，例如：

hbase> whoami

3.list
显示当前所有的表
4.count
统计指定表的记录数，例如：

hbase> count 'hbase_book'

5.describe
展示表结构信息

hbase(main):035:0> describe 'user'

6.exist
检查表是否存在，适用于表量特别多的情况

hbase(main):035:0> exists 'user2'

7.is_enabled、is_disabled
检查表是否启用或禁用

hbase(main):036:0> is_enabled 'user'

8.alter
该命令可以改变表和列族的模式，例如：

为当前表增加列族：
hbase> alter 'hbase_book', NAME => 'CF2', VERSIONS => 2
为当前表删除列族：
hbase(main):002:0>  alter 'hbase_book', 'delete' => 'CF2'

9.disable
禁用一张表
10.drop
删除一张表，记得在删除表之前必须先禁用
11.truncate
禁用表-删除表-创建表

9、HBase的java代码开发

熟练掌握通过使用java代码实现HBase数据库当中的数据增删改查的操作，特别是各种查询，熟练运用

第一步：创建maven工程，导入jar包

<repositories>
        <repository>
            <id>cloudera</id>
            <url>https://repository.cloudera.com/artifactory/cloudera-repos/</url>
        </repository>
    </repositories>

    <dependencies>

        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>2.6.0-mr1-cdh5.14.0</version>
        </dependency>


        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-client</artifactId>
            <version>1.2.0-cdh5.14.0</version>
        </dependency>

        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-server</artifactId>
            <version>1.2.0-cdh5.14.0</version>
        </dependency>


        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
            <version>6.14.3</version>
            <scope>test</scope>
        </dependency>


    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                    <!--    <verbal>true</verbal>-->
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.2</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <filters>
                                <filter>
                                    <artifact>*:*</artifact>
                                    <excludes>
                                        <exclude>META-INF/*.SF</exclude>
                                        <exclude>META-INF/*.DSA</exclude>
                                        <exclude>META-INF/*/RSA</exclude>
                                    </excludes>
                                </filter>
                            </filters>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

第二步：开发javaAPI操作HBase表数据

import com.sun.org.apache.bcel.internal.generic.NEW;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.*;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.filter.*;
import org.apache.hadoop.hbase.util.Bytes;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

1、创建表

/**
* 需求一：创建myuser表，带有f1  和f2两个列族
*
*/
    @Test
    public void  createTable() throws IOException {
        //连接hbase的服务端
        Configuration configuration = HBaseConfiguration.create();
        //设置hbase连接zk的地址
        configuration.set("hbase.zookeeper.quorum","node1:2181,node2:2181,node3:2181");

        //获取hbase数据库连接对象   通信三要素：ip地址，端口号，传输协议
        Connection connection = ConnectionFactory.createConnection(configuration);
        //获取管理员的对象，这个对象就是用于创建表，删除表等等
        Admin admin = connection.getAdmin();
        //创建一个表最少需要两个条件，表名和列族名
        HTableDescriptor hTableDescriptor = new HTableDescriptor(TableName.valueOf("myuser"));

        //给表设置列族名
        HColumnDescriptor f1 = new HColumnDescriptor("f1");
        HColumnDescriptor f2 = new HColumnDescriptor("f2");

        hTableDescriptor.addFamily(f1);
        hTableDescriptor.addFamily(f2);

        //创建表操作
        admin.createTable(hTableDescriptor);

        admin.close();
        connection.close();
        //获取连接对象，来创建表操作
    }

2、向表中添加数据

	private  Connection connection;
    private Table  table ;

    @BeforeTest
    public  void  init() throws IOException {
        //连接hbase集群
        Configuration configuration = HBaseConfiguration.create();
        configuration.set("hbase.zookeeper.quorum","node1:2181,node2:2181,node3:2181");
        connection = ConnectionFactory.createConnection(configuration);
        //获取我们的表
        table = connection.getTable(TableName.valueOf("myuser"));

    }

    /**
     * 向myuser表当中添加数据
     * hbase当中插入和更新是一样的操作，如果rowkey不存在，那么就插入，如果rowkey存在，那么就更新
     */
    @Test
    public  void  addData() throws IOException {

        //向表当中添加数据
        //put  'user','rk0001','info:name','zhangsan'
      /*  Put put = new Put("0001".getBytes());
        put.addColumn("f1".getBytes(),"name".getBytes(),"zhangsan".getBytes());
        put.addColumn("f1".getBytes(),"age".getBytes(),"18".getBytes());*/

        //创建put对象，并指定rowkey
        Put put = new Put("0001".getBytes());
        put.addColumn("f1".getBytes(),"id".getBytes(), Bytes.toBytes(1));
        put.addColumn("f1".getBytes(),"name".getBytes(), Bytes.toBytes("张三"));
        put.addColumn("f1".getBytes(),"age".getBytes(), Bytes.toBytes(18));

        put.addColumn("f2".getBytes(),"address".getBytes(), Bytes.toBytes("地球人"));
        put.addColumn("f2".getBytes(),"phone".getBytes(), Bytes.toBytes("15874102589"));
        //将我们构建好的put对象出入进去，就可以保存到hbase里面去了
        table.put(put);

    }
    @AfterTest
    public  void closeAfter() throws IOException {
        table.close();
        connection.close();
    }

3、查询数据

3.1 初始化一批数据到HBase当中用于查询

/**
* 初始化一批数据供查询使用
* @throws IOException
*/
    @Test
    public void insertBatchData() throws IOException {

        //获取连接
        Configuration configuration = HBaseConfiguration.create();
        configuration.set("hbase.zookeeper.quorum", "node01:2181,node02:2181");
        Connection connection = ConnectionFactory.createConnection(configuration);
        //获取表
        Table myuser = connection.getTable(TableName.valueOf("myuser"));
        //创建put对象，并指定rowkey
        Put put = new Put("0002".getBytes());
        put.addColumn("f1".getBytes(),"id".getBytes(),Bytes.toBytes(1));
        put.addColumn("f1".getBytes(),"name".getBytes(),Bytes.toBytes("曹操"));
        put.addColumn("f1".getBytes(),"age".getBytes(),Bytes.toBytes(30));
        put.addColumn("f2".getBytes(),"sex".getBytes(),Bytes.toBytes("1"));
        put.addColumn("f2".getBytes(),"address".getBytes(),Bytes.toBytes("沛国谯县"));
        put.addColumn("f2".getBytes(),"phone".getBytes(),Bytes.toBytes("16888888888"));
        put.addColumn("f2".getBytes(),"say".getBytes(),Bytes.toBytes("helloworld"));

        Put put2 = new Put("0003".getBytes());
        put2.addColumn("f1".getBytes(),"id".getBytes(),Bytes.toBytes(2));
        put2.addColumn("f1".getBytes(),"name".getBytes(),Bytes.toBytes("刘备"));
        put2.addColumn("f1".getBytes(),"age".getBytes(),Bytes.toBytes(32));
        put2.addColumn("f2".getBytes(),"sex".getBytes(),Bytes.toBytes("1"));
        put2.addColumn("f2".getBytes(),"address".getBytes(),Bytes.toBytes("幽州涿郡涿县"));
        put2.addColumn("f2".getBytes(),"phone".getBytes(),Bytes.toBytes("17888888888"));
        put2.addColumn("f2".getBytes(),"say".getBytes(),Bytes.toBytes("talk is cheap , show me the code"));


        Put put3 = new Put("0004".getBytes());
        put3.addColumn("f1".getBytes(),"id".getBytes(),Bytes.toBytes(3));
        put3.addColumn("f1".getBytes(),"name".getBytes(),Bytes.toBytes("孙权"));
        put3.addColumn("f1".getBytes(),"age".getBytes(),Bytes.toBytes(35));
        put3.addColumn("f2".getBytes(),"sex".getBytes(),Bytes.toBytes("1"));
        put3.addColumn("f2".getBytes(),"address".getBytes(),Bytes.toBytes("下邳"));
        put3.addColumn("f2".getBytes(),"phone".getBytes(),Bytes.toBytes("12888888888"));
        put3.addColumn("f2".getBytes(),"say".getBytes(),Bytes.toBytes("what are you 弄啥嘞！"));

        Put put4 = new Put("0005".getBytes());
        put4.addColumn("f1".getBytes(),"id".getBytes(),Bytes.toBytes(4));
        put4.addColumn("f1".getBytes(),"name".getBytes(),Bytes.toBytes("诸葛亮"));
        put4.addColumn("f1".getBytes(),"age".getBytes(),Bytes.toBytes(28));
        put4.addColumn("f2".getBytes(),"sex".getBytes(),Bytes.toBytes("1"));
        put4.addColumn("f2".getBytes(),"address".getBytes(),Bytes.toBytes("四川隆中"));
        put4.addColumn("f2".getBytes(),"phone".getBytes(),Bytes.toBytes("14888888888"));
        put4.addColumn("f2".getBytes(),"say".getBytes(),Bytes.toBytes("出师表你背了嘛"));

        Put put5 = new Put("0006".getBytes());
        put5.addColumn("f1".getBytes(),"id".getBytes(),Bytes.toBytes(5));
        put5.addColumn("f1".getBytes(),"name".getBytes(),Bytes.toBytes("司马懿"));
        put5.addColumn("f1".getBytes(),"age".getBytes(),Bytes.toBytes(27));
        put5.addColumn("f2".getBytes(),"sex".getBytes(),Bytes.toBytes("1"));
        put5.addColumn("f2".getBytes(),"address".getBytes(),Bytes.toBytes("哪里人有待考究"));
        put5.addColumn("f2".getBytes(),"phone".getBytes(),Bytes.toBytes("15888888888"));
        put5.addColumn("f2".getBytes(),"say".getBytes(),Bytes.toBytes("跟诸葛亮死掐"));


        Put put6 = new Put("0007".getBytes());
        put6.addColumn("f1".getBytes(),"id".getBytes(),Bytes.toBytes(5));
        put6.addColumn("f1".getBytes(),"name".getBytes(),Bytes.toBytes("xiaobubu—吕布"));
        put6.addColumn("f1".getBytes(),"age".getBytes(),Bytes.toBytes(28));
        put6.addColumn("f2".getBytes(),"sex".getBytes(),Bytes.toBytes("1"));
        put6.addColumn("f2".getBytes(),"address".getBytes(),Bytes.toBytes("内蒙人"));
        put6.addColumn("f2".getBytes(),"phone".getBytes(),Bytes.toBytes("15788888888"));
        put6.addColumn("f2".getBytes(),"say".getBytes(),Bytes.toBytes("貂蝉去哪了"));

        List<Put> listPut = new ArrayList<Put>();
        listPut.add(put);
        listPut.add(put2);
        listPut.add(put3);
        listPut.add(put4);
        listPut.add(put5);
        listPut.add(put6);

        myuser.put(listPut);
        myuser.close();
    }

3.2 按照rowkey进行查询获取所有列的所有制

/**
* 查询rowkey为0003的人
*/
    @Test
    public void getDataByRowKey() throws IOException {
        //获取连接
        //获取对应的表

        Get get = new Get(Bytes.toBytes("0003"));

        //通过get来获取数据  result里面封装了我们的结果数据
        Result result = table.get(get);

        //打印结果数据.获取这条数据所有的cell
        List<Cell> cells = result.listCells();
        for (Cell cell : cells) {
            //获取列族名
            byte[] family = cell.getFamily();
            //获取列名
            byte[] qualifier = cell.getQualifier();
            //获取列值
            byte[] value = cell.getValue();
            String s1 = new String(family);

            java.lang.String familyName = Bytes.toString(family);
            //判断，如果是id列和age列，转换成为int类型输出
            if("f1".equals(familyName) &&  "id".equals(Bytes.toString(qualifier)) || "age".equals(Bytes.toString(qualifier))){
                System.out.println("列族名称为"+ familyName + "列名称为" + Bytes.toString(qualifier)  +"列值为====" + Bytes.toInt(value) );
            }else{
                System.out.println("列族名称为"+ familyName + "列名称为" + Bytes.toString(qualifier)  +"列值为====" +  Bytes.toString(value) );
            }
        }
    }

3.3 按照rowkey查询指定列族下面的指定列的值

/**
 * 查询指定列族下面指定列的值
 *
 */
    @Test
    public  void  getColumn() throws IOException {
        Get get = new Get("0003".getBytes());
        get.addColumn("f1".getBytes(), "name".getBytes());
        get.addColumn("f2".getBytes(),"phone".getBytes());
        Result result = table.get(get);
        List<Cell> cells = result.listCells();
        for (Cell cell : cells) {
            //获取列族
            byte[] family = cell.getFamily();
            //获取列名
            byte[] qualifier = cell.getQualifier();
            //获取列值
            byte[] value = cell.getValue();
            System.out.println(Bytes.toString(value));
        }
    }

3.4 按照rowkey查询指定列族下面的所有列的值

/**
 * 查询指定列族下面的所有列
 *
 */
    @Test
    public  void  getFamily() throws IOException {
        Get get = new Get("0003".getBytes());
        get.addFamily("f2".getBytes());
        Result result = table.get(get);
        List<Cell> cells = result.listCells();
        for (Cell cell : cells) {
            //获取列族
            byte[] family = cell.getFamily();
            //获取列名
            byte[] qualifier = cell.getQualifier();
            //获取列值
            byte[] value = cell.getValue();
            System.out.println(Bytes.toString(value));
        }
    }

3.5 通过startRowKey和endRowKey进行扫描(前闭后开)

/**
* 通过rowkey的范围值进行扫描
* 扫描  0004   到0006的所有的数据
*/
    @Test
    public  void  rangeRowkey() throws IOException {
        Scan scan = new Scan();
      /*  scan.setStartRow("0004".getBytes());
        scan.setStopRow("0006".getBytes()); 注释掉就是全表扫描*/ 

        //ResultScanner 里面封装了我们多条数据
        ResultScanner scanner = table.getScanner(scan);
        //循环遍历ResultScanner 得到一个个的Result
        for (Result result : scanner) {
            //获取数据的rowkey
            byte[] row = result.getRow();
            System.out.println("数据的rowkey为" +  Bytes.toString(row));


            List<Cell> cells = result.listCells();
            for (Cell cell : cells) {
                byte[] family = cell.getFamily();
                String familyName = Bytes.toString(family);
                byte[] qualifier = cell.getQualifier();
                byte[] value = cell.getValue();
                //判断，如果是id列和age列，转换成为int类型输出
                if("f1".equals(familyName) &&  "id".equals(Bytes.toString(qualifier)) || "age".equals(Bytes.toString(qualifier))){
                    System.out.println("列族名称为"+ familyName + "列名称为" + Bytes.toString(qualifier)  +"列值为====" + Bytes.toInt(value) );
                }else{
                    System.out.println("列族名称为"+ familyName + "列名称为" + Bytes.toString(qualifier)  +"列值为====" +  Bytes.toString(value) );
                }
            }
        }
    }

4、过滤器查询

过滤器的类型很多，但是可以分为两大类——比较过滤器，专用过滤器
过滤器的作用是在服务端判断数据是否满足条件，然后只将满足条件的数据返回给客户端；
在这里插入图片描述

4.1 比较过滤器

4.1.1 通过RowFilter过滤比rowKey 0003小的所有值出来

/**
 * 过滤rowkey比0003还要小的数据
 */
    @Test
    public   void  rowFilterStudy() throws IOException {
        Scan scan = new Scan();
        //通过rowFilter实现数据按照rowkey进行过滤
        BinaryComparator binaryComparator = new BinaryComparator("0003".getBytes());

        RowFilter rowFilter = new RowFilter(CompareFilter.CompareOp.LESS, binaryComparator);
        scan.setFilter(rowFilter);
        ResultScanner scanner = table.getScanner(scan);
        for (Result result : scanner) {
            byte[] row = result.getRow();
            System.out.println("数据的rowkey为" +  Bytes.toString(row));

            List<Cell> cells = result.listCells();
            for (Cell cell : cells) {
                byte[] family = cell.getFamily();
                byte[] qualifier = cell.getQualifier();
                byte[] value = cell.getValue();

                //id列和age列是整型的数据
                if("f1".equals(Bytes.toString(family)) && "id".equals(Bytes.toString(qualifier))  || "age".equals(Bytes.toString(qualifier)) ){
                    System.out.println("列族为" +  Bytes.toString(family) + "列名为" +  Bytes.toString(qualifier) + "列值为" +  Bytes.toInt(value));
                }else{
                    System.out.println("列族为" +  Bytes.toString(family) + "列名为" +  Bytes.toString(qualifier) + "列值为" +  Bytes.toString(value));
                }
            }
        }
    }

4.1.2 列族过滤器FamilyFilter

/**
* 列族过滤器，只需要获取f2列族下面的列
*/
    @Test
    public void familyFilter() throws IOException {
        Scan scan = new Scan();
        SubstringComparator substringComparator = new SubstringComparator("f2");

        FamilyFilter familyFilter = new FamilyFilter(CompareFilter.CompareOp.EQUAL, substringComparator);

        scan.setFilter(familyFilter);


        ResultScanner scanner = table.getScanner(scan);
        for (Result result : scanner) {
            byte[] row = result.getRow();
            System.out.println("数据的rowkey为" +  Bytes.toString(row));

            List<Cell> cells = result.listCells();
            for (Cell cell : cells) {
                byte[] family = cell.getFamily();
                byte[] qualifier = cell.getQualifier();
                byte[] value = cell.getValue();

                //id列和age列是整型的数据
                if("f1".equals(Bytes.toString(family)) && "id".equals(Bytes.toString(qualifier))  || "age".equals(Bytes.toString(qualifier)) ){
                    System.out.println("列族为" +  Bytes.toString(family) + "列名为" +  Bytes.toString(qualifier) + "列值为" +  Bytes.toInt(value));
                }else{
                    System.out.println("列族为" +  Bytes.toString(family) + "列名为" +  Bytes.toString(qualifier) + "列值为" +  Bytes.toString(value));
                }
            }
        }
    }

4.1.3 列过滤器QualifierFilter

/**
 * 列名过滤器，只查询，列名为name的这一列数据
 */
    @Test
    public  void  qualifierFilter() throws IOException {

        Scan scan = new Scan();

        QualifierFilter qualifierFilter = new QualifierFilter(CompareFilter.CompareOp.EQUAL, new SubstringComparator("name"));


        scan.setFilter(qualifierFilter);


        ResultScanner scanner = table.getScanner(scan);

        for (Result result : scanner) {
            byte[] row = result.getRow();
            System.out.println("数据的rowkey为" +  Bytes.toString(row));

            List<Cell> cells = result.listCells();
            for (Cell cell : cells) {
                byte[] family = cell.getFamily();
                byte[] qualifier = cell.getQualifier();
                byte[] value = cell.getValue();

                //id列和age列是整型的数据
                if("f1".equals(Bytes.toString(family)) && "id".equals(Bytes.toString(qualifier))  || "age".equals(Bytes.toString(qualifier)) ){
                    System.out.println("列族为" +  Bytes.toString(family) + "列名为" +  Bytes.toString(qualifier) + "列值为" +  Bytes.toInt(value));
                }else{
                    System.out.println("列族为" +  Bytes.toString(family) + "列名为" +  Bytes.toString(qualifier) + "列值为" +  Bytes.toString(value));
                }
            }
        }
    }

4.1.4 列值过滤器ValueFilter

值过滤器，与数据值进行比较只返回满足条件的列值

/**
     * 查修列值当中包含8的列，返回回来
     */
    @Test
    public void valueFilter() throws IOException {
        Scan scan = new Scan();
        ValueFilter valueFilter = new ValueFilter(CompareFilter.CompareOp.EQUAL, new SubstringComparator("8"));

        scan.setFilter(valueFilter);


        ResultScanner scanner = table.getScanner(scan);
        for (Result result : scanner) {
            byte[] row = result.getRow();
            System.out.println("数据的rowkey为" +  Bytes.toString(row));

            List<Cell> cells = result.listCells();
            for (Cell cell : cells) {
                byte[] family = cell.getFamily();
                byte[] qualifier = cell.getQualifier();
                byte[] value = cell.getValue();

                //id列和age列是整型的数据
                if("f1".equals(Bytes.toString(family)) && "id".equals(Bytes.toString(qualifier))  || "age".equals(Bytes.toString(qualifier)) ){
                    System.out.println("列族为" +  Bytes.toString(family) + "列名为" +  Bytes.toString(qualifier) + "列值为" +  Bytes.toInt(value));
                }else{
                    System.out.println("列族为" +  Bytes.toString(family) + "列名为" +  Bytes.toString(qualifier) + "列值为" +  Bytes.toString(value));
                }
            }
        }
    }

4.2 专用过滤器

4.2.1 单列值过滤器 SingleColumnValueFilter

singleColumnValueFilter：将满足条件的所有列的值全部返回来

/**
* 查询name为刘备的人
*/
    @Test
    public void singleColumnValueFilter() throws IOException {

        Scan scan = new Scan();

        /**
         * @param family name of column family
         * @param qualifier name of column qualifier
         * @param compareOp operator
         * @param value value to compare column values against
         */
        SingleColumnValueFilter singleColumnValueFilter = new SingleColumnValueFilter("f1".getBytes(), "name".getBytes(), CompareFilter.CompareOp.EQUAL, "刘备".getBytes());

        scan.setFilter(singleColumnValueFilter);

        ResultScanner scanner = table.getScanner(scan);
        for (Result result : scanner) {
            byte[] row = result.getRow();
            System.out.println("数据的rowkey为" +  Bytes.toString(row));

            List<Cell> cells = result.listCells();
            for (Cell cell : cells) {
                byte[] family = cell.getFamily();
                byte[] qualifier = cell.getQualifier();
                byte[] value = cell.getValue();

                //id列和age列是整型的数据
                if("f1".equals(Bytes.toString(family)) && "id".equals(Bytes.toString(qualifier))  || "age".equals(Bytes.toString(qualifier)) ){
                    System.out.println("列族为" +  Bytes.toString(family) + "列名为" +  Bytes.toString(qualifier) + "列值为" +  Bytes.toInt(value));
                }else{
                    System.out.println("列族为" +  Bytes.toString(family) + "列名为" +  Bytes.toString(qualifier) + "列值为" +  Bytes.toString(value));
                }
            }
        }
    }

4.2.2 列值排除过滤器SingleColumnValueExcludeFilter

与SingleColumnValueFilter相反，会排除掉指定的列，其他的列全部返回

4.2.3 rowkey前缀过滤器PrefixFilter

/**
* 查询rowkey以00开头所有的数据  PrefixFilter
*/
    @Test
    public  void  prefixFilter() throws IOException {

        Scan scan = new Scan();

        PrefixFilter prefixFilter = new PrefixFilter("00".getBytes());

        scan.setFilter(prefixFilter);

        ResultScanner scanner = table.getScanner(scan);


        for (Result result : scanner) {
            byte[] row = result.getRow();
            System.out.println("数据的rowkey为" +  Bytes.toString(row));

            List<Cell> cells = result.listCells();
            for (Cell cell : cells) {
                byte[] family = cell.getFamily();
                byte[] qualifier = cell.getQualifier();
                byte[] value = cell.getValue();

                //id列和age列是整型的数据
                if("f1".equals(Bytes.toString(family)) && "id".equals(Bytes.toString(qualifier))  || "age".equals(Bytes.toString(qualifier)) ){
                    System.out.println("列族为" +  Bytes.toString(family) + "列名为" +  Bytes.toString(qualifier) + "列值为" +  Bytes.toInt(value));
                }else{
                    System.out.println("列族为" +  Bytes.toString(family) + "列名为" +  Bytes.toString(qualifier) + "列值为" +  Bytes.toString(value));
                }
            }
        }
    }

4.2.4 分页过滤器PageFilter

在这里插入图片描述

/**
 * hbase当中分页
 * 分页两个条件
 * pageNum
 * pageSize
 */
    @Test
    public  void  pageFilter() throws IOException {

        int pageNum =3 ;
        int pageSize = 2;

        if(pageNum  == 1 ){
            Scan scan = new Scan();
            scan.setStartRow("".getBytes());   //设置我们的起始rowkey
            scan.setMaxResultSize(pageSize);  //设置最大的返回结果返回两条
            PageFilter filter = new PageFilter(pageSize);
            scan.setFilter(filter);

            ResultScanner scanner = table.getScanner(scan);
            for (Result result : scanner) {
                byte[] row = result.getRow();
                System.out.println("数据的rowkey为" +  Bytes.toString(row));

                List<Cell> cells = result.listCells();
                for (Cell cell : cells) {
                    byte[] family = cell.getFamily();
                    byte[] qualifier = cell.getQualifier();
                    byte[] value = cell.getValue();

                    //id列和age列是整型的数据
                    if("f1".equals(Bytes.toString(family)) && "id".equals(Bytes.toString(qualifier))  || "age".equals(Bytes.toString(qualifier)) ){
                        System.out.println("列族为" +  Bytes.toString(family) + "列名为" +  Bytes.toString(qualifier) + "列值为" +  Bytes.toInt(value));
                    }else{
                        System.out.println("列族为" +  Bytes.toString(family) + "列名为" +  Bytes.toString(qualifier) + "列值为" +  Bytes.toString(value));
                    }
                }
            }
        }else{
            String  startRow = "";
            Scan scan = new Scan();
            int resultSize = (pageNum - 1) * pageSize + 1;
            scan.setMaxResultSize(resultSize);
            PageFilter filter = new PageFilter(resultSize);//设置我们一次性往前扫描5条，最后一个rowkey就是我们第三页的起始rowkey
             scan.setFilter(filter);
            ResultScanner scanner = table.getScanner(scan);  //resultScanner里面包含了5条
            for (Result result : scanner) {
                //获取我们rowkey
                byte[] row = result.getRow();
                startRow = Bytes.toString(row);  //最后一次循环遍历  rowkey为0005

            }
            //根据我们求取出来的startRow来实现我们第三页数据的查询
            Scan scan2 = new Scan();
            scan2.setStartRow(startRow.getBytes());
            scan2.setMaxResultSize(pageSize);

            PageFilter filter1 = new PageFilter(pageSize);
            scan2.setFilter(filter1);

            ResultScanner scanner1 = table.getScanner(scan2);
            for (Result result : scanner1) {
                byte[] row = result.getRow();
                System.out.println("数据的rowkey为" +  Bytes.toString(row));

                List<Cell> cells = result.listCells();
                for (Cell cell : cells) {
                    byte[] family = cell.getFamily();
                    byte[] qualifier = cell.getQualifier();
                    byte[] value = cell.getValue();

                    //id列和age列是整型的数据
                    if("f1".equals(Bytes.toString(family)) && "id".equals(Bytes.toString(qualifier))  || "age".equals(Bytes.toString(qualifier)) ){
                        System.out.println("列族为" +  Bytes.toString(family) + "列名为" +  Bytes.toString(qualifier) + "列值为" +  Bytes.toInt(value));
                    }else{
                        System.out.println("列族为" +  Bytes.toString(family) + "列名为" +  Bytes.toString(qualifier) + "列值为" +  Bytes.toString(value));
                    }
                }
            }
        }
        //分为两种条件进行判断，第一页和其他页
    }

4.3 多过滤器综合查询FilterList

需求：使用SingleColumnValueFilter查询f1列族，name为刘备的数据，并且同时满足rowkey的前缀以00开头的数据（PrefixFilter）

/**
* 多过滤器综合查询
* 需求：使用SingleColumnValueFilter查询f1列族，name为刘备的数据，并且同时满足rowkey的前缀以00开头的数据（PrefixFilter）
*/
    @Test
    public  void filterList() throws IOException {
        /**
         * final byte [] family, final byte [] qualifier,
         final CompareOp compareOp, final byte[] value
         */
        SingleColumnValueFilter singleColumnValueFilter = new SingleColumnValueFilter("f1".getBytes(), "name".getBytes(), CompareFilter.CompareOp.EQUAL, "刘备".getBytes());

        PrefixFilter prefixFilter = new PrefixFilter("00".getBytes());

        FilterList filterList = new FilterList(singleColumnValueFilter, prefixFilter);


        Scan scan = new Scan();
        scan.setFilter(filterList);

        ResultScanner scanner = table.getScanner(scan);
        for (Result result : scanner) {
            byte[] row = result.getRow();
            System.out.println("数据的rowkey为" +  Bytes.toString(row));

            List<Cell> cells = result.listCells();
            for (Cell cell : cells) {
                byte[] family = cell.getFamily();
                byte[] qualifier = cell.getQualifier();
                byte[] value = cell.getValue();

                //id列和age列是整型的数据
                if("f1".equals(Bytes.toString(family)) && "id".equals(Bytes.toString(qualifier))  || "age".equals(Bytes.toString(qualifier)) ){
                    System.out.println("列族为" +  Bytes.toString(family) + "列名为" +  Bytes.toString(qualifier) + "列值为" +  Bytes.toInt(value));
                }else{
                    System.out.println("列族为" +  Bytes.toString(family) + "列名为" +  Bytes.toString(qualifier) + "列值为" +  Bytes.toString(value));
                }
            }
        }
    }

5、根据rowkey删除数据

5.1 根据rowkey删除数据

 /**
 * 根据rowkey删除数据
 */
    @Test
    public void deleteData() throws IOException {

        Delete delete = new Delete("0007".getBytes());

        table.delete(delete);
    }

5.2 删除表操作

@Test
    public void  deleteTable() throws IOException {
        //获取连接
        Configuration configuration = HBaseConfiguration.create();
        configuration.set("hbase.zookeeper.quorum","node1:2181,node2:2181,node3:2181");
        Connection connection = ConnectionFactory.createConnection(configuration);
        Admin admin = connection.getAdmin();
        admin.disableTable(TableName.valueOf("myuser"));
        admin.deleteTable(TableName.valueOf("myuser"));
        admin.close();
    }

10、HBase底层原理

系统架构

在这里插入图片描述
Client

包含访问hbase的接口，client维护着一些cache来加快对hbase的访问，比如regions的位置信息。

Zookeeper

1 保证任何时候，集群中只有一个master
2 存贮所有Region的寻址入口----root表在哪台服务器上。
3 实时监控Region Server的状态，将Region server的上线和下线信息实时通知给Master
4 存储Hbase的schema,包括有哪些table，每个table有哪些column family

Master职责

1 为Region server分配region
2 负责region server的负载均衡
3 发现失效的region server并重新分配其上的region
4 HDFS上的垃圾文件回收
5 处理schema更新请求

Region Server职责

1 Region server维护Master分配给它的region，处理对这些region的IO请求
2 Region server负责切分在运行过程中变得过大的region
可以看到，client访问hbase上数据的过程并不需要master参与（寻址访问zookeeper和region server，数据读写访问regione server），master仅仅维护者table和region的元数据信息，负载很低。

hbase的表模型

在这里插入图片描述

创建一个hbase表，最低两个要求，一个是表名，一个是列族名

列族：columnFamily：访问控制、磁盘和内存的使用统计都是在列族层面进行的。不要设计太多列族

列：column

注意：每一个列，必然归属于某一个列族

一个列族下面可以有很多列。列类似于mysql当中的字段

rowkey：行键，类似于mysql表当中的主键.Row key行键 (Row key)可以是任意字符串(最大长度是 64KB，实际应用中长度一般为 10-100bytes,存放在内存中不宜太长)，在hbase内部，row key保存为字节数组。
要保持整形的自然序，行键必须用0作左填充。

Hbase会对表中的数据按照rowkey排序(字典顺序)

timestamp：时间戳。每条数据产生的时间戳（自带）

version：版本号，每条数据当前的版本号（自带）

cell：单元格，存储了我们某条数据，某个字段的值

注意：列族下面的各个列，是你在插入数据的时候动态指定的

HBase当中物理存储

1.整体结构

在这里插入图片描述
1 Table中的所有行都按照row key的字典序排列。
2 Table 在行的方向上分割为多个Hregion。

3 region按大小分割的(默认10G)，每个表一开始只有一个region，随着数据不断插入表，region不断增大，当增大到一个阀值的时候，Hregion就会等分会两个新的Hregion。当table中的行不断增多，就会有越来越多的Hregion。

4 Hregion是Hbase中分布式存储和负载均衡的最小单元。最小单元就表示不同的Hregion可以分布在不同的HRegion server上。但一个Hregion是不会拆分到多个server上的。

5 HRegion虽然是负载均衡的最小单元，但并不是物理存储的最小单元。
事实上，HRegion由一个或者多个Store组成，每个store保存一个column family。
每个Strore又由一个memStore和0至多个StoreFile组成。如上图

2.STORE FILE & HFILE结构

StoreFile以HFile格式保存在HDFS上。
HFile：文件存储格式。类似于txt，orc，parquet等等都是文件存储格式

textFile，sequenceFile  行式存储
orc   ,   parquet  列式存储

在这里插入图片描述

3.Memstore与storefile

一个region由多个store组成，每个store包含一个列族的所有数据
Store包括位于内存的memstore和位于硬盘的storefile
写操作先写入memstore,当memstore中的数据量达到某个阈值，Hregionserver启动flashcache进程写入storefile,每次写入形成单独一个storefile
当storefile大小超过一定阈值后，会把当前的region分割成两个，并由Hmaster分配给相应的region服务器，实现负载均衡
客户端检索数据时，先在memstore找，找不到再找storefile

4.HLog(WAL log)

WAL 意为Write ahead log(http://en.wikipedia.org/wiki/Write-ahead_logging)，类似mysql中的binlog,用来做灾难恢复时用，Hlog记录数据的所有变更,一旦数据修改，就可以从log中进行恢复。
每个Region Server维护一个Hlog,而不是每个Region一个。这样不同region(来自不同table)的日志会混在一起，这样做的目的是不断追加单个文件相对于同时写多个文件而言，可以减少磁盘寻址次数，因此可以提高对table的写性能。带来的麻烦是，如果一台region server下线，为了恢复其上的region，需要将region server上的log进行拆分，然后分发到其它region server上进行恢复。
HLog文件就是一个普通的Hadoop Sequence File

5.读写过程

1、读请求过程：

第一步：客户端发起请求，读取数据

第二步：客户端连接zk,获取一张特殊表mate表的位置（记录了其他表的元数据信息）

第三步：读取meta表数据之后，获取到了对应表的myuser的region信息

第四步：客户端与对应的region进行通信，数据查询

第五步：先查找memoryStore，如果查找不到再查找storeFile

第六步：HRegionServer把查询到的数据响应给Client。

2、写请求过程：

第一步：客户端发起请求，写入数据

第二步：客户端连接zk,获取一张特殊表mate表的位置（记录了其他表的元数据信息）

scan ‘hbase:meta’ meta表的数据信息

ROW                              COLUMN+CELL                                                                                
 hbase:namespace,,1557280798528. column=info:regioninfo, timestamp=1557280800325, value={ENCODED => 56c88e849283c869e74095d5
 56c88e849283c869e74095d5bf616b4 bf616b49, NAME => 'hbase:namespace,,1557280798528.56c88e849283c869e74095d5bf616b49.', START
 9.                              KEY => '', ENDKEY => ''}                                                                   
 hbase:namespace,,1557280798528. column=info:seqnumDuringOpen, timestamp=1557280800325, value=\x00\x00\x00\x00\x00\x00\x00\x
 56c88e849283c869e74095d5bf616b4 02                                                                                         
 9.                                                                                                                         
 hbase:namespace,,1557280798528. column=info:server, timestamp=1557280800325, value=node02.hadoop.com:60020                 
 56c88e849283c869e74095d5bf616b4                                                                                            
 9.                                                                                                                         
 hbase:namespace,,1557280798528. column=info:serverstartcode, timestamp=1557280800325, value=1557280788349                  
 56c88e849283c869e74095d5bf616b4                                                                                            
 9.                                                                                                                         
 myuser,,1557285598626.9a6ee8080 column=info:regioninfo, timestamp=1557285599647, value={ENCODED => 9a6ee8080ee16457bb791a10
 ee16457bb791a10cca6c498.        cca6c498, NAME => 'myuser,,1557285598626.9a6ee8080ee16457bb791a10cca6c498.', STARTKEY => ''
                                 , ENDKEY => ''}                                                                            
 myuser,,1557285598626.9a6ee8080 column=info:seqnumDuringOpen, timestamp=1557285599647, value=\x00\x00\x00\x00\x00\x00\x00\x
 ee16457bb791a10cca6c498.        02                                                                                         
 myuser,,1557285598626.9a6ee8080 column=info:server, timestamp=1557285599647, value=node02.hadoop.com:60020                 
 ee16457bb791a10cca6c498.                                                                                                   
 myuser,,1557285598626.9a6ee8080 column=info:serverstartcode, timestamp=1557285599647, value=1557280788349                  
 ee16457bb791a10cca6c498.                                                                                                   
 user,,1557283951792.5b54e4569a9 column=info:regioninfo, timestamp=1557284223555, value={ENCODED => 5b54e4569a9e7f541340077f
 e7f541340077ff35c168f.          f35c168f, NAME => 'user,,1557283951792.5b54e4569a9e7f541340077ff35c168f.', STARTKEY => '', 
                                 ENDKEY => ''}                                                                              
 user,,1557283951792.5b54e4569a9 column=info:seqnumDuringOpen, timestamp=1557284223555, value=\x00\x00\x00\x00\x00\x00\x00\x
 e7f541340077ff35c168f.          05                                                                                         
 user,,1557283951792.5b54e4569a9 column=info:server, timestamp=1557284223555, value=node01.hadoop.com:60020                 
 e7f541340077ff35c168f.                                                                                                     
 user,,1557283951792.5b54e4569a9 column=info:serverstartcode, timestamp=1557284223555, value=1557280783177                  
 e7f541340077ff35c168f.                                                                                                     
3 row(s) in 0.0500 seconds

第三步：读取meta表数据之后，获取到了对应表的myuser的region信息

第四步：将数据写入对应的region里面去（先写HLOG，再写memoryStore。都写入后表示写数据成功）

第五步：数据一直往memoryStore写，等到数据达到一定阈值时候，启动线程进行flush过程，将数据写入到storeFile里面去

第六步：storeFile越来越多，将合并成一个大的HFile，放到hdfs上面去，这个过程叫做compact机制
hbase随机的读写操作
hdfs适合一次写入，多次读取
storeFile合并的过程中，compact机制会清理过期的数据，包括一些无效的版本的数据都会被清理掉

第七步：HFile也会越来越大，为了避免HFile过大，一旦达到临界值10Gb的时候，会将region给切开，分为两个region。split机制
在这里插入图片描述

6.Region管理

任何时刻一个region只隶属于某一个regionServer，只会被一个regionServer进行管理

region分配的原则：找比较空闲的regionServer进行分配

HFile达到10Gb，会分配region

创建表的时候，可以提前分配多个region，避免频繁的split分裂

regionServer 上线：上线都是通过zk进行位置感知的

regionServer下线：也是通过zk位置感知，告诉给master的。regionserver一旦下线，管理的region没法进行管理了，master会将它管理的region转移到其他的机器上面

7.Master工作机制

master上线

master启动进行以下步骤:

1 从zookeeper上获取唯一一个代表active master的锁，用来阻止其它master成为master。
2 扫描zookeeper上的server父节点，获得当前可用的region server列表。
3 和每个region server通信，获得当前已分配的region和region server的对应关系。
4 扫描.META.region的集合，计算得到当前还未分配的region，将他们放入待分配region列表。

master下线

由于master只维护表和region的元数据，而不参与表数据IO的过程，master下线仅导致所有元数据的修改被冻结
(无法创建删除表，无法修改表的schema，无法进行region的负载均衡，无法处理region 上下线，无法进行
region的合并，唯一例外的是region的split可以正常进行，因为只有region server参与)，表的数据读写还
可以正常进行。因此master下线短时间内对整个hbase集群没有影响。

从上线过程可以看到，master保存的信息全是可以冗余信息（都可以从系统其它地方收集到或者计算出来）
因此，一般hbase集群中总是有一个master在提供服务，还有一个以上的‘master’在等待时机抢占它的位置。

8.HBase当中三个重要的机制

flush：数据从memorystore到storeFile。flush过程，写操作会被阻塞

当MemStore达到阈值，将Memstore中的数据Flush进Storefile
涉及属性：
hbase.hregion.memstore.flush.size：134217728
即：128M就是Memstore的默认阈值

hbase.regionserver.global.memstore.upperLimit：0.4
即：这个参数的作用是当单个HRegion内所有的Memstore大小总和超过指定值时，flush该HRegion的所有
memstore。RegionServer的flush是通过将请求添加一个队列，模拟生产消费模式来异步处理的。那这里就有
一个问题，当队列来不及消费，产生大量积压请求时，可能会导致内存陡增，最坏的情况是触发OOM。

hbase.regionserver.global.memstore.lowerLimit：0.38
即：当MemStore使用内存总量达到hbase.regionserver.global.memstore.upperLimit指定值时，将会
有多个MemStores flush到文件中，MemStore flush 顺序是按照大小降序执行的，直到刷新到MemStore
使用内存略小于lowerLimit

compact：数据从storeFile到大的HFile。清除掉过期的数据，删除掉无用的数据

http://archive.cloudera.com/cdh5/cdh/5/hbase-1.2.0-cdh5.14.0/book.html#compaction

在这里插入图片描述

split：HFile越来越大，达到阈值10GB，进行切分为二。

22 hbase（上）

文章目录

hbase（上）

1、HBase的基本介绍

2、hbase与hadoop的关系

3、RDBMS与HBase对比

4、HBase的简要特征

5、hbase的架构

6、HBase的集群环境搭建

第一步：下载对应的HBase的安装包

第二步：压缩包上传并解压

第三步：修改配置文件

第四步：安装包分发到其他机器

第五步：三台机器创建软连接

第六步：三台机器添加HBASE_HOME的环境变量

第七步：HBase集群启动

第八步：页面访问

7、HBase常用基本shell操作

1.进入HBase客户端命令操作界面

2.查看帮助命令

3.查看当前数据库中有哪些表

4.创建一张表

5.添加数据操作

6.查询数据操作

第一种查询方式：get rowkey 通过rowkey直接获取数据 效率最高

1.通过rowkey进行查询

2.查看rowkey下面的某个列族的信息

3.查看rowkey指定列族指定字段的值

4.查看rowkey指定多个列族的信息

5.指定rowkey与列值查询

6.指定rowkey与列值模糊查询

第二种查询方式：scan tableName startRowkey endRowKey 根据rowkey的范围值进行查询、rowkey是按照字典顺序进行排列

7.rowkey的范围值查询

第三种查询方式 scan tableName 全表扫描

8.查询所有数据

9.列族查询

10.多列族查询

11.指定列族与某个列名查询

12.指定列族与列名以及限定版本查询

13.指定多个列族与按照数据值模糊查询

14.指定rowkey模糊查询

15.指定数据范围值查询

7、更新数据操作

1.更新数据值

2.更新版本号

8、删除数据以及删除表操作

1.指定rowkey以及列名进行删除

2.指定rowkey，列名以及字段值进行删除

3.删除一个列族

4.清空表数据

5.删除表

8、HBase的高级shell管理命令

9、HBase的java代码开发

第一步：创建maven工程，导入jar包

第二步：开发javaAPI操作HBase表数据

1、创建表

2、向表中添加数据

3、查询数据

3.1 初始化一批数据到HBase当中用于查询

3.2 按照rowkey进行查询获取所有列的所有制

3.3 按照rowkey查询指定列族下面的指定列的值

3.4 按照rowkey查询指定列族下面的所有列的值

3.5 通过startRowKey和endRowKey进行扫描(前闭后开)

4、过滤器查询

4.1 比较过滤器

4.1.1 通过RowFilter过滤比rowKey 0003小的所有值出来

4.1.2 列族过滤器FamilyFilter

4.1.3 列过滤器QualifierFilter

4.1.4 列值过滤器ValueFilter

4.2 专用过滤器

4.2.1 单列值过滤器 SingleColumnValueFilter

4.2.2 列值排除过滤器SingleColumnValueExcludeFilter

4.2.3 rowkey前缀过滤器PrefixFilter

4.2.4 分页过滤器PageFilter

4.3 多过滤器综合查询FilterList

5、根据rowkey删除数据

5.1 根据rowkey删除数据

5.2 删除表操作

10、HBase底层原理

系统架构

第一种查询方式：get rowkey 通过rowkey直接获取数据效率最高