HBase介绍和工作原理
HBase 1、HBase介绍和工作原理
HBase是一个分布式的、面向列的开源数据库，该技术来源于 Fay Chang 所撰写的Google论文“Bigtable：一个结构化数据的分布式存储系统”。就像Bigtable利用了Google文件系统（File System）所提供的分布式数据存储一样，HBase在Hadoop之上提供了类似于Bigtable的能力。HBase是Apache的Hadoop项目的子项目。HBase不同于一般的关系数据库，它是一个适合于非结构化数据存储的数据库。另一个不同的是HBase基于列的而不是基于行的模式。
1、Hadoop生太圈
通过Hadoop生态圈，可以看到HBase的身影，可见HBase在Hadoop的生态圈是扮演这一个重要的角色那就是 实时、分布式、高维数据 的数据存储；
2、HBase简介
– HBase – Hadoop Database，是一个高可靠性、高性能、面向列、可伸缩、 实时读写的分布式数据库
– 利用Hadoop HDFS作为其文件存储系统,利用Hadoop MapReduce来处理 HBase中的海量数据,利用Zookeeper作为其分布式协同服务
– 主要用来存储非结构化和半结构化的松散数据（列存NoSQL数据库）
3、HBase数据模型
以关系型数据的思维下会感觉，上面的表格是一个5列4行的数据表格，但是在HBase中这种理解是错误的，其实在HBase中上面的表格只是一行数据；
Row Key:
– 决定一行数据的唯一标识
– RowKey是按照字典顺序排序的。
– Row key最多只能存储64k的字节数据。
Column Family列族（CF1、CF2、CF3） & qualifier列：
– HBase表中的每个列都归属于某个列族，列族必须作为表模式(schema) 定义的一部分预先给出。如create ‘test’, ‘course’；
– 列名以列族作为前缀，每个“列族”都可以有多个列成员(column，每个列族中可以存放几千~上千万个列)；如 CF1:q1, CF2:qw,
新的列族成员（列）可以随后按需、动态加入，Family下面可以有多个Qualifier，所以可以简单的理解为，HBase中的列是二级列，
也就是说Family是第一级列，Qualifier是第二级列。两个是父子关系。
– 权限控制、存储以及调优都是在列族层面进行的；
– HBase把同一列族里面的数据存储在同一目录下，由几个文件保存。
– 目前为止HBase的列族能能够很好处理最多不超过3个列族。
Timestamp时间戳：
– 在HBase每个cell存储单元对同一份数据有多个版本，根据唯一的时间 戳来区分每个版本之间的差异，不同版本的数据按照时间倒序排序，
最新的数据版本排在最前面。
– 时间戳的类型是64位整型。
– 时间戳可以由HBase(在数据写入时自动)赋值，此时时间戳是精确到毫 秒的当前系统时间。
– 时间戳也可以由客户显式赋值，如果应用程序要避免数据版本冲突， 就必须自己生成具有唯一性的时间戳。
Cell单元格：
– 由行和列的坐标交叉决定；
– 单元格是有版本的（由时间戳来作为版本）；
– 单元格的内容是未解析的字节数组（Byte[]），cell中的数据是没有类型的，全部是字节码形式存贮。
• 由{row key，column(=<family> +<qualifier>)，version}唯一确定的单元。
4、HBase体系架构
Client
• 包含访问HBase的接口并维护cache来加快对HBase的访问
Zookeeper
• 保证任何时候，集群中只有一个master
• 存贮所有Region的寻址入口。
• 实时监控Region server的上线和下线信息。并实时通知Master
• 存储HBase的schema和table元数据
Master
• 为Region server分配region
• 负责Region server的负载均衡
• 发现失效的Region server并重新分配其上的region
• 管理用户对table的增删改操作
RegionServer
• Region server维护region，处理对这些region的IO请求
• Region server负责切分在运行过程中变得过大的region
HLog(WAL log)：
– HLog文件就是一个普通的Hadoop Sequence File，Sequence File 的Key是 HLogKey对象，HLogKey中记录了写入数据的归属信息，
除了table和 region名字外，同时还包括sequence number和timestamp，timestamp是” 写入时间”，sequence number的起始值为0，
或者是最近一次存入文件系 统中sequence number。
– HLog SequeceFile的Value是HBase的KeyValue对象，即对应HFile中的 KeyValue
Region
– HBase自动把表水平划分成多个区域(region)，每个region会保存一个表 里面某段连续的数据；每个表一开始只有一个region，随着数据不断插 入表，
region不断增大，当增大到一个阀值的时候，region就会等分会 两个新的region（裂变）；
– 当table中的行不断增多，就会有越来越多的region。这样一张完整的表 被保存在多个Regionserver上。
Memstore 与 storefile
– 一个region由多个store组成，一个store对应一个CF（列族）
– store包括位于内存中的memstore和位于磁盘的storefile写操作先写入 memstore，当memstore中的数据达到某个阈值，
hregionserver会启动 flashcache进程写入storefile，每次写入形成单独的一个storefile
– 当storefile文件的数量增长到一定阈值后，系统会进行合并（minor、 major compaction），在合并过程中会进行版本合并和删除工作 （majar），
形成更大的storefile。
– 当一个region所有storefile的大小和超过一定阈值后，会把当前的region 分割为两个，并由hmaster分配到相应的regionserver服务器，实现负载均衡。
– 客户端检索数据，先在memstore找，找不到再找storefile
– HRegion是HBase中分布式存储和负载均衡的最小单元。最小单元就表 示不同的HRegion可以分布在不同的HRegion server上。
– HRegion由一个或者多个Store组成，每个store保存一个columns family。
– 每个Strore又由一个memStore和0至多个StoreFile组成。
如图：StoreFile 以HFile格式保存在HDFS上。
官方帮助文档：http://hbase.apache.org/book.html PDF：http://hbase.apache.org/apache_hbase_reference_guide.pdf
1、安装前准备
– Hadoop集群要启动正常
– Zookeeper集群启动正常
HBase 分布式存储的运行依托于Zookeeper和HDFS所以必须有一个完整的Hadoop分布式运行环境和Zookeeper运行环境；
Hadoop高可用安装参见：http://www.cnblogs.com/raphael5200/p/5154325.html
2、安装HBase
1）、配置hbase-env.sh
进入HBase 的conf目录下，编辑hbase-env.sh 添加如下配置：
# 指定HBase是否使用HBase本身自带的Zookeeper export HBASE_MANAGES_ZK=false # 指定Jdk目录 export JAVA_HOME=/usr/java/jdk1.7.0_79 # 指定Hadoop配置文件目录 export HBASE_CLASSPATH=/usr/local/hadoop-2.5.1/etc/hadoop
2）、配置hbase-site.xml
编辑conf目录下的hbase-site.xml,配置内容如下：
# 指定HDFS的根目录，在这个地方，如果想使用HBase高可用的话，必须配置成dfs.nameservices 不能配置节点名称
<property>
<name>hbase.rootdir</name>
<value>hdfs://raphael/hbase</value>
</property>
<property>
<name>hbase.cluster.distributed</name>
<value>true</value>
</property>
# 配置Zookeeper节点，配置可不加端口
<property>
<name>hbase.zookeeper.quorum</name>
<value>node5,node6,node7</value>
</property>
3）、配置reginservers，数据节点
编辑conf下的regionservers，在该文件中配置HBase的节点，每台节点占一行：
node5 node6 node7
4）、配置HBase环境变量
编辑/root/.bash_profile 在该文件中配置HBase的环境变量：
PATH=$PATH:$HOME/bin JAVA_HOME=/usr/java/jdk1.7.0_79 PATH=$PATH:$JAVA_HOME/bin export JAVA_HOME HADOOP_HOME=/usr/local/hadoop-2.5.1 export HADOOP_HOME HIVE_HOME=/usr/local/apache-hive-1.2.1 export HIVE_HOME HBASE_HOME=/usr/local/hbase-1.1.3 export HBASE_HOME PATH=$PATH:/usr/local/zookeeper-3.4.6/bin/:$HADOOP_HOME/bin/:$HADOOP_HOME/sbin/:$HIVE_HOME/bin/:$HBASE_HOME/bin export PATH
配置完成以后，将HBase分发到其他的HBase节点上：
scp -r /usr/local/hbase root@node6:/usr/local/hbase
5）、启用HBase
#首先启动Zookeeper的节点 $ zkServer.sh start #再启动Hadoop $ start-all.sh #最后启动HBase $ start-hbase.sh
启动完成以后就可以访问 http://节点:16010 来查看了
在关闭节点之前必须先关闭HBase，否则下次启动HBase有可以会出错；
3、使用HBase 和 Hbase使用帮助
1）、进入HBase
#使用命令进入HBase Shell $ hbase shell 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 hbase(main):003:0>
2）、使用HBase帮助
HBase 提供了大量的帮助文档，只要在HBase 下使用命令help就能够查看HBase所有关键字的帮助
hbase(main):003:0> help HBase Shell, version 1.1.3, r72bc50f5fafeb105b2139e42bbee3d61ca724989, Sat Jan 16 18:29:00 PST 2016 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, 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 ...
如果不知道某个关键字如何使用的话，只需要在Hbase下直接建入该关键字即可：
hbase(main):004:0> put
ERROR: wrong number of arguments (0 for 4)
Here is some help for this command:
Put a cell 'value' at specified table/row/column and optionally
timestamp coordinates. To put a cell value into table 'ns1:t1' or 't1'
at row 'r1' under column 'c1' marked with the time 'ts1', do:
hbase> put 'ns1:t1', 'r1', 'c1', 'value'
hbase> put 't1', 'r1', 'c1', 'value'
hbase> put 't1', 'r1', 'c1', 'value', ts1
hbase> put 't1', 'r1', 'c1', 'value', {ATTRIBUTES=>{'mykey'=>'myvalue'}}
hbase> put 't1', 'r1', 'c1', 'value', ts1, {ATTRIBUTES=>{'mykey'=>'myvalue'}}
hbase> put 't1', 'r1', 'c1', 'value', ts1, {VISIBILITY=>'PRIVATE|SECRET'}
The same commands also can be run on a table reference. Suppose you had a reference
t to table 't1', the corresponding command would be:
hbase> t.put 'r1', 'c1', 'value', ts1, {ATTRIBUTES=>{'mykey'=>'myvalue'}}
在HBase 下，如果输入内容错了，使用回退键是不管用的，必须使用Ctrl+回退键才行。
3）、创建表、插入数据、查询数据
进入hbase shell console
$HBASE_HOME/bin/hbase shell
如果有kerberos认证，需要事先使用相应的keytab进行一下认证（使用kinit命令），认证成功之后再使用hbase shell进入可以使用whoami命令可查看当前用户
hbase(main)> whoami
表的管理
1）查看有哪些表
hbase(main)> list
2）创建表
# 语法：create <table>, {NAME => <family>, VERSIONS => <VERSIONS>}
# 例如：创建表t1，有两个family name：f1，f2，且版本数均为2
hbase(main)> create 't1',{NAME => 'f1', VERSIONS => 2},{NAME => 'f2', VERSIONS => 2}
3）删除表
分两步：首先disable，然后drop
例如：删除表t1
hbase(main)> disable 't1'
hbase(main)> drop 't1'
4）查看表的结构
# 语法：describe <table>
# 例如：查看表t1的结构
hbase(main)> describe 't1'
5）修改表结构
修改表结构必须先disable
# 语法：alter 't1', {NAME => 'f1'}, {NAME => 'f2', METHOD => 'delete'}
# 例如：修改表test1的cf的TTL为180天
hbase(main)> disable 'test1'
hbase(main)> alter 'test1',{NAME=>'body',TTL=>'15552000'},{NAME=>'meta', TTL=>'15552000'}
hbase(main)> enable 'test1'
权限管理
1）分配权限
# 语法 : grant <user> <permissions> <table> <column family> <column qualifier> 参数后面用逗号分隔
# 权限用五个字母表示： "RWXCA".
# READ('R'), WRITE('W'), EXEC('X'), CREATE('C'), ADMIN('A')
# 例如，给用户‘test'分配对表t1有读写的权限，
hbase(main)> grant 'test','RW','t1'
2）查看权限
# 语法：user_permission <table>
# 例如，查看表t1的权限列表
hbase(main)> user_permission 't1'
3）收回权限
# 与分配权限类似，语法：revoke <user> <table> <column family> <column qualifier>
# 例如，收回test用户在表t1上的权限
hbase(main)> revoke 'test','t1'
表数据的增删改查
1）添加数据
# 语法：put <table>,<rowkey>,<family:column>,<value>,<timestamp>
# 例如：给表t1的添加一行记录：rowkey是rowkey001，family name：f1，column name：col1，value：value01，timestamp：系统默认
hbase(main)> put 't1','rowkey001','f1:col1','value01'
用法比较单一。
2）查询数据
a）查询某行记录
# 语法：get <table>,<rowkey>,[<family:column>,....]
# 例如：查询表t1，rowkey001中的f1下的col1的值
hbase(main)> get 't1','rowkey001', 'f1:col1'
# 或者：
hbase(main)> get 't1','rowkey001', {COLUMN=>'f1:col1'}
# 查询表t1，rowke002中的f1下的所有列值
hbase(main)> get 't1','rowkey001'
b）扫描表
# 语法：scan <table>, {COLUMNS => [ <family:column>,.... ], LIMIT => num}
# 另外，还可以添加STARTROW、TIMERANGE和FITLER等高级功能
# 例如：扫描表t1的前5条数据
hbase(main)> scan 't1',{LIMIT=>5}
c）查询表中的数据行数
# 语法：count <table>, {INTERVAL => intervalNum, CACHE => cacheNum}
# INTERVAL设置多少行显示一次及对应的rowkey，默认1000；CACHE每次去取的缓存区大小，默认是10，调整该参数可提高查询速度
# 例如，查询表t1中的行数，每100条显示一次，缓存区为500
hbase(main)> count 't1', {INTERVAL => 100, CACHE => 500}
3）删除数据
a )删除行中的某个列值
# 语法：delete <table>, <rowkey>, <family:column> , <timestamp>,必须指定列名
# 例如：删除表t1，rowkey001中的f1:col1的数据
hbase(main)> delete 't1','rowkey001','f1:col1'
注：将删除改行f1:col1列所有版本的数据
b )删除行
# 语法：deleteall <table>, <rowkey>, <family:column> , <timestamp>，可以不指定列名，删除整行数据
# 例如：删除表t1，rowk001的数据
hbase(main)> deleteall 't1','rowkey001'
c）删除表中的所有数据
# 语法： truncate <table>
# 其具体过程是：disable table -> drop table -> create table
# 例如：删除表t1的所有数据
hbase(main)> truncate 't1'
Region管理
1）移动region
# 语法：move 'encodeRegionName', 'ServerName'
# encodeRegionName指的regioName后面的编码，ServerName指的是master-status的Region Servers列表
# 示例
hbase(main)>move '4343995a58be8e5bbc739af1e91cd72d', 'db-41.xxx.xxx.org,60020,1390274516739'
2）开启/关闭region
# 语法：balance_switch true|false
hbase(main)> balance_switch
3）手动split
# 语法：split 'regionName', 'splitKey'
4）手动触发major compaction
#语法：
#Compact all regions in a table:
#hbase> major_compact 't1'
#Compact an entire region:
#hbase> major_compact 'r1'
#Compact a single column family within a region:
#hbase> major_compact 'r1', 'c1'
#Compact a single column family within a table:
#hbase> major_compact 't1', 'c1'
配置管理及节点重启
1）修改hdfs配置
hdfs配置位置：/etc/hadoop/conf
# 同步hdfs配置
cat /home/hadoop/slaves|xargs -i -t scp /etc/hadoop/conf/hdfs-site.xml hadoop@{}:/etc/hadoop/conf/hdfs-site.xml
#关闭：
cat /home/hadoop/slaves|xargs -i -t ssh hadoop@{} "sudo /home/hadoop/cdh4/hadoop-2.0.0-cdh4.2.1/sbin/hadoop-daemon.sh --config /etc/hadoop/conf stop datanode"
#启动：
cat /home/hadoop/slaves|xargs -i -t ssh hadoop@{} "sudo /home/hadoop/cdh4/hadoop-2.0.0-cdh4.2.1/sbin/hadoop-daemon.sh --config /etc/hadoop/conf start datanode"
2）修改hbase配置
hbase配置位置：
# 同步hbase配置
cat /home/hadoop/hbase/conf/regionservers|xargs -i -t scp /home/hadoop/hbase/conf/hbase-site.xml hadoop@{}:/home/hadoop/hbase/conf/hbase-site.xml
# graceful重启
cd ~/hbase
bin/graceful_stop.sh --restart --reload --debug inspurXXX.xxx.xxx.org
HBase 3、HBase练习题
1、建立学生和课程表
要求：学生可以选择多个课程，每个课程可以被多个学生选择。
查询某个学生所选的所有课程列表
查询某个课程，的学生列表
学生可以修改所选的课程
方案：学生与课程之间是多对多关系，那可以建三张表 学生表、课程表、学生课程关系表
查询某个学生所选的所有课程列表：通过学生ID到学生课程表中去匹配RowKey为studentxxx的记录，然后再根据获取到的记录可以得到课程ID(即RowKey_后的部分)；
然后再根据课程ID获取到课程的名称等内容；
查询某个课程，的学生列表：通过课程ID到学生课程表中去匹配RowKey为coursexxx的记录，然后再根据获取到的记录可以得到学生ID(即RowKey_前的部分)；
然后再根据学生ID获取到课程的名称等内容；
学生可以修改所选的课程：学生修改课程，无非有两种情况1.学生新添加了课程；2.学生去掉了课程；因此只要对学生课程表中的数据进行删除或者添加即可；另外两个表数据
不需要做任何更改；
下面是代码：
// 学生表的创建与维护
public class Zuoye2_0 {
public static Connection conn = null;
public static TableName tName = TableName.valueOf("t_student");
public static Random ra = new Random();
@Before
public void init() throws IOException{
Configuration conf = HBaseConfiguration.create();
conf.set("hbase.zookeeper.quorum", "node5,node6,node7");
conn = ConnectionFactory.createConnection(conf);
}
@Test
public void create() throws IOException{
Admin admin = conn.getAdmin();
if(admin.tableExists(tName)){
admin.disableTable(tName);
admin.deleteTable(tName);
}
HTableDescriptor ht = new HTableDescriptor(tName);
HColumnDescriptor hc = new HColumnDescriptor("cf1".getBytes());
hc.setMaxVersions(5);
hc.setBlockCacheEnabled(true);
hc.setBlocksize(180000);
ht.addFamily(hc);
admin.createTable(ht);
System.out.println("表创建完成");
}
@Test
public void insert() throws IOException{
Table table = conn.getTable(tName);
List<Put> putList = new ArrayList<Put>();
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
for(int i=1;i<20;i++){
String id=format.format(new Date());
id=id.replace("-", "").replace(" ", "").replace(":", "");
id = "student"+getRowKey(id);
Put put = new Put(id.getBytes());
String name="Tom"+i;
put.addColumn("cf1".getBytes(), "name".getBytes(), name.getBytes());
putList.add(put);
}
table.put(putList);
System.out.println("数据插入完成");
}
@After
public void after() throws IOException {
if(conn!=null){
conn.close();
}
}
private String getRowKey(String id){
return id+""+ra.nextInt(99999);
}
}
// 课程表的创建与维护
public class Zuoye2_1 {
public static Connection conn = null;
public static TableName tName = TableName.valueOf("t_course");
public static Random ra = new Random();
@Before
public void init() throws IOException{
Configuration conf = HBaseConfiguration.create();
conf.set("hbase.zookeeper.quorum", "node5,node6,node7");
conn = ConnectionFactory.createConnection(conf);
}
@Test
public void create() throws IOException{
Admin admin = conn.getAdmin();
if(admin.tableExists(tName)){
admin.disableTable(tName);
admin.deleteTable(tName);
}
HTableDescriptor ht = new HTableDescriptor(tName);
HColumnDescriptor hc = new HColumnDescriptor("cf1".getBytes());
hc.setMaxVersions(5);
hc.setBlockCacheEnabled(true);
hc.setBlocksize(180000);
ht.addFamily(hc);
admin.createTable(ht);
System.out.println("表创建完成");
}
@Test
public void insert() throws IOException{
Table table = conn.getTable(tName);
List<Put> putList = new ArrayList<Put>();
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
for(int i=1;i<10;i++){
String id=format.format(new Date());
id=id.replace("-", "").replace(" ", "").replace(":", "");
id = "course"+getRowKey(id);
Put put = new Put(id.getBytes());
String name="Course"+i;
put.addColumn("cf1".getBytes(), "name".getBytes(), name.getBytes());
putList.add(put);
}
table.put(putList);
System.out.println("数据插入完成");
}
@After
public void after() throws IOException {
if(conn!=null){
conn.close();
}
}
private String getRowKey(String id){
return id+""+ra.nextInt(99999);
}
}
// http://blog.csdn.net/hugengyong/article/details/38148373
// 学生课程表的维护与查询
public class Zuoye2_2 {
public static Connection conn = null;
public static TableName tName = TableName.valueOf("t_student_course");
public static TableName tStudent = TableName.valueOf("t_student");
public static TableName tCourse = TableName.valueOf("t_course");
public static Random ra = new Random();
@Before
public void init() throws IOException{
Configuration conf = HBaseConfiguration.create();
conf.set("hbase.zookeeper.quorum", "node5,node6,node7");
conn = ConnectionFactory.createConnection(conf);
}
@Test
public void create() throws IOException{
Admin admin = conn.getAdmin();
if(admin.tableExists(tName)){
admin.disableTable(tName);
admin.deleteTable(tName);
}
HTableDescriptor ht = new HTableDescriptor(tName);
HColumnDescriptor hc = new HColumnDescriptor("cf1".getBytes());
hc.setMaxVersions(5);
hc.setBlockCacheEnabled(true);
hc.setBlocksize(180000);
ht.addFamily(hc);
admin.createTable(ht);
System.out.println("表创建完成");
}
@Test
public void insert() throws IOException{
Table table = conn.getTable(tName);
List<Put> putList = new ArrayList<Put>();
//学生1 student2016030421164483174
String stu1 = "student2016030421164483174";
//学生2 student2016030421164417190
String stu2 = "student2016030421164417190";
//学生3 student2016030421164462988
String stu3 = "student2016030421164462988";
//课程1 2 3 course2016030421165195800 course201603042116517244 course2016030421165117240
Put put1 = new Put("student2016030421164483174_course2016030421165195800".getBytes());
put1.addColumn("cf1".getBytes(), "student".getBytes(), stu1.getBytes());
Put put2 = new Put("student2016030421164483174_course201603042116517244".getBytes());
put2.addColumn("cf1".getBytes(), "student".getBytes(), stu1.getBytes());
Put put3 = new Put("student2016030421164483174_course2016030421165117240".getBytes());
put3.addColumn("cf1".getBytes(), "student".getBytes(), stu1.getBytes());
Put put4 = new Put("student2016030421164417190_course2016030421165195800".getBytes());
put4.addColumn("cf1".getBytes(), "student".getBytes(), stu2.getBytes());
Put put5 = new Put("student2016030421164417190_course201603042116517244".getBytes());
put5.addColumn("cf1".getBytes(), "student".getBytes(), stu2.getBytes());
Put put6 = new Put("student2016030421164462988_course2016030421165195800".getBytes());
put6.addColumn("cf1".getBytes(), "student".getBytes(), stu3.getBytes());
putList.add(put1);
putList.add(put2);
putList.add(put3);
putList.add(put4);
putList.add(put5);
putList.add(put6);
table.put(putList);
System.out.println("数据插入完成");
}
//查询某个学生所选的所有课程列表 学生1
@Test
public void findCourseByStudent() throws IOException{
Table table = conn.getTable(tName);
String stuId="student2016030421164483174";
List<String> courseIds =new ArrayList<String>();
Scan scan = new Scan();
RowFilter rf1 = new RowFilter(CompareOp.EQUAL, new RegexStringComparator(stuId+"_"));
scan.setFilter(rf1);
ResultScanner rs1 = table.getScanner(scan);
Iterator<Result> it = rs1.iterator();
while(it.hasNext()){
Result result = it.next();
byte[] rowKey = result.getRow();
courseIds.add(new String(rowKey,"utf8"));
}
for(String id : courseIds){
String courseId = id.split("_")[1];
Table courseTable = conn.getTable(tCourse);
Get get = new Get(courseId.getBytes());
Result result= courseTable.get(get);
byte[] name = result.getValue("cf1".getBytes(), "name".getBytes());
System.out.println("课程ID:"+courseId+" 名称："+new String(name,"utf8"));
}
}
//查询某个课程，的学生列表 课程1
@Test
public void findStudentByCourse() throws IOException{
Table table = conn.getTable(tName);
String courseId="course2016030421165195800";
List<String> studentIds =new ArrayList<String>();
Scan scan = new Scan();
RowFilter rf1 = new RowFilter(CompareOp.EQUAL, new RegexStringComparator("_"+courseId));
scan.setFilter(rf1);
ResultScanner rs1 = table.getScanner(scan);
Iterator<Result> it = rs1.iterator();
while(it.hasNext()){
Result result = it.next();
byte[] rowKey = result.getRow();
studentIds.add(new String(rowKey,"utf8"));
}
for(String id : studentIds){
String stuId = id.split("_")[0];
Table stuTable = conn.getTable(tStudent);
Get get = new Get(stuId.getBytes());
Result result= stuTable.get(get);
byte[] name = result.getValue("cf1".getBytes(), "name".getBytes());
System.out.println("学生ID:"+courseId+" 名字："+new String(name,"utf8"));
}
}
//学生可以修改所选的课程 将学生1的课程1去掉
@Test
public void changeCourseOfStudent() throws IOException{
String stuId="student2016030421164483174";
String courseId="course2016030421165195800";
String scId=stuId+"_"+courseId;
Delete delete = new Delete(scId.getBytes());
Table table = conn.getTable(tName);
table.delete(delete);
}
@After
public void after() throws IOException {
if(conn!=null){
conn.close();
}
}
}
2、建立部门表
要求：部门下有多个子部门。查询所有的顶级部门列表，查询某个部门下所有子部门列表，可以修改一个部门的所属父部门。
方案：
1.在RowKey的设计上把是否是顶级部门带入，例：0_001,1_002 0/1代表是还是是子级部门 0不是 1是 这样可以根据RowKey就能查询出所有的顶级部门
2.在部门表中设计了两个列族 cf1 cf2 在cf2中存储当前部门下的所有子部门；在cf2中存储方式是列名是子部门ID 例值也是子部门ID 例：1_002:1_002
这样可以在不进行又迭代的情况下就可以获取一个部门下的子级部门；只要取出该RowKey的cf2列族下的所有列即可；
3.当修改一个部门的父部门的时候，首先先找到该部门的父部门，先把当前的父部门中的cf2列族下的列删除掉，再到新的部门下的cf2列族下添加一个子部门；最后
再修改当前部门的父ID为新的部门ID
设计如下：
3、根据新浪微博系统：请建立微博系统的表
1.用户表不需要创建，假设用户已经存在，在DBMS中。
2.所有用户可以发微博
3.所有用户可以添加关注用户和取消关注用户
4.所有用户可以查看粉丝列表
5.用户首页，用户所关注的其他用户最新发布的微博列表。
方案：
微博表
rowkey cf1
uid_time_wid content
zs_2015_001
sunliu_2016_002
zs_2016_03050102 content
关注表
cf1 关注的人的id cf2 我的粉丝的id
uid 002=002,
zs 002=002, 004,005
sunlie 004
收件箱表（收取我关注的人发布的最新的微博）
rowkey cf1
uid w_rowkey= set max_version=1000
004 w_rowkey=zs_2015_001 w_rowkey=sunliu_2016_002 w_rowkey=sunliu_2016_003
005 w_rowkey=zs_2015_001
只要xx发布了一条新微博，则系统就会向xx的所有粉丝的收件箱中插一条列w_rowkey的内容作为当前最新版本的值；
在收件箱表中可以设置列 w_rowkey 的保存最多副本数MaxVersions 例：w_rowkey最多可保存1000个副本，那么可以通过时间戳倒序排列，就能获取到最近的我关注的人发布的1000条微博内容的内容ID；
HBase 4、Phoenix安装和Squirrel安装
描述
现有hbase的查询工具有很多如：Hive，Tez，Impala，Shark/Spark，Phoenix等。今天主要记录Phoenix。
phoenix，中文译为“凤凰”，很美的名字。Phoenix是由saleforce.com开源的一个项目，后又捐给了Apache基金会。它相当于一个Java中间件，提供jdbc连接，操作hbase数据表。
但是在生产环境中，不可以用在OLTP中。在线事务处理的环境中，需要低延迟，而Phoenix在查询HBase时，虽然做了一些优化，但延迟还是不小。所以依然是用在OLAT中，再将结果返回存储下来。
Phoenix安装
1、下载Phoenix
下载地址：http://mirror.bit.edu.cn/apache/phoenix/
最新下载的Phoenix文件名中都会标明对应的HBase版本 例: phoenix-4.5.2-HBase-1.1-bin.tar.gz
2、上传压缩包
将phoenix-4.5.2-HBase-1.1-bin.tar.gz 上传hbase集群的其中一个服务器的一个目录下
我上传的目录为/usr/local
3、解压缩文件
tar –zxvf phoenix-4.5.2-HBase-1.1-bin.tar.gz
可看到有个phoenix-4.5.2-HBase-1.1-bin.tar.gz /目录，里面包含了Phoenix的所有文件。
4、配置Phoenix
4.1、将phoenix-4.5.2-HBase-1.1-bin/目录下phoenix-core-4.5.2-HBase-1.1.jar、phoenix-4.5.2-HBase-1.1-server.jar拷贝到各个 hbase的lib目录下。
4.2、将hbase的配置文件hbase-site.xml、 Hadoop/etc/hadoop下的core-site.xml 、hdfs-site.xml放到phoenix-4.5.2-HBase-1.1-bin/bin/下，替换Phoenix原来的 配置文件。
4.3、重启hbase集群，使Phoenix的jar包生效。
5、修改权限
修改phoenix-4.5.2-HBase-1.1-bin/bin/下的psql.py和sqlline.py两个文件的权限为777
命令：chmod 777 文件名
6、验证是否成功
6.1、在phoenix-4.5.2-HBase-1.1-bin/bin/下输入命令：
#端口可以省略 $ ./sqlline.py node5:2181
如果看到如下界面表示启动成功。
6.2、输入!tables，查看都有哪些表。红框部分是用户建的表，其他为Phoenix系统表，系统表中维护了用户表的元数据信息。
6.3、退出Phoenix。输入!exit命令(PS：Phoenix早期版本如(2.11版本)需输入!quilt才可退出，目前高版本已改为!exit命令)=
squirrel安装文档
一．下载安装
从网址http://www.squirrelsql.org/下载相应版本的squirrel的安装jar包，比如下载squirrel-sql-3.7-standard.jar;
Window下安装：
CMD进入Window控制台，输入java -jar squirrel-sql-3.7-standard.jar 显示安装界面：
二．配置连接phonenix
1.配置squirrel
解压的phoenix-4.5.2-HBase-1.1-bin.tar.gz包的主目录下将如下几个jar包拷贝到squirrel安装目录的lib下，例如本机路径是D:\soft\squirrel-sql-3.7\lib
在安装目录下双击squirrel-sql.bat
点击左侧的Drivers，添加图标
在出现的窗口中填写如下项
Name：就是个名字任意取就可以，这里我叫phoenix
Example：jdbc:phoenix:192.168.57.4,192.168.57.5,192.168.57.6:2181(这里是你的phonenix的jdbc地址，注意端口也可以不写，多个用逗号隔开)
Class Name：org.apache.phoenix.jdbc.PhoenixDriver
2.连接phonenix
点击Aiiasses，点击右边的添加图标
出现以下窗口
这里还是名字随意写，driver要选择刚才配置的可用的driver，我们刚才配置的是phonenix
url这里就是连接phonex的url选择了phonenix的driver以后自动出现也可以改，user name就是phonenix连接的主机的用户名，密码就是该机器的密码，点击自动登录
然后点击test，显示连接成功即可（在这里最好不要直接点OK,先点Test，连接成功了再OK）
注意：这里可能链接不上，原因是C:\Windows\System32\drivers\etc下面的hosts文件没有配置路由表，所有要配置一下，如下图
双击创建的连接即可
HBase 5、Phoenix使用
1、建表
执行建表语句 $ ./psql.py localhost:2181 ../examples/stock_symbol.sql 其中../examples/stock_symbol.sql是建表的sql语句 CREATE TABLE IF NOT EXISTS WEB_STAT ( HOST CHAR(2) NOT NULL, DOMAIN VARCHAR NOT NULL, FEATURE VARCHAR NOT NULL, DATE DATE NOT NULL, USAGE.CORE BIGINT,--usage指定列族名 USAGE.DB BIGINT,--usage指定列族名 STATS.ACTIVE_VISITOR INTEGER CONSTRAINT PK PRIMARY KEY (HOST, DOMAIN, FEATURE, DATE)--指定主键 );
2、导入数据
命令：./psql.py -t WEB_STAT localhost:2181 ../examples/web_stat.csv PS：其中 -t 后面是表名， ../examples/web_stat.csv 是csv数据（注意数据的分隔符需要是逗号）。
3、查询数据
首先使用sqlline查看(截图为部分列的数据)，查询表名不区分大小写。
查询1、查询全部记录
语句：select * from web_stat;
查询2、查询记录总条数
语句：select count(1) from web_stat;
查询3、查询结果分组排序
语句：select domain,count(1) as num from web_stat group by domain order by num desc;
查询4、求平均值
语句：select avg(core) from web_stat;
查询5、多字段分组，排序，别名。
语句：select domain,count(1) as num,avg(core) as core,avg(db) as db from web_stat group by domain order by num desc;
查询6、查询日期类型字段
语句：select host,domain,date from web_stat where TO_CHAR(date)='2013-01-15 07:09:01.000';
查询7、字符串，日期类型转换
语句：select TO_DATE('20131125','yyyyMMdd') from web_stat;
Ps：输入的日期字符串会被转换为hbase表date的日期类型。
总结：Phoenix还支持了很多函数和sql语法，在这里不再一一列举。更多请参考Phoenix支持部分
4、Phoenix基本shell命令
PS：以下，可能有部分命令在Phoenix更高版本中已失效，改为其他命令代替，请注意。
0: jdbc:phoenix:localhost> help
!all Execute the specified SQL against all the current connections
!autocommit Set autocommit mode on or off
!batch Start or execute a batch of statements
!brief Set verbose mode off
!call Execute a callable statement
!close Close the current connection to the database
!closeall Close all current open connections
!columns List all the columns for the specified table
!commit Commit the current transaction (if autocommit is off)
!connect Open a new connection to the database.
!dbinfo Give metadata information about the database
!describe Describe a table
!dropall Drop all tables in the current database
!exportedkeys List all the exported keys for the specified table
!go Select the current connection
!help Print a summary of command usage
!history Display the command history
!importedkeys List all the imported keys for the specified table
!indexes List all the indexes for the specified table
!isolation Set the transaction isolation for this connection
!list List the current connections
!manual Display the SQLLine manual
!metadata Obtain metadata information
!nativesql Show the native SQL for the specified statement
!outputformat Set the output format for displaying results
(table,vertical,csv,tsv,xmlattrs,xmlelements)
!primarykeys List all the primary keys for the specified table
!procedures List all the procedures
!properties Connect to the database specified in the properties file(s)
!quit Exits the program 此命令在Phoenix4.3版本已改为!exit
!reconnect Reconnect to the database
!record Record all output to the specified file
!rehash Fetch table and column names for command completion
!rollback Roll back the current transaction (if autocommit is off)
!run Run a script from the specified file
!save Save the current variabes and aliases
!scan Scan for installed JDBC drivers
!script Start saving a script to a file
!set Set a sqlline variable
HBase 6、用Phoenix Java api操作HBase
开发环境准备：eclipse3.5、jdk1.7、window8、hadoop2.2.0、hbase0.98.0.2、phoenix4.3.0
1、从集群拷贝以下文件：core-site.xml、hbase-site.xml、hdfs-site.xml文件放到工程src下
2、把phoenix的phoenix-4.3.0-client.jar和phoenix-core-4.3.0.jar添加到工程classpath
3、配置集群中各节点的hosts文件，把客户端的hostname：IP添加进去
4、在客户端host文件中加入集群的hostname和IP
5、工程截图
例子1：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
import java.sql.Connection;import java.sql.DriverManager;import java.sql.ResultSet;import java.sql.Statement;public class Phoenix_Test { /** * 使用phoenix提供的api操作hbase读取数据 */ public static void main(String[] args) throws Throwable { try { // 下面的驱动为Phoenix老版本使用2.11使用，对应hbase0.94+ // Class.forName("com.salesforce.phoenix.jdbc.PhoenixDriver"); // phoenix4.3用下面的驱动对应hbase0.98+ Class.forName("org.apache.phoenix.jdbc.PhoenixDriver"); } catch (Exception e) { e.printStackTrace(); } // 这里配置zookeeper的地址，可单个，也可多个。可以是域名或者ip String url = "jdbc:phoenix:node5,node6,node7"; // String url = // "jdbc:phoenix:41.byzoro.com,42.byzoro.com,43.byzoro.com:2181"; Connection conn = DriverManager.getConnection(url); Statement statement = conn.createStatement(); String sql = "select count(1) as num from WEB_STAT"; long time = System.currentTimeMillis(); ResultSet rs = statement.executeQuery(sql); while (rs.next()) { int count = rs.getInt("num"); System.out.println("row count is " + count); } long timeUsed = System.currentTimeMillis() - time; System.out.println("time " + timeUsed + "mm"); // 关闭连接 rs.close(); statement.close(); conn.close(); }} |
执行结果：
例子2：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
|
import java.sql.Connection;import java.sql.DriverManager;import java.sql.ResultSet;import java.sql.Statement;public class Phoenix_Test2 { /** * 使用phoenix提供的api操作hbase中读取数据 */ public static void main(String[] args) throws Throwable { try { //下面的驱动为Phoenix老版本使用2.11使用，对应hbase0.94+ //Class.forName("com.salesforce.phoenix.jdbc.PhoenixDriver"); //phoenix4.3用下面的驱动对应hbase0.98+ Class.forName("org.apache.phoenix.jdbc.PhoenixDriver"); } catch (Exception e) { e.printStackTrace(); } //这里配置zk的地址，可单个，也可多个。可以是域名或者ip String url = "jdbc:phoenix:node5,node6,node7"; Connection conn = DriverManager.getConnection(url); Statement statement = conn.createStatement(); String sql = "select * from web_stat where core = 1"; long time = System.currentTimeMillis(); ResultSet rs = statement.executeQuery(sql); while (rs.next()) { //获取core字段值 int core = rs.getInt("core"); //获取core字段值 String host = rs.getString("host"); //获取domain字段值 String domain = rs.getString("domain"); //获取feature字段值 String feature = rs.getString("feature"); //获取date字段值,数据库中字段为Date类型，这里代码会自动转化为string类型 String date = rs.getString("date"); //获取db字段值 String db = rs.getString("db"); System.out.println("host:"+host+"\tdomain:"+domain+"\tfeature:"+feature+"\tdate:"+date+"\tcore:" + core+"\tdb:"+db); } long timeUsed = System.currentTimeMillis() - time; System.out.println("time " + timeUsed + "mm"); //关闭连接 rs.close(); statement.close(); conn.close(); }} |
执行结果：
1、HBase底层原理
1.1、系统架构
上面这张图是有一个错误点：应该是每一个 RegionServer 就只有一个 HLog，而不是一个 Region 有一个 HLog。下面这张图是正确的。
Client职责
1、HBase 有两张特殊表:
.META.：记录了用户所有表拆分出来的的 Region 映射信息，.META.可以有多个 Regoin
-ROOT-：记录了.META.表的 Region 信息，-ROOT-只有一个 Region，无论如何不会分裂
2、Client 访问用户数据前需要首先访问 ZooKeeper，找到-ROOT-表的 Region 所在的位置，然后访问-ROOT-表，接着访问.META.表，最后才能找到用户数据的位置去访问，中间需要多次网络操作，不过 client 端会做 cache 缓存。
ZooKeeper职责
1、ZooKeeper 为 HBase 提供 Failover 机制，选举 Master，避免单点 Master 单点故障问题
2、存储所有 Region 的寻址入口:-ROOT-表在哪台服务器上。-ROOT-这张表的位置信息
3、实时监控 RegionServer 的状态，将 RegionServer 的上线和下线信息实时通知给 Master
4、存储 HBase 的 Schema，包括有哪些 Table，每个 Table 有哪些 Column Family
Master职责
1、为 RegionServer 分配 Region
2、负责 RegionServer 的负载均衡
3、发现失效的 RegionServer 并重新分配其上的 Region
4、HDFS 上的垃圾文件(HBase)回收
5、处理 Schema 更新请求(表的创建，删除，修改，列簇的增加等等)
RegionServer职责
1、 RegionServer 维护 Master 分配给它的 Region，处理对这些 Region 的 IO 请求
2、负责和底层的文件系统 HDFS 的交互，存储数据到 HDFS
3、负责 Store 中的 HFile 的合并工作
4、RegionServer 负责 Split 在运行过程中变得过大的 Region，负责 Compact 操作
可以看到，client 访问 HBase 上数据的过程并不需要 Master 参与(寻址访问 ZooKeeper 和RegioneServer，数据读写访问 RegioneServer)，Master 仅仅维护者 Table 和 Region 的元数据信息，负载很低。
.META. 存的是所有的 Region 的位置信息，那么 RegioneServer 当中 Region 在进行分裂之后 的新产生的 Region，是由 Master 来决定发到哪个 RegioneServer，这就意味着，只有 Master知道 new Region 的位置信息，所以，由 Master 来管理.META.这个表当中的数据的 CRUD
所以结合以上两点表明，在没有 Region 分裂的情况，Master 宕机一段时间是可以忍受的。
1.2、物理存储
1.2.1、整体物理结构
1、Table 中的所有行都按照 RowKsey 的字典序排列。
2、Table 在行的方向上分割为多个 HRegion。
3、HRegion 按大小分割的(默认 10G)，每个表一开始只有一个 HRegion，随着数据不断插入 表，HRegion 不断增大，当增大到一个阀值的时候，HRegion 就会等分会两个新的 HRegion。 当表中的行不断增多，就会有越来越多的 HRegion。
4、HRegion 是 Hbase 中分布式存储和负载均衡的最小单元。最小单元就表示不同的 HRegion可以分布在不同的 HRegionServer 上。但一个 HRegion 是不会拆分到多个 server 上的。
5、HRegion 虽然是负载均衡的最小单元，但并不是物理存储的最小单元。事实上，HRegion由一个或者多个 Store 组成，每个 Store 保存一个 Column Family。每个 Strore 又由一个MemStore 和 0 至多个 StoreFile 组成
1.2.2、StoreFile 和HFile结构
StoreFile 以 HFile 格式保存在 HDFS 上，请看下图 HFile 的数据组织格式：
首先 HFile 文件是不定长的，长度固定的只有其中的两块：Trailer 和 FileInfo。 正如图中所示：Trailer 中有指针指向其他数据块的起始点。FileInfo 中记录了文件的一些 Meta 信息，例如：AVG_KEY_LEN, AVG_VALUE_LEN, LAST_KEY, COMPARATOR, MAX_SEQ_ID_KEY 等。
HFile 分为六个部分:
Data Block 段–保存表中的数据，这部分可以被压缩
Meta Block 段 (可选的)–保存用户自定义的 kv 对，可以被压缩。
File Info 段–Hfile 的元信息，不被压缩，用户也可以在这一部分添加自己的元信息。
Data Block Index 段–Data Block 的索引。每条索引的 key 是被索引的 block 的第一条记录的key。
Meta Block Index 段 (可选的)–Meta Block 的索引。
Trailer 段–这一段是定长的。保存了每一段的偏移量，读取一个 HFile 时，会首先读取 Trailer，Trailer 保存了每个段的起始位置(段的 Magic Number 用来做安全 check)，然后，DataBlock Index会被读取到内存中，这样，当检索某个 key 时，不需要扫描整个 HFile，而只需从内存中找 到 key 所在的 block，通过一次磁盘 io 将整个 block 读取到内存中，再找到需要的 key。DataBlock Index 采用 LRU 机制淘汰。
HFile 的 Data Block，Meta Block 通常采用压缩方式存储，压缩之后可以大大减少网络 IO 和磁 盘 IO，随之而来的开销当然是需要花费 cpu 进行压缩和解压缩。
目标 Hfile 的压缩支持两种方式:Gzip，LZO。
Data Index 和 Meta Index 块记录了每个 Data 块和 Meta 块的起始点。
Data Block 是 HBase I/O 的基本单元，为了提高效率，HRegionServer 中有基于 LRU 的 Block Cache 机制。每个 Data 块的大小可以在创建一个 Table 的时候通过参数指定，大号的 Block有利于顺序 Scan，小号 Block 利于随机查询。 每个 Data 块除了开头的 Magic 以外就是一个 个 KeyValue 对拼接而成, Magic 内容就是一些随机数字，目的是防止数据损坏。
HFile 里面的每个 KeyValue 对就是一个简单的 byte 数组。但是这个 byte 数组里面包含了很 多项，并且有固定的结构。我们来看看里面的具体结构：
开始是两个固定长度的数值，分别表示 Key 的长度和 Value 的长度。紧接着是 Key，开始是 固定长度的数值，表示 RowKey 的长度，紧接着是 RowKey，然后是固定长度的数值，表示Family 的长度，然后是 Family，接着是 Qualifier，然后是两个固定长度的数值，表示 TimeStamp和 KeyType(Put/Delete)。Value 部分没有这么复杂的结构，就是纯粹的二进制数据了。
1.2.3、MemStore 和 StoreFile
一个 HRegion 由多个 Store 组成，每个 Store 包含一个列族的所有数据
Store 包括位于内存的一个 Memstore 和位于硬盘的多个 Storefile 组成
写操作先写入 Memstore，当 Memstore 中的数据量达到某个阈值，HRegionServer 启动flushcache 进程写入 Storefile，每次写入形成单独一个 HFile
当总 Storefile 大小超过一定阈值后，会把当前的 Region 分割成两个，并由 HMaster 分配给 相应的 Region 服务器，实现负载均衡
客户端检索数据时，先在 Memstore 找，找不到再找 Storefile
1.2.4、HLog（WAL）
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，需要将 RegionServer 上的 log 进行拆分，然后分发到其它 region server 上进行恢复。
HLog 文件就是一个普通的 Hadoop Sequence File:
1、HLog Sequence File 的 Key 是 HLogKey 对象，HLogKey 中记录了写入数据的归属信息，除 了 table 和 region 名字外，同时还包括 sequence number 和 timestamp，timestamp 是”写入 时间”，sequence number 的起始值为 0，或者是最近一次存入文件系统中 sequence number。
2、HLog Sequece File 的 Value 是 HBase 的 KeyValue 对象，即对应 HFile 中的 KeyValue
1.3、寻址机制
既然读写都在 RegionServer 上发生，我们前面有讲到，每个 RegionSever 为一定数量的 Region服务，那么 Client 要对某一行数据做读写的时候如何能知道具体要去访问哪个 RegionServer呢?那就是接下来我们要讨论的问题
1.3.1、老的Region寻址方式
在 HBase-0.96 版本以前，HBase 有两个特殊的表，分别是-ROOT-表和.META.表，其中-ROOT-的位置存储在 ZooKeeper 中，-ROOT-本身存储了.META. Table 的 RegionInfo 信息，并且-ROOT-不会分裂，只有一个 Region。而.META.表可以被切分成多个 Region。读取的流程如下图所示：
详细步骤：
第 1 步:Client 请求 ZooKeeper 获得-ROOT-所在的 RegionServer 地址
第 2 步:Client 请求-ROOT-所在的 RS 地址，获取.META.表的地址，Client 会将-ROOT-的相关 信息 cache 下来，以便下一次快速访问
第 3 步:Client 请求.META.表的 RegionServer 地址，获取访问数据所在 RegionServer 的地址，Client 会将.META.的相关信息 cache 下来，以便下一次快速访问
第 4 步:Client 请求访问数据所在 RegionServer 的地址，获取对应的数据
从上面的路径我们可以看出，用户需要 3 次请求才能直到用户 Table 真正的位置，这在一定 程序带来了性能的下降。在 0.96 之前使用 3 层设计的主要原因是考虑到元数据可能需要很 大。但是真正集群运行，元数据的大小其实很容易计算出来。在 BigTable 的论文中，每行METADATA 数据存储大小为 1KB 左右，如果按照一个 Region 为 128M 的计算，3 层设计可以 支持的 Region 个数为 2^34 个，采用 2 层设计可以支持 2^17(131072)。那么 2 层设计的情 况下一个集群可以存储 4P 的数据。这仅仅是一个 Region 只有 128M 的情况下。如果是 10G呢? 因此，通过计算，其实 2 层设计就可以满足集群的需求。因此在 0.96 版本以后就去掉了-ROOT-表了。
1.3.2、新的Region寻址方式
如上面的计算，2 层结构其实完全能满足业务的需求，因此 0.96 版本以后将-ROOT-表去掉了。 如下图所示:
访问路径变成了 3 步：
第 1 步:Client 请求 ZooKeeper 获取.META.所在的 RegionServer 的地址。
第 2 步:Client 请求.META.所在的 RegionServer 获取访问数据所在的 RegionServer 地址，Client会将.META.的相关信息 cache 下来，以便下一次快速访问。
第 3 步:Client 请求数据所在的 RegionServer，获取所需要的数据。
总结去掉-ROOT-的原因有如下 2 点：其一，提高性能；其二，2层结构已经足以满足集群的需求。
这里还有一个问题需要说明，那就是 Client 会缓存.META.的数据，用来加快访问，既然有缓 存，那它什么时候更新?如果.META.更新了，比如 Region1 不在 RerverServer2 上了，被转移 到了 RerverServer3 上。Client 的缓存没有更新会有什么情况?
其实，Client 的元数据缓存不更新，当.META.的数据发生更新。如上面的例子，由于 Region1的位置发生了变化，Client 再次根据缓存去访问的时候，会出现错误，当出现异常达到重试 次数后就会去.META.所在的 RegionServer 获取最新的数据，如果.META.所在的 RegionServer也变了，Client 就会去 ZooKeeper 上获取.META.所在的 RegionServer 的最新地址。
1.4、读写过程
1.4.1、读请求过程
1、客户端通过 ZooKeeper 以及-ROOT-表和.META.表找到目标数据所在的 RegionServer（就是数据所在的Region的主机地址）
2、联系 RegionServer 查询目标数据
3、RegionServer 定位到目标数据所在的 Region，发出查询请求
4、Region 先在 Memstore 中查找，命中则返回
5、如果在 Memstore 中找不到，则在 Storefile 中扫描。为了能快速的判断要查询的数据在不在这个 StoreFile 中，应用了 BloomFilter
(BloomFilter，布隆过滤器:迅速判断一个元素是不是在一个庞大的集合内，但是他有一个 弱点:它有一定的误判率) (误判率:原本不存在与该集合的元素，布隆过滤器有可能会判断说它存在，但是，如果 布隆过滤器，判断说某一个元素不存在该集合，那么该元素就一定不在该集合内)
1.4.2、写请求过程
1、Client 先根据 RowKey 找到对应的 Region 所在的 RegionServer
2、Client 向 RegionServer 提交写请求
3、RegionServer 找到目标 Region
4、Region 检查数据是否与 Schema 一致
5、如果客户端没有指定版本，则获取当前系统时间作为数据版本6、将更新写入 WAL Log
7、将更新写入 Memstore
8、判断 Memstore 的是否需要 flush 为 StoreFile 文件。
Hbase 在做数据插入操作时，首先要找到 RowKey 所对应的的 Region，怎么找到的?其实这 个简单，因为.META.表存储了每张表每个 Region 的起始 RowKey 了。
建议：在做海量数据的插入操作，避免出现递增 rowkey 的 put 操作
如果 put 操作的所有 RowKey 都是递增的，那么试想，当插入一部分数据的时候刚好进行分 裂，那么之后的所有数据都开始往分裂后的第二个 Region 插入，就造成了数据热点现象。
细节描述：HBase 使用 MemStore 和 StoreFile 存储对表的更新。
数据在更新时首先写入 HLog(WAL Log)，再写入内存(MemStore)中，MemStore 中的数据是排 序的，当 MemStore 累计到一定阈值(默认是 128M)时，就会创建一个新的 MemStore，并且 将老的 MemStore 添加到 flush 队列，由单独的线程 flush 到磁盘上，成为一个 StoreFile。于 此同时，系统会在 ZooKeeper 中记录一个 redo point，表示这个时刻之前的变更已经持久化 了。当系统出现意外时，可能导致内存(MemStore)中的数据丢失，此时使用HLog(WAL Log)来恢复 checkpoint 之后的数据。
StoreFile 是只读的，一旦创建后就不可以再修改。因此 HBase 的更新/修改其实是不断追加 的操作。当一个 Store 中的 StoreFile 达到一定的阈值后，就会进行一次合并(minor_compact, major_compact)，将对同一个 key 的修改合并到一起，形成一个大的 StoreFile，当 StoreFile的大小达到一定阈值后，又会对 StoreFile 进行 split，等分为两个 StoreFile。由于对表的更新是不断追加的，compact 时，需要访问 Store 中全部的 StoreFile 和 MemStore，将他们按rowkey 进行合并，由于 StoreFile 和 MemStore 都是经过排序的，并且 StoreFile 带有内存中 索引，合并的过程还是比较快。
Minor_Compact 和 Major_Compact 的区别：
1）Minor 操作只用来做部分文件的合并操作以及包括 minVersion=0 并且设置 ttl 的过期版 本清理，不做任何删除数据、多版本数据的清理工作。
2）Major 操作是对 Region 下的 HStore 下的所有 StoreFile 执行合并操作，最终的结果是整 理合并出一个文件。
Client 写入 -> 存入 MemStore，一直到 MemStore 满 -> Flush 成一个 StoreFile，直至增长到 一定阈值 -> 触发 Compact 合并操作 -> 多个 StoreFile 合并成一个 StoreFile，同时进行版本 合并和数据删除 -> 当StoreFilesCompact后，逐步形成越来越大的StoreFile-> 单个StoreFile大小超过一定阈值后，触发 Split 操作，把当前 Region Split 成 2 个 Region，Region 会下线， 新 Split 出的 2 个孩子 Region 会被 HMaster 分配到相应的 HRegionServer 上，使得原先 1 个Region 的压力得以分流到 2 个 Region 上由此过程可知，HBase 只是增加数据，所有的更新 和删除操作，都是在 Compact 阶段做的，所以，用户写操作只需要进入到内存即可立即返 回，从而保证 I/O 高性能。
写入数据的过程补充：
工作机制：每个 HRegionServer 中都会有一个 HLog 对象，HLog 是一个实现 Write Ahead Log的类，每次用户操作写入 Memstore 的同时，也会写一份数据到 HLog 文件，HLog 文件定期 会滚动出新，并删除旧的文件(已持久化到 StoreFile 中的数据)。当 HRegionServer 意外终止 后，HMaster 会通过 ZooKeeper 感知，HMaster 首先处理遗留的 HLog 文件，将不同 Region的 log 数据拆分，分别放到相应 Region 目录下，然后再将失效的 Region(带有刚刚拆分的 log) 重新分配，领取到这些 Region 的 HRegionServer 在 load Region 的过程中，会发现有历史 HLog需要处理，因此会 Replay HLog 中的数据到 MemStore 中，然后 flush 到 StoreFiles，完成数据 恢复。
1.5、RegionServer工作机制
1、Region分配
任何时刻，一个 Region 只能分配给一个 RegionServer。master 记录了当前有哪些可用的RegionServer。以及当前哪些 Region 分配给了哪些 RegionServer，哪些 Region 还没有分配。 当需要分配的新的 Region，并且有一个 RegionServer 上有可用空间时，Master 就给这个RegionServer 发送一个装载请求，把 Region 分配给这个 RegionServer。RegionServer 得到请 求后，就开始对此 Region 提供服务。
2、RegionServer上线
Master 使用 zookeeper 来跟踪 RegionServer 状态。当某个 RegionServer 启动时，会首先在ZooKeeper 上的 server 目录下建立代表自己的 znode。由于 Master 订阅了 server 目录上的变 更消息，当 server 目录下的文件出现新增或删除操作时，Master 可以得到来自 ZooKeeper的实时通知。因此一旦 RegionServer 上线，Master 能马上得到消息。
3、RegionServer下线
当 RegionServer 下线时，它和 zookeeper 的会话断开，ZooKeeper 而自动释放代表这台 server的文件上的独占锁。Master 就可以确定：
RegionServer 和 ZooKeeper 之间的网络断开了。
RegionServer 挂了。
无论哪种情况，RegionServer 都无法继续为它的 Region 提供服务了，此时 Master 会删除 server目录下代表这台 RegionServer 的 znode 数据，并将这台 RegionServer 的 Region 分配给其它还 活着的同志。
1.6、Master工作机制
Master 上线
Master 启动进行以下步骤:
1、从 ZooKeeper 上获取唯一一个代表 Active Master 的锁，用来阻止其它 Master 成为 Master。
2、扫描 ZooKeeper 上的 server 父节点，获得当前可用的 RegionServer 列表。
3、和每个 RegionServer 通信，获得当前已分配的 Region 和 RegionServer 的对应关系。
4、扫描.META. Region 的集合，计算得到当前还未分配的 Region，将他们放入待分配 Region列表。
Master 下线
由于 Master 只维护表和 Region 的元数据，而不参与表数据 IO 的过程，Master 下线仅导致所有元数据的修改被冻结(无法创建删除表，无法修改表的 schema，无法进行 Region的负载均衡，无法处理 Region 上下线，无法进行 Region 的合并，唯一例外的是 Region 的 split可以正常进行，因为只有 RegionServer 参与)，表的数据读写还可以正常进行。因此 Master下线短时间内对整个 hbase 集群没有影响。
从上线过程可以看到，Master 保存的信息全是可以冗余信息(都可以从系统其它地方 收集到或者计算出来)
因此，一般 HBase 集群中总是有一个 Master 在提供服务，还有一个以上的 Master 在等 待时机抢占它的位置。
2、HBase高级应用
2.1、建表高级属性
下面几个 shell 命令在 HBase 操作中可以起到很好的作用，且主要体现在建表的过程中，看 下面几个 create 属性
1、BLOOMFILTER(布隆过滤器)
默认是 NONE 是否使用布隆过虑及使用何种方式，布隆过滤可以每列簇单独启用
使用 HColumnDescriptor.setBloomFilterType(NONE | ROW | ROWCOL) 对列族单独启用布隆，Default = ROW 对行进行布隆过滤
对 ROW，行键的哈希在每次插入行时将被添加到布隆
对 ROWCOL，行键 + 列族 + 列族修饰的哈希将在每次插入行时添加到布隆
使用方法：create 'table',{NAME => 'baseinfo' BLOOMFILTER => 'ROW'}
作用：用布隆过滤可以节省读磁盘过程，可以有助于降低读取延迟
2、VERSIONS(版本号)
默认是 1 ，这个参数的意思是数据保留 1 个 版本，如果我们认为我们的数据没有这么大的必要保留这么多，随时都在更新，而老版本的数据对我们毫无价值，那将此参数设为 1 能 节约 2/3 的空间。
使用方法:：create 'table',{ NAME => 'baseinfo' VERSIONS=>'2'}
附：MIN_VERSIONS => '0'是说在 compact 操作执行之后，至少要保留的版本，只有在设 置了 TTL 的时候生效
3、COMPRESSION(压缩)
默认值是 NONE ，即不使用压缩，这个参数意思是该列族是否采用压缩，采用什么压缩算法。
方法： create 'table',{NAME=>'info',COMPRESSION=>'SNAPPY'} ，建议采用 SNAPPY 压缩算 法 ，HBase 中，在 Snappy 发布之前(Google 2011 年对外发布 Snappy)，采用的 LZO 算法， 目标是达到尽可能快的压缩和解压速度，同时减少对 CPU 的消耗;
在 Snappy 发布之后，建议采用 Snappy 算法(参考《HBase: The Definitive Guide》)，具体 可以根据实际情况对 LZO 和 Snappy 做过更详细的对比测试后再做选择。
Algorithm
% remaining
Encoding
Decoding
GZIP
13.4% 21 MB/s 118 MB/s
LZO
20.5% 135 MB/s 410 MB/s
Zippy/Snappy 22.2% 172 MB/s 409 MB/s
如果建表之初没有压缩，后来想要加入压缩算法，可以通过 alter 修改 schema。
4、TTL(Time To Live)
默认是 2147483647，即Integer.MAX_VALUE 值，大概是 68 年，这个参数是说明该列族数据的存活时间，单位是 s，这个参数可以根据具体的需求对数据设定存活时间，超过存活时间的数据将不在表中显示，待下次 major compact 的时候再彻底删除数据。需要注意的是， TTL 设定之后 MIN_VERSIONS=>'0' 这样设置之后，TTL 时间戳过期后，将全部彻底删除该 family 下所有的数据，如果 MIN_VERSIONS 不等于 0 那将保留最新的MIN_VERSIONS 个版本的数据，其它的全部删除，比如MIN_VERSIONS=>'1' 届时将保留一个 最新版本的数据，其它版本的数据将不再保存。
5、Alter(修改表)
使用方法：如修改压缩算法
disable 'table'
alter 'table',{NAME=>'info',COMPRESSION=>'snappy'}
enable 'table'
但是需要执行 major_compact 'table' 命令之后 才会做实际的操作。
6、describe/desc(查看表详细信息)
这个命令查看了 create table 的各项参数或者是默认值。使用方式：describe 'user_info'
7、disable_all/enable_all
disable_all 'toplist.*' ，disable_all 支持正则表达式，并列出当前匹配的表的如下:
toplist_a_total_1001
toplist_a_total_1002
toplist_a_total_1008
toplist_a_total_1009
toplist_a_total_1019
toplist_a_total_1035
...
Disable the above 25 tables (y/n)? 并给出确认提示
8、drop_all
这个命令和 disable_all 的使用方式是一样的。
9、HBase 预分区
默认情况下，在创建 HBase 表的时候会自动创建一个 region 分区，当导入数据的时候，所有的 HBase 客户端都向这一个 region 写数据，直到这个 region 足够大了才进行切分。一 种可以加快批量写入速度的方法是通过预先创建一些空的 regions，这样当数据写入 HBase时，会按照 region 分区情况，在集群内做数据的负载均衡。
命令方式：
# create table with specific split points
hbase>create 'table1','f1',SPLITS => ['\x10\x00', '\x20\x00', '\x30\x00', '\x40\x00']
# create table with four regions based on random bytes keys
hbase>create 'table2','f1', { NUMREGIONS => 8 , SPLITALGO => 'UniformSplit' }
# create table with five regions based on hex keys
hbase>create 'table3','f1', { NUMREGIONS => 10, SPLITALGO => 'HexStringSplit' }
也可以使用 api 的方式：
hbase org.apache.hadoop.hbase.util.RegionSplitter test_table HexStringSplit -c 10 -f info
hbase org.apache.hadoop.hbase.util.RegionSplitter splitTable HexStringSplit -c 10 -f info
参数：
test_table 是表名
HexStringSplit 是 split 方式
-c 是分 10 个 region
-f 是 family
可在 UI 上查看结果，如图：
这样就可以将表预先分为 15 个区，减少数据达到 storefile 大小的时候自动分区的时间消耗，并且还有以一个优势，就是合理设计 rowkey 能让各个 region 的并发请求平均分配(趋于均匀) 使 IO 效率达到最高，但是预分区需要将 filesize 设置一个较大的值，设置哪个参数 呢 hbase.hregion.max.filesize 这个值默认是 10G 也就是说单个 region 默认大小是 10G。
这个参数的默认值在 0.90 到 0.92 到 0.94.3 各版本的变化:256M--1G--10G
但是如果 MapReduce Input 类型为 TableInputFormat 使用 hbase 作为输入的时候，就要注意 了，每个 region 一个 map，如果数据小于 10G 那只会启用一个 map 造成很大的资源浪费， 这时候可以考虑适当调小该参数的值，或者采用预分配 region 的方式，并将检测如果达到 这个值，再手动分配 region。
2.2、表设计
1、列簇设计
追求的原则是：在合理范围内能尽量少的减少列簇就尽量减少列簇。
最优设计是：将所有相关性很强的 key-value 都放在同一个列簇下，这样既能做到查询效率最高，也能保持尽可能少的访问不同的磁盘文件。
以用户信息为例，可以将必须的基本信息存放在一个列族，而一些附加的额外信息可以放在另一列族。
2、RowKey设计
HBase 中，表会被划分为 1...n 个 Region，被托管在 RegionServer 中。Region 两个重要的属性：StartKey 与 EndKey 表示这个 Region 维护的 rowKey 范围，当我们要读/写数据时，如 果 rowKey 落在某个 start-end key 范围内，那么就会定位到目标 region 并且读/写到相关的数据。那怎么快速精准的定位到我们想要操作的数据，就在于我们的 rowkey 的设计了。
Rowkey 设计三原则
一、rowkey长度原则
Rowkey 是一个二进制码流，Rowkey 的长度被很多开发者建议说设计在 10~100 个字节，不过建议是越短越好，不要超过 16 个字节。
原因如下:
1、数据的持久化文件 HFile 中是按照 KeyValue 存储的，如果 Rowkey 过长比如 100 个字节，1000 万列数据光 Rowkey 就要占用 100*1000 万=10 亿个字节，将近 1G 数据，这会极大影响 HFile 的存储效率;
2、MemStore 将缓存部分数据到内存，如果 Rowkey 字段过长内存的有效利用率会降低， 系统将无法缓存更多的数据，这会降低检索效率。因此 Rowkey 的字节长度越短越好。
3、目前操作系统是都是 64 位系统，内存 8 字节对齐。控制在 16 个字节，8 字节的整数倍利用操作系统的最佳特性。
二、rowkey散列原则
如果 Rowkey 是按时间戳的方式递增，不要将时间放在二进制码的前面，建议将 Rowkey的高位作为散列字段，由程序循环生成，低位放时间字段，这样将提高数据均衡分布在每个Regionserver 实现负载均衡的几率。如果没有散列字段，首字段直接是时间信息将产生所有 新数据都在一个 RegionServer 上堆积的热点现象，这样在做数据检索的时候负载将会集中在个别 RegionServer，降低查询效率。
三、rowkey唯一原则
必须在设计上保证其唯一性。rowkey 是按照字典顺序排序存储的，因此，设计 rowkey的时候，要充分利用这个排序的特点，将经常读取的数据存储到一块，将最近可能会被访问的数据放到一块。
数据热点
HBase 中的行是按照 rowkey 的字典顺序排序的，这种设计优化了 scan 操作，可以将相关的行以及会被一起读取的行存取在临近位置，便于 scan。然而糟糕的 rowkey 设计是热点的源头。 热点发生在大量的 client 直接访问集群的一个或极少数个节点(访问可能是读， 写或者其他操作)。大量访问会使热点 region 所在的单个机器超出自身承受能力，引起性能 下降甚至 region 不可用，这也会影响同一个 RegionServer 上的其他 region，由于主机无法服 务其他 region 的请求。 设计良好的数据访问模式以使集群被充分，均衡的利用。 为了避免写热点，设计 rowkey 使得不同行在同一个 region，但是在更多数据情况下，数据 应该被写入集群的多个 region，而不是一个。
防止数据热点的有效措施
1、加盐
这里所说的加盐不是密码学中的加盐，而是在 rowkey 的前面增加随机数，具体就是给rowkey 分配一个随机前缀以使得它和之前的 rowkey 的开头不同。分配的前缀种类数量应该 和你想使用数据分散到不同的 region 的数量一致。加盐之后的 rowkey 就会根据随机生成的 前缀分散到各个 region 上，以避免热点。
2、哈希
哈希会使同一行永远用一个前缀加盐。哈希也可以使负载分散到整个集群，但是读却是可以预测的。使用确定的哈希可以让客户端重构完整的 rowkey，可以使用 get 操作准确获取 某一个行数据。
3、反转
第三种防止热点的方法是反转固定长度或者数字格式的 rowkey。这样可以使得 rowkey中经常改变的部分(最没有意义的部分)放在前面。这样可以有效的随机 rowkey，但是牺 牲了 rowkey 的有序性。反转 rowkey 的例子以手机号为 rowkey，可以将手机号反转后的字符串作为 rowkey，这 样的就避免了以手机号那样比较固定开头导致热点问题
4、时间戳反转
一个常见的数据处理问题是快速获取数据的最近版本，使用反转的时间戳作为 rowkey的一部分对这个问题十分有用，可以用 Long.Max_Value - timestamp 追加到 key 的末尾，例 如 [key][reverse_timestamp] , [key] 的最新值可以通过 scan [key]获得[key]的第一条记录，因 为 HBase 中 rowkey 是有序的，第一条记录是最后录入的数据。比如需要保存一个用户的操作记录，按照操作时间倒序排序，在设计 rowkey 的时候，可以这样设计[userId 反转][Long.Max_Value - timestamp]，在查询用户的所有操作记录数据的时候，直接指定反转后的 userId ， startRow 是 [userId 反 转 ][000000000000],stopRow 是 [userId 反 转][Long.Max_Value - timestamp]。
如果需要查询某段时间的操作记录，startRow 是[user 反转][Long.Max_Value - 起始时间]，stopRow 是[userId 反转][Long.Max_Value - 结束时间]
————————————————
版权声明：本文为CSDN博主「编程有了模型」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_1018944104/article/details/85375484
