第1章 HBase简介
1.1 HBase定义
HBase是一种分布式、可扩展、支持海量数据存储的NoSQL数据库。
1.2 HBase数据模型
逻辑上，HBase的数据模型同关系型数据库很类似，数据存储在一张表中，有行有列。但从HBase的底层物理存储结构（K-V）来看，HBase更像是一个multi-dimensional map（多维地图）。
1.2.1 HBase逻辑结构
1.2.2 HBase物理存储结构
1.2.3 数据模型
1）Name Space
命名空间，类似于关系型数据库的database概念，每个命名空间下有多个表。HBase两个自带的命名空间，分别是hbase和default，hbase中存放的是HBase内置的表，default表是用户默认使用的命名空间。一个表可以自由选择是否有命名空间，如果创建表的时候加上了命名空间后，这个表名字以<Namespace>:<Table>作为区分。
2）Table
类似于关系型数据库的表概念。不同的是，HBase定义表时只需要声明列族即可，不需要声明具体的列。这意味着，往HBase写入数据时，字段可以动态、按需指定。因此，和关系型数据库相比，HBase能够轻松应对字段变更的场景。
3）Row
HBase表中的每行数据都由一个RowKey和多个Column（列）组成，数据是按照RowKey的字典顺序存储的，并且查询数据时只能根据RowKey进行检索，所以RowKey的设计十分重要。
4) RowKey
Rowkey由用户指定的一串不重复的字符串定义，是一行的唯一标识！数据是按照RowKey的字典顺序存储的，并且查询数据时只能根据RowKey进行检索，所以RowKey的设计十分重要。
如果使用了之前已经定义的RowKey，那么会将之前的数据更新掉。
5）Column Family
列族是多个列的集合。一个列族可以动态地灵活定义多个列。表的相关属性大部分都定义在列族上，同一个表里的不同列族可以有完全不同的属性配置，但是同一个列族内的所有列都会有相同的属性。
列族存在的意义是HBase会把相同列族的列尽量放在同一台机器上，所以说，如果想让某几个列被放到一起，你就给他们定义相同的列族。
官方建议一张表的列族定义的越少越好，列族太多会极大程度地降低数据库性能，且目前版本Hbase的架构，容易出BUG。
6) Column Qualifier
Hbase中的列是可以随意定义的，一个行中的列不限名字、不限数量，只限定列族。因此列必须依赖于列族存在！列的名称前必须带着其所属的列族！例如info：name，info：age。
因为HBase中的列全部都是灵活的，可以随便定义的，因此创建表的时候并不需要指定列！列只有在你插入第一条数据的时候才会生成。其他行有没有当前行相同的列是不确定，只有在扫描数据的时候才能得知。
7）Time Stamp
用于标识数据的不同版本（version），每条数据写入时，系统会自动为其加上该字段，其值为写入HBase的时间。在读取单元格的数据时，版本号可以省略，如果不指定，Hbase默认会获取最后一个版本的数据返回。
8）Cell
由{rowkey, column Family：column Qualifier, time Stamp} 唯一确定的单元。cell中的数据全部是字节码形式存贮。
9）Region
Region由一个表的若干行组成。在Region中行的排序按照行键（rowkey）字典排序。Region不能跨RegionSever，且当数据量大的时候，HBase会拆分Region。
Region由RegionServer进程管理。HBase在进行负载均衡的时候，一个Region有可能会从当前RegionServer移动到其他RegionServer上。
Region是基于HDFS的，它的所有数据存取操作都是调用了HDFS的客户端接口来实现的。
1.3 HBase基本架构
架构角色：
1）Region Server
Region Server为 Region的管理者，其实现类为HRegionServer，主要作用如下:
- 对于数据的操作：get, put, delete；
- 对于Region的操作：splitRegion、compactRegion。
2）Master
Master是所有Region Server的管理者，其实现类为HMaster，主要作用如下：
-
- 对于表的操作：create, delete, alter
- 对于RegionServer的操作：分配regions到每个RegionServer，监控每个RegionServer的状态，负载均衡和故障转移。
3）Zookeeper
HBase通过Zookeeper来做master的高可用、RegionServer的监控、元数据的入口以及集群配置的维护等工作。
4）HDFS
HDFS为HBase提供最终的底层数据存储服务，同时为HBase提供高容错的支持。
第2章 HBase快速入门
2.1 HBase安装部署
2.1.1 Zookeeper正常部署
首先保证Zookeeper集群的正常部署，并启动之：
[atguigu@hadoop102 zookeeper-3.5.7]$ bin/zkServer.sh start
[atguigu@hadoop103 zookeeper-3.5.7]$ bin/zkServer.sh start
[atguigu@hadoop104 zookeeper-3.5.7]$ bin/zkServer.sh start
2.1.2 Hadoop正常部署
Hadoop集群的正常部署并启动。
[atguigu@hadoop102 hadoop-3.1.3]$ sbin/start-dfs.sh
[atguigu@hadoop103 hadoop-3.1.3]$ sbin/start-yarn.sh
2.1.3 HBase的解压
1）解压Hbase到指定目录。
[atguigu@hadoop102 software]$ tar -zxvf hbase-2.0.5-bin.tar.gz -C /opt/module
[atguigu@hadoop102 software]$ mv /opt/module/hbase-2.0.5 /opt/module/hbase
2）配置环境变量
[atguigu@hadoop102 ~]$ sudo vim /etc/profile.d/my_env.sh
添加
#HBASE_HOME
export HBASE_HOME=/opt/module/hbase
export PATH=$PATH:$HBASE_HOME/bin
2.1.4 HBase的配置文件
修改HBase对应的配置文件。
1）hbase-env.sh修改内容：
export HBASE_MANAGES_ZK=false
2）hbase-site.xml修改内容：
<configuration>
<property>
<name>hbase.rootdir</name>
<value>hdfs://hadoop102:8020/hbase</value>
</property>
<property>
<name>hbase.cluster.distributed</name>
<value>true</value>
</property>
<property>
<name>hbase.zookeeper.quorum</name>
<value>hadoop102,hadoop103,hadoop104</value>
</property>
<property>
<name>hbase.unsafe.stream.capability.enforce</name>
<value>false</value>
</property>
<property>
<name>hbase.wal.provider</name>
<value>filesystem</value>
</property>
</configuration>
3）regionservers：
hadoop102
hadoop103
hadoop104
2.1.5 HBase远程发送到其他集群
[atguigu@hadoop102 module]$ xsync hbase/
2.1.6 HBase服务的启动
1）单点启动
[atguigu@hadoop102 hbase]$ bin/hbase-daemon.sh start master
[atguigu@hadoop102 hbase]$ bin/hbase-daemon.sh start regionserver
注意：如果集群之间的节点时间不同步，会导致regionserver无法启动，抛出ClockOutOfSyncException异常。
修复提示：
（1）同步时间服务
请参看帮助文档：《尚硅谷大数据技术之Hadoop入门》
（2）属性：hbase.master.maxclockskew设置更大的值
<property>
<name>hbase.master.maxclockskew</name>
<value>180000</value>
<description>Time difference of regionserver from master</description>
</property>
2）群启
[atguigu@hadoop102 hbase]$ bin/start-hbase.sh
对应的停止服务：
[atguigu@hadoop102 hbase]$ bin/stop-hbase.sh
2.1.7 查看HBase页面
启动成功后，可以通过“host:port”的方式来访问HBase管理页面，例如：
2.1.8 高可用（可选）
在HBase中HMaster负责监控HRegionServer的生命周期，均衡RegionServer的负载，如果HMaster挂掉了，那么整个HBase集群将陷入不健康的状态，并且此时的工作状态并不会维持太久。所以HBase支持对HMaster的高可用配置。
1）关闭HBase集群（如果没有开启则跳过此步）
[atguigu@hadoop102 hbase]$ bin/stop-hbase.sh
2）在conf目录下创建backup-masters文件
[atguigu@hadoop102 hbase]$ touch conf/backup-masters
3）在backup-masters文件中配置高可用HMaster节点
[atguigu@hadoop102 hbase]$ echo hadoop103 > conf/backup-masters
4）将整个conf目录scp到其他节点
[atguigu@hadoop102 hbase]$ xsync conf
5）重启hbase,打开页面测试查看
2.2 HBase Shell操作
2.2.1 基本操作
1）进入HBase客户端命令行
[atguigu@hadoop102 hbase]$ bin/hbase shell
2）查看帮助命令
hbase(main):001:0> help
3）查看当前数据库中有哪些表
hbase(main):002:0> list
2.2.2 表的操作
1）创建表
hbase(main):002:0> create 'student','info'
2）插入数据到表
hbase(main):003:0> put 'student','1001','info:sex','male'
hbase(main):004:0> put 'student','1001','info:age','18'
hbase(main):005:0> put 'student','1002','info:name','Janna'
hbase(main):006:0> put 'student','1002','info:sex','female'
hbase(main):007:0> put 'student','1002','info:age','20'
3）扫描查看表数据
hbase(main):008:0> scan 'student'
hbase(main):009:0> scan 'student',{STARTROW => '1001', STOPROW => '1001'}
hbase(main):010:0> scan 'student',{STARTROW => '1001'}
4）查看表结构
hbase(main):011:0> describe 'student'
5）更新指定字段的数据
hbase(main):012:0> put 'student','1001','info:name','Zhangsan'
hbase(main):013:0> put 'student','1001','info:age','100'
6）查看“指定行”或“指定列族:列”的数据
hbase(main):014:0> get 'student','1001'
hbase(main):015:0> get 'student','1001','info:name'
7）统计表数据行数
hbase(main):021:0> count 'student'
8）删除数据
（1）删除某rowkey的全部数据：
hbase(main):016:0> deleteall 'student','1001'
（2）删除某rowkey的某一列数据：
hbase(main):017:0> delete 'student','1002','info:sex'
9）清空表数据
hbase(main):018:0> truncate 'student'
提示：清空表的操作顺序为先disable，然后再truncate。
10）删除表
（1）首先需要先让该表为disable状态：
hbase(main):019:0> disable 'student'
（2）然后才能drop这个表：
hbase(main):020:0> drop 'student'
提示：如果直接drop表，会报错：ERROR: Table student is enabled. Disable it first.
11）变更表信息
将info列族中的数据存放3个版本：
hbase(main):022:0> alter 'student',{NAME=>'info',VERSIONS=>3}
hbase(main):022:0> get 'student','1001',{COLUMN=>'info:name',VERSIONS=>3}
第3章 HBase进阶
3.1 RegionServer 架构
1）StoreFile
保存实际数据的物理文件，StoreFile以Hfile的形式存储在HDFS上。每个Store会有一个或多个StoreFile（HFile），数据在每个StoreFile中都是有序的。
2）MemStore
写缓存，由于HFile中的数据要求是有序的，所以数据是先存储在MemStore中，排好序后，等到达刷写时机才会刷写到HFile，每次刷写都会形成一个新的HFile。
3）HLog
由于数据要经MemStore排序后才能刷写到HFile，但把数据保存在内存中会有很高的概率导致数据丢失，为了解决这个问题，数据会先写在一个实现了Write-Ahead logfile机制的文件HLog中，然后再写入MemStore中。所以在系统出现故障的时候，数据可以通过这个日志文件重建。
4）BlockCache
读缓存，每次查询出的数据会缓存在BlockCache中，方便下次查询。
3.2 写流程
写流程：
1）Client先访问zookeeper，获取hbase:meta表位于哪个Region Server。
2）访问对应的Region Server，获取hbase:meta表，根据写请求的namespace:table/rowkey，查询出目标数据位于哪个Region Server中的哪个Region中。并将该table的region信息以及meta表的位置信息缓存在客户端的meta cache，方便下次访问。
3）与目标Region Server进行通讯；
4）将数据顺序写入（追加）到HLog；
5）将数据写入对应的MemStore，数据会在MemStore进行排序；
6）向客户端发送ack；
7）等达到MemStore的刷写时机后，将数据刷写到HFile。
3.3 MemStore Flush
3.3.1 Memstore级别
当某个memstroe的大小达到了hbase.hregion.memstore.flush.size（默认值128M），其所在region的所有memstore都会刷写。因此不建议创建太多的列族。
3.3.2 Region级别
当一个Region中所有的memstore的大小达到了hbase.hregion.memstore.flush.size（默认值128M） * hbase.hregion.memstore.block.multiplier（默认值4）时，会阻止继续往该Region写数据，进行所有Memstore的刷写。
3.3.3 RegionServer级别
一个RegionServer中的阈值大于 java_heapsize * hbase.regionserver.global.memstore.size（默认值0.4）* hbase.regionserver.global.memstore.size.lower.limit（默认值0.95）。region会按照其所有memstore的大小顺序（由大到小）依次进行刷写。直到region server中所有memstore的总大小减小到上述值以下。
当regionserver中memstore的总大小达到java_heapsize * hbase.regionserver.global.memstore.size（默认值0.4）时，会阻止继续往所有的memstore写数据。
3.3.4 HLog数量上限
当WAL文件的数量超过hbase.regionserver.max.logs，region会按照时间顺序依次进行刷写，直到WAL文件数量减小到hbase.regionserver.max.log以下（该属性名已经废弃，现无需手动设置，最大值为32）
3.3.5 定时刷写
到达自动刷写的时间，也会触发memstore flush。自动刷新的时间间隔由该属性进行配置hbase.regionserver.optionalcacheflushinterval（默认1小时）
3.3.6 手动刷写
可以在客户端手动flush 表名 或 region名 或regionserver名
3.4 读流程
3.4.1 寻找RegionServer
1）Client先访问zookeeper，获取hbase:meta表位于哪个Region Server。
2）访问对应的Region Server，获取hbase:meta表，根据读请求的namespace:table/rowkey，查询出目标数据位于哪个Region Server中的哪个Region中。并将该table的region信息以及meta表的位置信息缓存在客户端的meta cache，方便下次访问。
3）向目标Region Server发送读请求；
3.4.2 RegionServer返回数据
读流程
4）分别在MemStore和Store File（HFile）中查询目标数据，并将查到的所有数据进行合并。此处所有数据是指同一条数据的不同版本（time stamp）或者不同的类型（Put/Delete）。
5）将查询到的新的数据块（Block，HFile数据存储单元，默认大小为64KB）缓存到Block Cache。
6）将合并后的最终结果返回给客户端。
3.5 StoreFile Compaction
由于memstore每次刷写都会生成一个新的HFile，且同一个字段的不同版本（timestamp）和不同类型（Put/Delete）有可能会分布在不同的HFile中，因此查询时需要遍历所有的HFile。为了减少HFile的个数，以及清理掉过期和删除的数据，会进行StoreFile Compaction。
Compaction分为两种，分别是Minor Compaction和Major Compaction。Minor Compaction会将临近的若干个较小的HFile合并成一个较大的HFile，并清理掉部分过期和删除的数据。Major Compaction会将一个Store下的所有的HFile合并成一个大HFile，并且会清理掉所有过期和删除的数据。
3.6 Region Split
默认情况下，每个Table起初只有一个Region，随着数据的不断写入，Region会自动进行拆分。刚拆分时，两个子Region都位于当前的Region Server，但处于负载均衡的考虑，HMaster有可能会将某个Region转移给其他的Region Server。
3.6.1 0.94版本之前的策略
0.94版本之前采取的是 ConstantSizeRegionSplitPolicy , 当一个Store（对应一个列族）的StoreFile大小大于配置 hbase.hregion.max.filesize（默认10G）时就会拆分
3.6.2 0.94版本之后的策略
0.94版本之后的切分策略取决于hbase.regionserver.region.split.policy参数的配置，默认使用IncreasingToUpperBoundRegionSplitPolicy策略切分region。
该策略分为两种情况，第一种为如果在当前RegionServer中某个Table的Region个数介于 0-100之间，那么当1个region中的某个Store下所有StoreFile的总大小超过Min(initialSize*R^3 ,hbase.hregion.max.filesize")，该Region就会进行拆分。其中initialSize的默认值为2*hbase.hregion.memstore.flush.size，R为当前Region Server中属于该Table的Region个数。
具体的切分策略为：
第一次split：1^3 * 256 = 256MB
第二次split：2^3 * 256 = 2048MB
第三次split：3^3 * 256 = 6912MB
第四次split：4^3 * 256 = 16384MB > 10GB，因此取较小的值10GB
后面每次split的size都是10GB了。
第二种为如果当前RegionServer中某个Table的Region个数超过100个，则超过10GB才会切分一次region
3.6.3 2.0版本之后的策略
Hbase 2.0引入了新的split策略：SteppingSplitPolicy。如果当前RegionSer ver上该表只有一个Region，按照2 * hbase.hregion.memstore.flush.size分裂，否则按照hbase.hregion.max.filesize分裂。
3.6.4 禁止分裂
region的分裂需要消耗一定的性能，因此如果对region已经提前预分区，那么可以设置禁止region自动分裂，即使用DisableSplitPolicy。
第4章 HBase API
4.1 环境准备
新建项目后在pom.xml中添加依赖。
注意：可能会报错javax.el包不存在，不用管，是一个测试用的依赖，不影响使用。
<dependencies>
<dependency>
<groupId>org.apache.hbase</groupId>
<artifactId>hbase-server</artifactId>
<version>2.0.5</version>
<exclusions>
<exclusion>
<groupId>org.glassfish</groupId>
<artifactId>javax.el</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.apache.hbase</groupId>
<artifactId>hbase-client</artifactId>
<version>2.0.5</version>
</dependency>
<dependency>
<groupId>org.glassfish</groupId>
<artifactId>javax.el</artifactId>
<version>3.0.1-b06</version>
</dependency>
</dependencies>
4.2 创建连接
客户端连接HBase集群进行读写时，需要先连接HBase集群所使用的zookeeper，因此在resources目录中添加客户端使用的hbase-site.xml配置文件，添加zk集群地址信息:
<property>
<name>hbase.zookeeper.quorum</name>
<value>hadoop102,hadoop103,hadoop104</value>
</property>
public class HBaseUtil {
private Connection connection;
{
try {
connection = ConnectionFactory.createConnection();
} catch (IOException e) {
e.printStackTrace();
}
}
public void closeConn() throws IOException {
if (connection != null){
connection.close();
}
}
}
4.3 使用连接
4.3.1 获取Table对象
public Table getTable(String tableName) throws IOException {
// isBlank 判断一个字符串是否是 null,"","回车,空格白字符"
if (StringUtils.isBlank(tableName)){
throw new RuntimeException("表名非法!");
}
Table table = connection.getTable(TableName.valueOf(tableName));
return table;
}
4.3.2 Put
定义Put对象:
/*
定义一个返回Put对象的方法
Put对象封装了要操作的Cell
Put 表名，rowkey，列族名，列名，value
*/
public Put createPut(String rowkey,String cf,String cq,String value){
Put put = new Put(Bytes.toBytes(rowkey));
// java语法糖 A.() return A
return put.addColumn(Bytes.toBytes(cf), Bytes.toBytes(cq), Bytes.toBytes(value));
}
/*
Put t1，a3，f1，name，jack
Put t1，a3，f1，age，20
Put t1，a3，f1，gender，male
*/
@Test
public void testPut() throws IOException {
//有一张表
Table table = hbu.getTable("t1");
//put一次就调用表的一次put方法，或也可以批量操作
ArrayList<Put> puts = new ArrayList<>();
puts.add(hbu.createPut("a3","f1","name","jack"));
puts.add(hbu.createPut("a3","f1","age","20"));
puts.add(hbu.createPut("a3","f1","gender","male"));
//批量插入多个cell
table.put(puts);
table.close();
}
4.3.3 Get
/*
Get t1 a3
*/
@Test
public void testGet() throws IOException {
//有一张表
Table table = hbu.getTable("t1");
//封装一个Get对象，代表一次Get操作
Get get = new Get(Bytes.toBytes("a3"));
// 一行查询的结果
Result result = table.get(get);
hbu.parseResult(result);
table.close();
}
4.3.4 遍历扫描结果
/*
遍历Get的一行结果
一行由若干列组成，每个列都有若干个cell
*/
public void parseResult(Result result){
//获取一行中最原始的cell
Cell[] cells = result.rawCells();
//遍历
for (Cell cell : cells) {
System.out.println("rowkey："+Bytes.toString(CellUtil.cloneRow(cell)));
System.out.println("列名"+Bytes.toString(CellUtil.cloneFamily(cell))+ ":"+Bytes.toString(CellUtil.cloneQualifier(cell)));
System.out.println("值:"+Bytes.toString(CellUtil.cloneValue(cell)));
}
}
4.3.5 Scan
@Test
public void testScan() throws IOException {
//有一张表
Table table = hbu.getTable("t1");
//封装一个Scan对象，代表一次Scan操作
Scan scan = new Scan();
scan.withStartRow(Bytes.toBytes("a1"));
scan.withStopRow(Bytes.toBytes("z1"));
// scaner是多行查询的结果
ResultScanner scanner = table.getScanner(scan);
for (Result result : scanner) {
hbu.parseResult(result);
}
table.close();
}
4.3.5 Delete
@Test
public void testDelete() throws IOException {
//有一张表
Table table = hbu.getTable("t1");
Delete delete = new Delete(Bytes.toBytes("a3"));
// 删一列的最新版本 向指定的列添加一个cell(type=Delete,ts=最新的cell的ts)
// delete.addColumn(Bytes.toBytes("f1"), Bytes.toBytes("age"));
// 删除这列的所有版本 向指定的列添加一个cell(type=DeleteColumn,ts=当前时间)
//delete.addColumns(Bytes.toBytes("f1"), Bytes.toBytes("age"));
// 删除列族的所有版本 向指定的行添加一个cell f1:, timestamp=当前时间, type=DeleteFamily
//delete.addFamily(Bytes.toBytes("f1"));
// 删除一行的所有列族
table.delete(delete);
table.close();
}
第5章 HBase使用设计
5.1 预分区
每一个region维护着startRow与endRowKey，如果加入的数据符合某个region维护的rowKey范围，则该数据交给这个region维护。那么依照这个原则，我们可以将数据所要投放的分区提前大致的规划好，以提高HBase性能。
1）手动设定预分区
create 'staff1','info', SPLITS => ['1000','2000','3000','4000']
2）生成16进制序列预分区
create 'staff2','info',{NUMREGIONS => 15, SPLITALGO => 'HexStringSplit'}
3）按照文件中设置的规则预分区
创建splits.txt文件内容如下：
aaaa
bbbb
cccc
dddd
然后执行：
create 'staff3', 'info',SPLITS_FILE => 'splits.txt'
5.2 RowKey设计
一条数据的唯一标识就是rowkey，那么这条数据存储于哪个分区，取决于rowkey处于哪个region的区间内，设计rowkey的主要目的 ，就是让数据均匀的分布于所有的region中，在一定程度上防止数据倾斜。接下来我们就谈一谈如何让rowkey足够散列。
1．生成随机数、hash、散列值
| 原本rowKey为1001的，SHA1后变成：dd01903921ea24941c26a48f2cec24e0bb0e8cc7 原本rowKey为3001的，SHA1后变成：49042c54de64a1e9bf0b33e00245660ef92dc7bd 原本rowKey为5001的，SHA1后变成：7b61dec07e02c188790670af43e717f0f46e8913 |
2．字符串反转
| 20170524000001转成10000042507102 20170524000002转成20000042507102 |
3．字符串拼接
| a12e_20170524000001 93i7_20170524000001 |
rowkey的设计案例，请参考: rowkey设计原则案例.zip
5.3 内存优化
HBase操作过程中需要大量的内存开销，毕竟Table是可以缓存在内存中的，但是不建议分配非常大的堆内存，因为GC过程持续太久会导致RegionServer处于长期不可用状态，一般16~36G内存就可以了，如果因为框架占用内存过高导致系统内存不足，框架一样会被系统服务拖死。
内存优化需要修改HBase家目录conf中的hbase-env.sh文件
#对master和regionserver都有效
export HBASE_HEAPSIZE=1G
#只对master有效
export HBASE_MASTER_OPTS=自定义的jvm虚拟机参数
#只对regionserver有效
export HBASE_REGIONSERVER_OPTS=自定义的jvm虚拟机参数
5.4 基础优化
1）设置RPC监听数量
hbase-site.xml
属性：hbase.regionserver.handler.count
解释：默认值为30，用于指定RPC监听的数量，可以根据客户端的请求数进行调整，读写请求较多时，增加此值。
2）手动控制Major Compaction
hbase-site.xml
属性：hbase.hregion.majorcompaction
解释：默认值：604800000秒（7天）， Major Compaction的周期，若关闭自动Major Compaction，可将其设为0
3）优化HStore文件大小
hbase-site.xml
属性：hbase.hregion.max.filesize
解释：默认值10737418240（10GB），如果需要运行HBase的MR任务，可以减小此值，因为一个region对应一个map任务，如果单个region过大，会导致map任务执行时间过长。该值的意思就是，如果HFile的大小达到这个数值，则这个region会被切分为两个Hfile。
4）优化HBase客户端缓存
hbase-site.xml
属性：hbase.client.write.buffer
解释：默认值2097152bytes（2M）用于指定HBase客户端缓存，增大该值可以减少RPC调用次数，但是会消耗更多内存，反之则反之。一般我们需要设定一定的缓存大小，以达到减少RPC次数的目的。
5）指定scan.next扫描HBase所获取的行数
hbase-site.xml
属性：hbase.client.scanner.caching
解释：用于指定scan.next方法获取的默认行数，值越大，消耗内存越大。
6）BlockCache占用RegionServer堆内存的比例
hbase-site.xml
属性：hfile.block.cache.size
解释：默认0.4，读请求比较多的情况下，可适当调大
7）MemStore占用RegionServer堆内存的比例
hbase-site.xml
属性：hbase.regionserver.global.memstore.size
解释：默认0.4，写请求较多的情况下，可适当调大
第6章 整合Phoenix
6.1 Phoenix简介
6.1.1 Phoenix定义
Phoenix是HBase的开源SQL皮肤。可以使用标准JDBC API代替HBase客户端API来创建表，插入数据和查询HBase数据。
优点：使用简单，直接能写sql。
缺点：效率没有自己设计rowKey再使用API高，性能较差。
6.1.2 Phoenix架构
6.2 Phoenix快速入门
6.2.1 安装
1）官网地址
2）Phoenix部署
（1）上传并解压tar包
[atguigu@hadoop102 module]$ tar -zxvf apache-phoenix-5.0.0-HBase-2.0-bin.tar.gz -C /opt/module/
[atguigu@hadoop102 module]$ mv apache-phoenix-5.0.0-HBase-2.0-bin phoenix
（2）复制server包并拷贝到各个节点的hbase/lib
[atguigu@hadoop102 module]$ cd /opt/module/phoenix/
[atguigu@hadoop102 phoenix]$ cp /opt/module/phoenix/phoenix-5.0.0-HBase-2.0-server.jar /opt/module/hbase/lib/
[atguigu@hadoop102 phoenix]$ xsync /opt/module/hbase/lib/phoenix-5.0.0-HBase-2.0-server.jar
（3）配置环境变量
#phoenix
export PHOENIX_HOME=/opt/module/phoenix
export PHOENIX_CLASSPATH=$PHOENIX_HOME
export PATH=$PATH:$PHOENIX_HOME/bin
- 在hbase-site.xml中添加支持二级索引的参数(如果不需要创建二级索引，不用不加)。之后分发到所有regionserver的节点上。
<property>
<name>hbase.regionserver.wal.codec</name>
<value>org.apache.hadoop.hbase.regionserver.wal.IndexedWALEditCodec</value>
</property>
<property>
<name>hbase.region.server.rpc.scheduler.factory.class</name>
<value>org.apache.hadoop.hbase.ipc.PhoenixRpcSchedulerFactory</value>
<description>Factory to create the Phoenix RPC Scheduler that uses separate queues for index and metadata updates</description>
</property>
<property>
<name>hbase.rpc.controllerfactory.class</name>
<value>org.apache.hadoop.hbase.ipc.controller.ServerRpcControllerFactory</value>
<description>Factory to create the Phoenix RPC Scheduler that uses separate queues for index and metadata updates</description>
</property>
（5）重启HBase
[atguigu@hadoop102 ~]$ stop-hbase.sh
[atguigu@hadoop102 ~]$ start-hbase.sh
（6）连接Phoenix
[atguigu@hadoop101 phoenix]$ /opt/module/phoenix/bin/sqlline.py hadoop102,hadoop103,hadoop104:2181
6.2.2 数据关系映射
Phoenix 将 HBase 的数据模型映射到关系型模型中。
Phoenix中的主键会作为rowkey，非主键列作为普通字段。默认使用0作为列族，也可以在建表时使用 列族.列名 作为字段名，显式指定列族。
如果主键是联合主键，则会将主键字段拼接作为rowkey。
6.2.3 Phoenix Shell操作
!table 或 !tables
2）创建表
直接指定单个列作为RowKey
CREATE TABLE IF NOT EXISTS student(
id VARCHAR primary key,
name VARCHAR,
addr VARCHAR)
;
在phoenix中，表名等会自动转换为大写，若要小写，使用双引号，如"us_population"。
指定多个列的联合作为RowKey
CREATE TABLE IF NOT EXISTS us_population (
State CHAR(2) NOT NULL,
City VARCHAR NOT NULL,
Population BIGINT
CONSTRAINT my_pk PRIMARY KEY (state, city))
;
注意：Phoenix中建表，会在HBase中创建一张对应的表。为了减少数据对磁盘空间的占用，Phoenix默认会对HBase中的列名做编码处理。具体规则可参考官网链接：Storage Formats | Apache Phoenix，若不想对列名编码，可在建表语句末尾加上COLUMN_ENCODED_BYTES = 0;
例如:
CREATE TABLE IF NOT EXISTS student(
id VARCHAR primary key,
name VARCHAR,
addr VARCHAR)
COLUMN_ENCODED_BYTES = 0
;
CREATE TABLE IF NOT EXISTS us_population (
State CHAR(2) NOT NULL,
City VARCHAR NOT NULL,
Population BIGINT
CONSTRAINT my_pk PRIMARY KEY (state, city))
COLUMN_ENCODED_BYTES = 0
;
- 插入或更新数据
upsert执行时，判断如果主键存在就更新，不存在则执行插入。
upsert into student values('1001','zhangsan','beijing');
4）查询记录
select * from student;
select * from student where id='1001';
5）删除记录
delete from student where id='1001';
6）删除表
drop table student;
7）退出命令行
!quit
6.2.4 Phoenix JDBC操作
1.胖客户端
胖客户端指将Phoenix的所有功能都集成在客户端，导致客户端代码打包后体积过大。
1）maven依赖
<dependencies>
<dependency>
<groupId>org.apache.phoenix</groupId>
<artifactId>phoenix-core</artifactId>
<version>5.0.0-HBase-2.0</version>
<exclusions>
<exclusion>
<groupId>org.glassfish</groupId>
<artifactId>javax.el</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-common</artifactId>
<version>2.7.2</version>
</dependency>
</dependencies>
2）编写代码
import java.sql.*;
import java.util.Properties;
public class TestThickClient {
public static void main(String[] args) throws SQLException {
// 1.添加链接
String url = "jdbc:phoenix:hadoop102,hadoop103,hadoop104:2181";
// 2.获取连接
Connection connection = DriverManager.getConnection(url);
// 3.编译SQL语句
PreparedStatement preparedStatement = connection.prepareStatement("select * from student");
// 4.执行语句
ResultSet resultSet = preparedStatement.executeQuery();
// 5.输出结果
while (resultSet.next()){
System.out.println(resultSet.getString(1) + ":" + resultSet.getString(2) + ":" + resultSet.getString(3));
}
// 6.关闭资源
connection.close();
}
}
- 瘦客户端
瘦客户端指将Phoenix的功能进行拆解，主要功能由服务端提供，只使用轻量级的客户端向服务端发送请求。
（1）启动query server
[atguigu@hadoop102 ~]$ queryserver.py start
（2）maven依赖
<dependencies>
<dependency>
<groupId>org.apache.phoenix</groupId>
<artifactId>phoenix-queryserver-client</artifactId>
<version>5.0.0-HBase-2.0</version>
</dependency>
</dependencies>
（3）编写代码
import org.apache.phoenix.queryserver.client.ThinClientUtil;
import java.sql.*;
public class TestThinClient {
public static void main(String[] args) throws SQLException {
// 1. 直接从瘦客户端获取链接
String hadoop102 = ThinClientUtil.getConnectionUrl("hadoop102", 8765);
// 2. 获取连接
Connection connection = DriverManager.getConnection(hadoop102);
// 3.编译SQL语句
PreparedStatement preparedStatement = connection.prepareStatement("select * from student");
// 4.执行语句
ResultSet resultSet = preparedStatement.executeQuery();
// 5.输出结果
while (resultSet.next()){
System.out.println(resultSet.getString(1) + ":" + resultSet.getString(2) + ":" + resultSet.getString(3));
}
// 6.关闭资源
connection.close();
}
}
6.3 Phoenix二级索引
6.3.1 为什么需要二级索引
在HBase中查询时，必须指定rowkey。但是在Phoenix中，可以通过sql语句进行查询，在编写sql语句时，有事我们可能在不使用主键的情况下，进行过滤查询。此时好比是不使用rowkey，直接查询某一列。这样必须对某个表进行全表扫描，才能查询到指定的数据，效率低。
二级索引是针对列的索引，通过建立二级索引，可以在不使用主键进行查询的场景中提升查询效率。
6.3.2 全局索引（global index）
Global Index是默认的索引格式，创建全局索引时，会在HBase中建立一张新表。也就是说索引数据和数据表是存放在不同的表中的，因此全局索引适用于多读少写的业务场景。
写数据的时候会消耗大量开销，因为索引表也要更新，而索引表是分布在不同的数据节点上的，跨节点的数据传输带来了较大的性能消耗。
在读数据的时候Phoenix会选择索引表来降低查询消耗的时间。
1）创建单个字段的全局索引
CREATE INDEX my_index ON my_table (my_col);
如果想查询的字段不是索引字段的话索引表不会被使用，也就是说不会带来查询速度的提升。
6.3.3 包含索引（covered index）
包含索引会将指定的列作为rowkey，包含的列作为普通列建立索引。
1）创建携带其他字段的全局索引
CREATE INDEX my_index ON my_table (v1) INCLUDE (v2);
6.3.4 本地索引（local index）
Local Index适用于写操作频繁的场景。
在数据表中新建一个列族来存储索引数据。避免了在写操作的时候往不同服务器的索引表中写索引带来的额外开销。
CREATE LOCAL INDEX my_index ON my_table (my_column);
扫一扫
2607
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
