HBase介绍
HBase是一种分布式、可扩展、支持海量数据存储的NoSQL数据库。逻辑上，HBase的数据模型同关系型数据库很类似，数据存储在一张表中，有行有列。但从HBase的底层物理存储结构（K-V）来看，HBase更像是一个multi-dimensional map(多维地图)。1）Name Space命名空间，类似于关系型数据库的database概念，每个命名空间下有多个表。HBase两个自带的命名空间
第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表是用户默认使用的命名空间。
2）Table
类似于关系型数据库的表概念。不同的是，HBase定义表时只需要声明列族即可，不需要声明具体的列。这意味着，往HBase写入数据时，字段可以动态、按需指定。因此，和关系型数据库相比，HBase能够轻松应对字段变更的场景。
3）Row
HBase表中的每行数据都由一个RowKey和多个Column（列）组成，数据是按照RowKey的字典顺序存储的，并且查询数据时只能根据RowKey进行检索，所以RowKey的设计十分重要。
4）Column
HBase中的每个列都由Column Family(列族)和Column Qualifier（列限定符）进行限定，例如info：name，info：age。建表时，只需指明列族，而列限定符无需预先定义。
5）Time Stamp
用于标识数据的不同版本（version），每条数据写入时，系统会自动为其加上该字段，其值为写入HBase的时间。
6）Cell
由{rowkey, column Family：column Qualifier, time Stamp} 唯一确定的单元。cell中的数据全部是字节码形式存贮。
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 RegionServer 架构
1）StoreFile
保存实际数据的物理文件，StoreFile以Hfile的形式存储在HDFS上。每个Store会有一个或多个StoreFile（HFile），数据在每个StoreFile中都是有序的。
2）MemStore
写缓存，由于HFile中的数据要求是有序的，所以数据是先存储在MemStore中，排好序后，等到达刷写时机才会刷写到HFile，每次刷写都会形成一个新的HFile。
3）WAL
由于数据要经MemStore排序后才能刷写到HFile，但把数据保存在内存中会有很高的概率导致数据丢失，为了解决这个问题，数据会先写在一个叫做Write-Ahead logfile的文件中，然后再写入MemStore中。所以在系统出现故障的时候，数据可以通过这个日志文件重建。
4）BlockCache
读缓存，每次查询出的数据会缓存在BlockCache中，方便下次查询。
2.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）将数据顺序写入（追加）到WAL；
5）将数据写入对应的MemStore，数据会在MemStore进行排序；
6）向客户端发送ack；
7）等达到MemStore的刷写时机后，将数据刷写到HFile。
2.3 MemStore Flush
MemStore刷写时机：
1.当某个memstroe的大小达到了hbase.hregion.memstore.flush.size（默认值128M），其所在region的所有memstore 都会刷写。
当memstore的大小达到了
hbase.hregion.memstore.flush.size（默认值128M）
* hbase.hregion.memstore.block.multiplier（默认值4）
时，会阻止继续往该memstore写数据。
2.当region server中memstore的总大小达到
java_heapsize
*hbase.regionserver.global.memstore.size（默认值0.4）
*hbase.regionserver.global.memstore.size.lower.limit（默认值0.95），
region会按照其所有memstore的大小顺序（由大到小）依次进行刷写。直到region server中所有memstore的总大小减小到上述值以下。
当region server中memstore的总大小达到
java_heapsize
*hbase.regionserver.global.memstore.size（默认值0.4）
时，会阻止继续往所有的memstore写数据。
3. 到达自动刷写的时间，也会触发memstore flush。自动刷新的时间间隔由该属性进行配置hbase.regionserver.optionalcacheflushinterval（默认1小时）。
4.当WAL文件的数量超过hbase.regionserver.max.logs，region会按照时间顺序依次进行刷写，直到WAL文件数量减小到hbase.regionserver.max.log以下（该属性名已经废弃，现无需手动设置，最大值为32）。
2.4 读流程
1）整体流程
2）Merge细节
读流程
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）分别在MemStore和Store File（HFile）中查询目标数据，并将查到的所有数据进行合并。此处所有数据是指同一条数据的不同版本（time stamp）或者不同的类型（Put/Delete）。
5）将查询到的新的数据块（Block，HFile数据存储单元，默认大小为64KB）缓存到Block Cache。
6）将合并后的最终结果返回给客户端。
2.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，并且会清理掉所有过期和删除的数据。
2.6 Region Split
默认情况下，每个Table起初只有一个Region，随着数据的不断写入，Region会自动进行拆分。刚拆分时，两个子Region都位于当前的Region Server，但处于负载均衡的考虑，HMaster有可能会将某个Region转移给其他的Region Server。
Region Split时机：
1.当1个region中的某个Store下所有StoreFile的总大小超过hbase.hregion.max.filesize （10G），该Region就会进行拆分（0.94版本之前）。
2.当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个数（0.94版本之后）。
具体的切分策略为：
第一次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了。
3.Hbase 2.0引入了新的split策略：如果当前RegionServer上该表只有一个Region，按照2 * hbase.hregion.memstore.flush.size分裂，否则按照hbase.hregion.max.filesize分裂。
第3章 HBase Shell操作
3.1 基本操作
1．进入HBase客户端命令行
[atguigu@hadoop102 hbase]$ bin/hbase shell
2．查看帮助命令
hbase(main):001:0> help
3．查看当前数据库中有哪些表
hbase(main):002:0> list
3.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．删除数据
删除某rowkey的全部数据：
hbase(main):016:0> deleteall 'student','1001'
删除某rowkey的某一列数据：
hbase(main):017:0> delete 'student','1002','info:sex'
9．清空表数据
hbase(main):018:0> truncate 'student'
提示：清空表的操作顺序为先disable，然后再truncate。
10．删除表
首先需要先让该表为disable状态：
hbase(main):019:0> disable 'student'
然后才能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}
第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 创建连接
4.2.1 单线程使用
基本的连接方法
package com.atguigu.hbase;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import java.io.IOException;
/**
* @author yhm
* @create 2021-02-01 16:29
*/
public class HBaseConnect {
public static void main(String[] args) throws IOException {
// 1.获取配置类
Configuration conf = HBaseConfiguration.create();
// 2.给配置类添加配置
conf.set("hbase.zookeeper.quorum","hadoop102,hadoop103,hadoop104");
// 3.获取连接
Connection connection = ConnectionFactory.createConnection(conf);
// 打印连接
System.out.println(connection);
// 4.关闭连接
connection.close();
}
}
4.2.2 多线程单例使用
package com.atguigu.hbase;
import org.apache.hadoop.conf.Configuration;
/**
* @author yhm
* @create 2021-12-07 10:08
*/
public class HbaseDML {
// 设置静态属性hbase连接
public static Connection connection = null;
static {
// 1. 创建配置对象
Configuration conf = new Configuration();
// 2. 添加配置参数
conf.set("hbase.zookeeper.quorum", "hadoop102,hadoop103,hadoop104");
// 3. 创建hbase的连接
try {
connection = ConnectionFactory.createConnection(conf);
} catch (IOException e) {
e.printStackTrace();
}
}
public static void closeConnection() throws IOException {
if (connection != null) {
connection.close();
}
}
}
4.3 使用连接
4.3.1 插入数据
/**
* putCell数据
* @param nameSpace
* @param tableName
* @param rowKey
* @param family
* @param column
* @param value
* @throws IOException
*/
public static void putCell(String nameSpace,String tableName,String rowKey,String family,String column,String value) throws IOException {
// 1.获取table
Table table = connection.getTable(TableName.valueOf(nameSpace, tableName));
// 2.创建Put对象
Put put = new Put(Bytes.toBytes(rowKey));
// 3.添加put属性
put.addColumn(Bytes.toBytes(family),Bytes.toBytes(column),Bytes.toBytes(value));
// 4.put数据
table.put(put);
// 5.关闭资源
table.close();
}
public static void main(String[] args) throws IOException {
putCell("bigdata","student","1001","info","name","zhangsan");
}
4.3.2 查询数据
/**
* getCell数据
* @param nameSpace
* @param tableName
* @param rowKey
* @param family
* @param column
* @return
* @throws IOException
*/
public static String getCells(String nameSpace,String tableName,String rowKey,String family,String column) throws IOException {
// 1.获取table
Table table = connection.getTable(TableName.valueOf(nameSpace, tableName));
// 2.获取Get对象
Get get = new Get(Bytes.toBytes(rowKey));
// 3.添加get属性
get.addColumn(Bytes.toBytes(family),Bytes.toBytes(column));
// 4.get数据
// 简便用法
// byte[] bytes = table.get(get).value();
// String value = new String(bytes);
// 复杂用法
// 4.1 获取result
Result result = table.get(get);
// 4.2 获取cells
Cell[] cells = result.rawCells();
// 4.3 遍历cells
String value = "";
for (Cell cell : cells) {
// 4.4 输出每个cell
value += Bytes.toString(CellUtil.cloneValue(cell)) + "-";
}
// 5.关闭资源
table.close();
return value;
}
public static void main(String[] args) throws IOException {
// putCell("bigdata","student","1001","info","name","zhangsan");
String cell = getCell("bigdata", "student", "1001", "info", "name");
System.out.println(cell);
}
4.3.3 扫描数据
/**
* 扫描数据
* @param nameSpace
* @param tableName
* @param startRow
* @param stopRow
* @return
* @throws IOException
*/
public static List<String> scanRows(String nameSpace, String tableName, String startRow, String stopRow) throws IOException {
// 1.获取table
Table table = connection.getTable(TableName.valueOf(nameSpace, tableName));
// 2.创建Scan对象
Scan scan = new Scan().withStartRow(Bytes.toBytes(startRow)).withStopRow(Bytes.toBytes(stopRow));
// 3.扫描数据
ResultScanner scanner = table.getScanner(scan);
// 4.获取结果
ArrayList<String> arrayList = new ArrayList<>();
for (Result result : scanner) {
arrayList.add(Bytes.toString(result.value()));
}
// 5.关闭资源
scanner.close();
table.close();
return arrayList;
}
public static void main(String[] args) throws IOException {
// putCell("bigdata","student","1002","info","name","lisi");
// String cell = getCell("bigdata", "student", "1001", "info", "name");
// System.out.println(cell);
List<String> strings = scanRows("bigdata", "student", "1001", "2000");
for (String string : strings) {
System.out.println(string);
}
}
4.3.4 删除数据
/**
* 删除column数据
*
* @param nameSpace
* @param tableName
* @param rowKey
* @param family
* @param column
* @throws IOException
*/
public static void deleteColumn(String nameSpace, String tableName, String rowKey, String family, String column) throws IOException {
// 1.获取table
Table table = connection.getTable(TableName.valueOf(nameSpace, tableName));
// 2.创建Delete对象
Delete delete = new Delete(Bytes.toBytes(rowKey));
// 3.添加删除信息
// 3.1 删除单个版本
// delete.addColumn(Bytes.toBytes(family),Bytes.toBytes(column));
// 3.2 删除所有版本
delete.addColumns(Bytes.toBytes(family), Bytes.toBytes(column));
// 3.3 删除列族
// delete.addFamily(Bytes.toBytes(family));
// 4.删除数据
table.delete(delete);
// 5.关闭资源
table.close();
}
public static void main(String[] args) throws IOException {
// putCell("bigdata","student","1002","info","name","lisi");
// String cell = getCell("bigdata", "student", "1001", "info", "name");
// System.out.println(cell);
// List<String> strings = scanRows("bigdata", "student", "1001", "2000");
// for (String string : strings) {
// System.out.println(string);
deleteColumn("bigdata", "student", "1001", "info", "name");
}
第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处于哪个一个预分区的区间内，设计rowkey的主要目的 ，就是让数据均匀的分布于所有的region中，在一定程度上防止数据倾斜。接下来我们就谈一谈rowkey常用的设计方案。
1.生成随机数、hash、散列值
2.字符串反转
3.字符串拼接
需求：使用hbase存储下列数据，要求能够通过hbase的API读取数据完成两个统计需求，（1）统计张三在2021年12月份消费的总金额
（2）统计所有人在2021年12月份消费的总金额
5.2.1 实现需求1
为了能够统计张三在2021年12月份消费的总金额，我们需要用scan命令能够得到张三在这个月消费的所有记录，之后在进行累加即可。Scan需要填写startRow和stopRow：
scan : startRow -> zhangsan_2021-12
endRow -> zhangsan_2021-12.
注意点：
（1）姓名和日期的字段直接需要有分隔符，分隔符规则按照阿斯卡码进行，需要避免扫描到用户zhangsanfeng的数据
（2）最后的日期结尾处需要使用阿斯卡码略大于’-’的值
最终得到rowKey的设计为：
//注意rowkey相同的数据会视为相同数据覆盖掉之前的版本
rowKey: user_date()
5.2.2 实现需求2
问题提出：按照需要1的rowKey设计，会发现对于需求2，完全没有办法写rowKey的扫描范围。此处能够看出hbase设计rowKey使用的特点为：
适用性强 泛用性差 能够完美实现一个需求 但是不能同时实现多个需要。
如果想要同时完成两个需求，需要对rowKey出现字段的顺序进行调整。
调整的原则为：可枚举的放在前面。其中时间是可以枚举的，用户名称无法枚举，所以必须把时间放在前面。
//设计如下
rowKey: date(yyyy-MM)_user_date(-dd HH:mm:SS)
实现需求1
scan : startRow -> 2021-12_zhangsan
endRow -> 2021-12_zhangsan.
实现需求2
scan : startRow -> 2021-12
endRow -> 2021-12.
5.2.3 添加预分区优化
预分区的分区号同样需要遵守rowKey的scan原则。所以必须添加在rowKey的最前面，前缀为最简单的数字。同时使用hash算法将用户名和月份拼接决定分区号。（单独使用用户名会造成单一用户所有数据存储在一个分区）
000.
001.
002.
...
119.
//此时rowKey设计
rowKey: 分区号(hash[user-月份]%120)_date(yyyy-MM)_user_date(-dd HH:mm:SS)
缺点：实现需求2的时候，由于每个分区都有12月份的数据，需要扫描120个分区。
解决方法：提前将分区号和月份进行对应
000. – 009. 号分区存储1月份数据
...
110. – 119. 号分区存储12月份数据
rowKey情况: 分区号(hash[user]%10 + 月份对应的分区开始值)_date(yyyy-MM)_user_date(-dd HH:mm:SS)
完成需求2:
scan : startRow -> 110_2021-12
endRow -> 110_2021-12.
... 扫描10次
startRow -> 119_2021-12
endRow -> 119_2021-12.
5.3 内存优化
HBase操作过程中需要大量的内存开销，毕竟Table是可以缓存在内存中的，但是不建议分配非常大的堆内存，因为GC过程持续太久会导致RegionServer处于长期不可用状态，一般16~36G内存就可以了，如果因为框架占用内存过高导致系统内存不足，框架一样会被系统服务拖死。
5.4 基础优化
1.Zookeeper会话超时时间
hbase-site.xml
属性：zookeeper.session.timeout
解释：默认值为90000毫秒（90s）。当某个RegionServer挂掉，90s之后Master才能察觉到。可适当减小此值，以加快Master响应，可调整至60000毫秒。
2.设置RPC监听数量
hbase-site.xml
| 属性：hbase.regionserver.handler.count 解释：默认值为30，用于指定RPC监听的数量，可以根据客户端的请求数进行调整，读写请求较多时，增加此值。 |
3.手动控制Major Compaction
hbase-site.xml
属性：hbase.hregion.majorcompaction
解释：默认值：604800000秒（7天）， Major Compaction的周期，若关闭自动Major Compaction，可将其设为0
4.优化HStore文件大小
hbase-site.xml
| 属性：hbase.hregion.max.filesize 解释：默认值10737418240（10GB），如果需要运行HBase的MR任务，可以减小此值，因为一个region对应一个map任务，如果单个region过大，会导致map任务执行时间过长。该值的意思就是，如果HFile的大小达到这个数值，则这个region会被切分为两个Hfile。 |
5.优化HBase客户端缓存
hbase-site.xml
| 属性：hbase.client.write.buffer 解释：默认值2097152bytes（2M）用于指定HBase客户端缓存，增大该值可以减少RPC调用次数，但是会消耗更多内存，反之则反之。一般我们需要设定一定的缓存大小，以达到减少RPC次数的目的。 |
6.指定scan.next扫描HBase所获取的行数
hbase-site.xml
| 属性：hbase.client.scanner.caching 解释：用于指定scan.next方法获取的默认行数，值越大，消耗内存越大。 |
7.BlockCache占用RegionServer堆内存的比例
hbase-site.xml
属性：hfile.block.cache.size
解释：默认0.4，读请求比较多的情况下，可适当调大
8.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
4）重启HBase
[atguigu@hadoop102 ~]$ stop-hbase.sh
[atguigu@hadoop102 ~]$ start-hbase.sh
5) 连接Phoenix
[atguigu@hadoop101 phoenix]$ /opt/module/phoenix/bin/sqlline.py hadoop102,hadoop103,hadoop104:2181
6.2.2 Phoenix Shell操作
1）显示所有表
!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;
3）插入数据
upsert into student values('1001','zhangsan','beijing');
select * from student;
select * from student where id='1001';
delete from student where id='1001';
drop table student;
!quit
6.2.3 Phoenix JDBC操作
1.胖客户端
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>
<exclusion>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-common</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.glassfish</groupId>
<artifactId>javax.el</artifactId>
<version>3.0.1-b06</version>
</dependency>
<dependency>
<groupId>org.apache.hadoop</groupId>
<artifactId>hadoop-common</artifactId>
<version>2.8.4</version>
</dependency>
</dependencies>
2）编写代码
import java.sql.*;
import java.util.Properties;
/**
* @author yhm
* @create 2021-02-03 19:52
*/
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();
}
}
2.瘦客户端
1）启动query server
[atguigu@hadoop102 ~]$ queryserver.py start
[atguigu@hadoop102 ~]$ sqlline-thin.py hadoop102
2）maven依赖
<dependencies>
<!-- https://mvnrepository.com/artifact/org.apache.phoenix/phoenix-queryserver-client -->
<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.*;
/**
* @author yhm
* @create 2021-02-03 20:16
*/
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的HRegionserver节点的hbase-site.xml
<!-- phoenix regionserver 配置参数-->
<property>
<name>hbase.regionserver.wal.codec</name>
<value>org.apache.hadoop.hbase.regionserver.wal.IndexedWALEditCodec</value>
</property>
6.3.2 全局索引（global index）
Global Index是默认的索引格式，创建全局索引时，会在HBase中建立一张新表。也就是说索引数据和数据表是存放在不同的表中的，因此全局索引适用于多读少写的业务场景。
写数据的时候会消耗大量开销，因为索引表也要更新，而索引表是分布在不同的数据节点上的，跨节点的数据传输带来了较大的性能消耗。
在读数据的时候Phoenix会选择索引表来降低查询消耗的时间。
创建单个字段的全局索引
CREATE INDEX my_index ON my_table (my_col);
如果想查询的字段不是索引字段的话索引表不会被使用，也就是说不会带来查询速度的提升。
若想解决上述问题，可采用如下方案：
1）使用包含索引
2）使用本地索引
6.3.3 包含索引（covered index）
创建携带其他字段的全局索引
CREATE INDEX my_index ON my_table (v1) INCLUDE (v2);
6.3.3 本地索引（local index）
Local Index适用于写操作频繁的场景。
索引数据和数据表的数据是存放在同一张表中（且是同一个Region），避免了在写操作的时候往不同服务器的索引表中写索引带来的额外开销。
CREATE LOCAL INDEX my_index ON my_table (my_column);
为开发者提供学习成长、分享交流、生态实践、资源工具等服务，帮助开发者快速成长。
更多推荐
7
0- 0
已为社区贡献3条内容
所有评论(0)