08-HBase
1.目标概述
- 了解HBase基本概念
- 了解HBase架构
- 掌握HBase集群环境搭建
- 掌握HBase中shell操作
- 掌握HBase中java API操作
- 掌握rowKey的设计原则
- 【延伸】MapReduce操作HBase
- 【延伸】spark操作HBase
2.HBase基础
2.1.基本概念
2.1.1.介绍
官网地址：http://hbase.apache.org/
HBase在Hadoop之上提供了类似于Bigtable的能力，是BigTable的开源实现版本，通过java编程语言实现 。HBase不同于关系数据库，它是一个适合于非结构化数据存储的数据库 。
HBase是一个分布式的、面向列的开源数据库 ，是一个NoSQL的分布式数据存储系统，实现对大型数据的实时、随机读写访问。
HBase利用Hadoop HDFS作为文件存储系统，利用Hadoop MapReduce来处理HBase中的海量数据 。
- HBase依赖于hdfs做底层的数据存储
- HBase依赖于mapReduce做数据计算
- HBase依赖于zookeeper做服务协调
2.1.2.特点
-
提供高可靠、高性能、列存储、可伸缩、实时读写的nosql数据库系统
- 介于NoSQL和RDBMS之间，仅能通过主键(row key)和主键的范围（range）来检索数据
- 主要用来存储非结构化和半结构化的松散数据
- HBase中底层数据存储都是字节数组：byte[]
-
HBase中表的特点
-
大：一个表可以有上十亿行，上百万列
-
面向列：面向**列(族)**的存储和权限控制，列(簇)独立检索
-
稀疏：空(null)列不占用存储空间，表可以设计的非常稀疏
-
无模式：每行都有一个可排序的主键和任意多的列，列可以动态增加，不同的行可以有不同的列
-
-
和行式数据库的区别
- 行式数据库在分析的时候，操作整行数据。比如将字段id，name，age，sex，score等完整的信息读入内存，造成大量的内存和IO资源浪费
- 列式数据库是把行式数据库全部拆开，按照列的方式重新组合存储，一列所有的行的数据存放在一起。带来的好处就是，比如要分析男女信息，就直接访问所有的男女信息；要分析销售额，就直接访问消费额相关的数据。
2.2.HBase表结构
-
表(table)：用于存储管理数据，具有稀疏的、面向列的特点。HBase中的每一张表，就是所谓的大表(Bigtable)，可以有上十亿行，上百万列。对于值为空的列，并不占用存储空间，因此表可以设计的非常稀疏
-
行键(RowKey)：类似于mysql中的主键，HBase根据行键来快速检索数据，一个行键对应一条记录。
-
列簇(ColumnFamily)：是列的集合。列簇在表定义时需要指定，列在插入数据时动态指定。列中的数据都是以二进制形式存在，没有数据类型。在物理存储结构上，每个表中的每个列簇单独以一个文件存储，一个表可以有多个列簇（官方推荐小于等于3个）
-
时间戳(TimeStamp)：是列的一个属性，是一个64位整数。由行键和列确定的单元格（Cell），可以存储多个数据，每个数据含有时间戳属性，数据具有版本特性。可根据版本(VERSIONS)或时间戳来指定查询历史版本数据，如果都不指定，则默认返回最新版本的数据
-
参考案例：
mysql数据库表：
转换对应成HBase表：
2.3.HBase整体架构
2.3.1.Client
- 通过 RPC机制与HMaster和HRegionServer进行通信
- Client与HMaster进行通信进行管理类操作
- Client与HRegionServer进行数据读写类操作
2.3.2.Zookeeper
- 保证任何时候，集群中只有一个运行状态的 Master，避免脑裂问题
- 存储所有Region的寻址入口，包括**-ROOT-**表地址、HMaster地址
- 实时监控Region Server的状态，将Region server的上线和下线信息，实时通知给Master
2.3.3.HMaster
- 可以启动多个HMaster，通过Zookeeper的Master Election机制保证有且仅有一个Master提供服务
- 作用：
- 为Region server分配region
- 负责region server的负载均衡
- 发现失效的region serve并重新分配其上的region
- HDFS上的垃圾文件回收
2.3.4.HRegionServer
- HBase中最核心的模块，主要负责响应用户I/O请求，向HDFS文件系统中读写数据
- 作用：
- 维护Master分配给它的region，处理对这些region的IO请求
- 负责切分在运行过程中变得过大的region
- HRegionServer管理一些列HRegion对象，每个HRegion对应Table中一个Region，HRegion由多个HStore组成，每个HStore对应Table中一个Column Family的存储，Column Family就是一个集中的存储单元集
2.3.5.HStore
HBase存储的核心，由MemStore和StoreFile组成。
用户写入数据的流程为：client写入 -> 存入MemStore，一直到MemStore满 -> Flush成一个StoreFile，直至增长到一定阈值 -> 触发Compact合并操作 -> 多个StoreFile合并成一个StoreFile，同时进行版本合并和数据删除 -> 当StoreFiles Compact后，逐步形成越来越大的StoreFile -> 单个StoreFile大小超过一定阈值后，触发Split操作，把当前Region Split成2个Region，原先的Region会下线，新Split出的2个孩子Region会被HMaster分配到相应的HRegionServer上，使得原先1个Region的压力得以分流到2个Region上。如图所示：
2.3.6.HRegion
一个表最开始存储的时候，是一个Region。
一个Region中会有个多个store，每个store用来存储一个列簇。如果只有一个column family，就只有一个store。Region会随着插入的数据越来越多，会进行拆分。默认大小是10G一个。
2.3.7.HLog
在分布式系统环境中，无法避免系统出错或者宕机，一旦HRegionServer意外退出，MemStore中的内存数据就会丢失，引入HLog就是防止这种情况。
工作机制：每个HRegionServer中都会有一个HLog对象，HLog是一个实现Write Ahead Log的类，每次用户操作写入Memstore的同时，也会写一份数据到HLog文件，HLog文件定期会滚动出新，并删除旧的文件(已持久化到StoreFile中的数据)。
当HRegionServer意外终止后，HMaster会通过Zookeeper感知，HMaster首先处理遗留的HLog文件，将不同Region的log数据拆分，分别放到相应Region目录下，然后再将失效的Region重新分配，领取到这些Region的HRegionServer在Load Region的过程中，会发现有历史HLog需要处理，因此会Replay HLog中的数据到MemStore中，然后flush到StoreFiles，完成数据恢复。
2.4.查询路由
HBase中存有两张特殊的表，-ROOT-和.META.：
- .META.：记录了用户表的Region信息，.META.可以有多个Regoin
- -ROOT-：记录了.META.表的Region信息，-ROOT-只有一个Region。Zookeeper中记录了-ROOT-表的location
客户端访问数据流程：
访问zookeeper->访问-ROOT-表->访问.META.表->找到用户数据的位置，再去访问数据
3.HBase集群部署
3.1.选择jdk版本和hadoop版本
参考地址：http://hbase.apache.org/1.2/book.html
jdk版本：
hadoop版本：
3.2.下载HBase
参考地址：http://mirrors.hust.edu.cn/apache/hbase/
3.3.上传HBase到linux主机，并解压
cd /export/softwares
tar -zxvf hbase-1.3.1-bin.tar.gz -C /export/servers
#解压完成后删除压缩包
rm -rf hbase-1.3.1-bin.tar.gz
#重新命名hbase
cd /export/servers
mv hbase-1.3.1 hbase131
3.4.修改配置文件
3.4.1.regionservers
说明：配置HRegionservers节点列表。
cd /export/servers/hbase131/conf
vi regionservers
node02
node03
3.4.2.hbase-env.sh
说明：配置jdk环境变量，配置集群通过zookeeper管理，不由hbase自己管理。
#配置jdk环境变量
export JAVA_HOME=/export/servers/jdk1.8.0_141
#配置集群交给zookeeper管理
export HBASE_MANAGES_ZK=false
3.4.3.hbase-site.xml
说明：hbase的核心配置文件。
vim hbase-site.xml
<configuration>
<!--配置hbase在hdfs上的存储路径,
非ha环境：hdfs://master:9000/hbase
ha环境：hdfs://ns1/hbase
-->
<property>
<name>hbase.rootdir</name>
<value>hdfs://node01:8020/hbase</value>
</property>
<!--开启集群分布式模式-->
<property>
<name>hbase.cluster.distributed</name>
<value>true</value>
</property>
<!--hbase Master端口-->
<property>
<name>hbase.master.port</name>
<value>16000</value>
</property>
<!--配置zookeeper集群主机列表-->
<property>
<name>hbase.zookeeper.quorum</name>
<value>node01,node02,node03</value>
</property>
<!--配置zookeeper主机端口-->
<property>
<name>hbase.zookeeper.property.clientPort</name>
<value>2181</value>
</property>
</configuration>
3.4.4. backup-masters
说明：配置备用master节点。backup-masters需要手动创建。
vim backup-masters
node02
3.4.5.拷贝hadoop中hdfs的核心配置文件到hbase
cp /export/servers/hadoop-2.6.0-cdh5.14.0/etc/hadoop/hdfs-site.xml /export/servers/hbase131/conf/
cp /export/servers/hadoop-2.6.0-cdh5.14.0/etc/hadoop/core-site.xml /export/servers/hbase131/conf/
3.5.把配置好的HBase远程拷贝到其它主机节点
scp -r /export/servers/hbase131 root@node02:/export/servers
scp -r /export/servers/hbase131 root@node03:/export/servers
3.6.配置环境变量
vim /etc/profile
export HBASE_HOME=/export/servers/hbase131
export PATH=$PATH:${HBASE_HOME}/bin
#让环境变量生效
source /etc/profile
3.7.启动HBase集群
3.7.1.系统时钟同步
说明：HBase对于集群时间的同步要求非常严格，要求相差不要超过30秒。启动集群前一定要同步系统时间。
ntpdate -u 0.uk.pool.ntp.org
3.7.2.启动zookeeper集群
/export/servers/zookeeper-3.4.5-cdh5.14.0/bin/zkServer.sh start
3.7.3.启动hdfs
3.7.4.启动hbase集群
/export/servers/hbase131/bin/start-hbase.sh
3.7.5.访问hbase的web界面
地址：http://192.168.53.100:16010/master-status
3.7.6.如何启动单节点进程
说明：如果某些主机节点进程未启动正常，可以通过以下方式进行单独启动。
#单独启动master
hbase-daemon.sh start master
#单独启动regionserver
hbase-daemon.sh start regionserver
4.HBase shell操作
4.1.shell交互界面整体操作
4.1.1.启动shell交互界面
cd /export/servers/hbase131/bin
#启动shell交互界面
hbase shell
#查看集群状态信息
status
#查看版本信息
version
4.1.2.退出shell交互界面
exit
4.1.3.查看帮助信息
#查看全部帮助信息
help
#查看指定的命令帮助信息
help "create"
图一：
图二：
4.2.操作名称空间namespace
说明：在hbase中，namespace相当于关系数据库的database。用于从逻辑上对表进行分组。hbase系统默认有两个缺省的名称空间：
- hbase：系统内建表，包括namespace和meta表
- default：创建表时，如果不指定namespace的表 ，则在default名称空间下
#列出所有名称空间
list_namespace
#查看指定名称空间
describe_namespace 'hbase'
#创建名称空间
create_namespace 'my_ns'
#删除名称空间
drop_namespace 'my_ns'
4.3.操作表table
4.3.1.案例
说明：将关系数据库中的表，转换成hbase中的表进行操作。
mysql数据库表：
hbase表：
4.3.2.命令操作
#列出所有表
list
#创建表(create '名称空间:表名称','列簇')
create 'my_ns:user','base_info'
#插入数据(put '名称空间:表名称','行键','列簇:列名','数据')
put 'my_ns:user','rowkey_10','base_info:username','张三'
put 'my_ns:user','rowkey_10','base_info:birthday','2014-07-10'
put 'my_ns:user','rowkey_10','base_info:sex','1'
put 'my_ns:user','rowkey_10','base_info:address','北京市'
put 'my_ns:user','rowkey_16','base_info:username','张小明'
put 'my_ns:user','rowkey_16','base_info:birthday','2014-07-10'
put 'my_ns:user','rowkey_16','base_info:sex','1'
put 'my_ns:user','rowkey_16','base_info:address','北京'
put 'my_ns:user','rowkey_22','base_info:username','陈小明'
put 'my_ns:user','rowkey_22','base_info:birthday','2014-07-10'
put 'my_ns:user','rowkey_22','base_info:sex','1'
put 'my_ns:user','rowkey_22','base_info:address','上海'
put 'my_ns:user','rowkey_24','base_info:username','张三丰'
put 'my_ns:user','rowkey_24','base_info:birthday','2014-07-10'
put 'my_ns:user','rowkey_24','base_info:sex','1'
put 'my_ns:user','rowkey_24','base_info:address','河南'
put 'my_ns:user','rowkey_25','base_info:username','陈大明'
put 'my_ns:user','rowkey_25','base_info:birthday','2014-07-10'
put 'my_ns:user','rowkey_25','base_info:sex','1'
put 'my_ns:user','rowkey_25','base_info:address','西安'
#查询表中的数据
scan 'my_ns:user'
#统计表中行的数量
count 'my_ns:user'
#获取指定行键的数据
get 'my_ns:user','rowkey_10'
#获取指定列簇的数据
get 'my_ns:user','rowkey_10','base_info'
#获取指定列簇中某一列的数据
get 'my_ns:user','rowkey_10','base_info:username'
#获取指定列簇中多列数据
get 'my_ns:user', 'rowkey_10', {COLUMN => ['base_info:username','base_info:sex']}
#删除指定行键,指定列的数据
delete 'my_ns:user','rowkey_10','base_info:username'
#删除指定行键的所有数据
deleteall 'my_ns:user','rowkey_10'
#清空表的数据（慎用）
truncate 'my_ns:user'
#浏览表结构
describe 'my_ns:user'
#操作列簇
alter 'my_ns:user',NAME=>'ext_info'
alter 'my_ns:user','delete'=>'ext_info'
#测试表是否存在
exists 'my_ns:user'
#删除表（首先要禁用表）
disable 'my_ns:user'
drop 'my_ns:user'
5.HBase Java API操作
5.1.搭建环境
5.1.1.创建项目
5.1.2.导入依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>cn.liny</groupId>
<artifactId>spark-teach-day08-01hbase</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<properties>
<!--hbase版本-->
<hbase.version>1.3.1</hbase.version>
</properties>
<dependencies>
<!--hbase依赖-->
<dependency>
<groupId>org.apache.hbase</groupId>
<artifactId>hbase-client</artifactId>
<version>${hbase.version}</version>
</dependency>
</dependencies>
</project>
5.1.3.准备hbase-site.xml配置文件
说明：在resources目录下创建hbase-site.xml，方便通过配置文件信息创建HBase连接对象。
<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
<configuration>
<!--配置zookeeper集群地址,需要在hosts中配置主机域名映射，
如果没有配置，则可以指定为ip地址方式
-->
<property>
<name>hbase.zookeeper.quorum</name>
<value>node01,node02,node03</value>
</property>
</configuration>
5.2封装HBaseUtil工具类
package cn.liny.hbase;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.*;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.filter.Filter;
import org.apache.hadoop.hbase.util.Bytes;
import java.io.IOException;
import java.util.List;
/**
* HBase工具类
*/
public class HBaseUtil {
// 集群配置信息
private static final String ZK_CONNECT_KEY = "hbase.zookeeper.quorum";
private static final String ZK_CONNECT_VALUE = "node01:2181,node02:2181,node03:2181";
// 操作集群对象
private static Connection conn = null;
private static Admin admin = null;
//集群环境信息=============================================================================start
/**
* 获取连接对象Connection
*/
public static Connection getConnection(){
// 1.创建一个可以用来管理hbase配置信息的conf对象
Configuration conf = new Configuration();
conf.set(ZK_CONNECT_KEY,ZK_CONNECT_VALUE);
// 2.创建返回Connection对象
try {
if(conn == null){
conn = ConnectionFactory.createConnection(conf);
}
} catch (IOException e) {
System.out.println("创建Connection连接对象发生异常："+e.getMessage());
}
return conn;
}
/**
* 获取管理员对象
*/
public static Admin getAdmin(){
try {
admin = conn.getAdmin();
} catch (IOException e) {
System.out.println("获取管理员Admin对象发生异常："+e.getMessage());
}
return admin;
}
/**
* 释放连接对象
*/
public static void closeConnection(){
if(conn !=null){
try {
conn.close();
} catch (IOException e) {
System.out.println("释放Connection对象发生异常："+e.getMessage());
}
}
}
//集群环境信息=============================================================================end
//操作名称空间=============================================================================start
/**
* 创建名称空间：
* 1.传入目标名称空间的名称
* 2.判断名称空间是否已经存在
* 3.若存在，不执行任何操作；若不存在，则创建新的名称空间
*/
public static void createNameSpace(String ns_name){
// 标识名称空间是否存在,默认
boolean isExists = false;
try {
// 查询已经存在的名称空间
NamespaceDescriptor[] list = admin.listNamespaceDescriptors();
for(NamespaceDescriptor ns:list){
if(ns.getName().equals(ns_name)){
System.out.println("目标名称空间："+ns_name+"已经存在");
isExists = true;
break;
}
}
// 名称空间不存在，则创建新的名称空间
if(!isExists){
System.out.println("目标名称空间："+ns_name+"不存在，正在准备创建");
NamespaceDescriptor newNameSpace = NamespaceDescriptor.create(ns_name).build();
admin.createNamespace(newNameSpace);
}
} catch (IOException e) {
System.out.println("创建名称空间发生异常："+e.getMessage());
}
}
/**
* 删除名称空间
*/
public static void deleteNameSpace(String ns_name){
System.out.println("正在准备删除名称空间："+ns_name);
try {
admin.deleteNamespace(ns_name);
} catch (IOException e) {
System.out.println("删除名称空间发生异常："+e.getMessage());
}
}
//操作名称空间=============================================================================end
//表DDL操作=============================================================================start
/**
* 创建表:
* 1.传递表的名称，和列簇信息
* 2.判断表是否已经存在，如果已经存在，则不创建
*/
public static void createTable(String t_name,String ...family){
// 创建表，必须要指定列簇
if(family.length<=0){
System.out.println("创建表，必须要指定列簇");
return;
}
// 定义表名称
TableName tableName = TableName.valueOf(t_name);
try {
// 判断表是否存在
if(admin.tableExists(tableName)){
System.out.println("表"+t_name+"已经存在，不需要创建");
return;
}
// 如果表不存在，则执行创建
System.out.println("表"+t_name+"不存在，正在创建");
// 定义表的列簇集
HTableDescriptor htd = new HTableDescriptor(tableName);
// 添加列簇
HColumnDescriptor tmpColumn = null;
for(String hc:family){
tmpColumn= new HColumnDescriptor(hc);
htd.addFamily(tmpColumn);
}
// 创建表
admin.createTable(htd);
} catch (IOException e) {
System.out.println("创建表发生异常："+e.getMessage());
}
}
/**
* 获取表的详情信息
*/
public static void getTableInfo(String t_name) throws Exception{
// 定义表名称对象
TableName tableName = TableName.valueOf(t_name);
// 判断表是否存在
if(admin.tableExists(tableName)){
// 获取表的列簇集
HTableDescriptor htd = admin.getTableDescriptor(tableName);
// 获取表的列簇
HColumnDescriptor[] columnFamilies = htd.getColumnFamilies();
// 打印表的详情信息
for(HColumnDescriptor hcd:columnFamilies){
System.out.println(hcd.getNameAsString());
}
}else{
System.out.println("表"+tableName.getNameAsString()+"不存在。");
}
}
/**
* 修改表：
* 1.addOrDelete：标识添加列簇，或者删除例簇
* 2.true，表示添加；false：表示删除
*/
public static void updateTable(String t_name,String family,boolean addOrDelete){
// 定义表名称对象
TableName tableName = TableName.valueOf(t_name);
try{
// 判断表是否存在
if(admin.tableExists(tableName)){
// 细节：对表进行修改，需要先禁用表，修改完成后再启用表
admin.disableTable(tableName);
// 获取表描述对象
HTableDescriptor htd = admin.getTableDescriptor(tableName);
// 判断是添加还是删除
if(addOrDelete){
// 正在添加列簇
System.out.println("正在添加列簇："+family);
// 定义列簇对象
HColumnDescriptor hcd = new HColumnDescriptor(family);
htd.addFamily(hcd);
}else{
// 正在删除列簇
System.out.println("正在删除列簇："+family);
htd.removeFamily(Bytes.toBytes(family));
}
// 修改表
admin.modifyTable(tableName,htd);
}else{
System.out.println("表【"+tableName.getNameAsString()+"】不存在.");
}
}catch(Exception e){
System.out.println("修改表发生异常："+e.getMessage());
}finally {
// 重新启用表
try {
admin.enableTable(tableName);
} catch (IOException e) {
System.out.println("重新启用表发生异常："+e.getMessage());
}
}
}
/**
* 删除表
*/
public static void deleteTable(String t_name){
// 定义表名称对象
TableName tableName = TableName.valueOf(t_name);
try {
// 判断表是否存在
if(admin.tableExists(tableName)){
// 禁用表
admin.disableTable(tableName);
// 删除表
admin.deleteTable(tableName);
}else{
System.out.println("表"+tableName.getNameAsString()+"不存在.");
}
} catch (IOException e) {
System.out.println("删除表发生异常："+e.getMessage());
}
}
//表DDL操作=============================================================================end
//表DML操作=============================================================================start
/**
* 添加（更新）数据:
* 1.参数说明：
* t_name：表名称
* rowKey：行键
* family：列簇名称
* ck：列名称数组
* cv：列值数组
*
*/
public static void put(String t_name,String rowKey,String family,String[] ck,String[] cv){
// 定义表的名称对象
TableName tableName = TableName.valueOf(t_name);
try {
// 获取表
Table table = conn.getTable(tableName);
// 根据行键创建Put对象
/**
* Put对象，是HBase提供用于添加或者更新数据的API
*/
Put put = new Put(Bytes.toBytes(rowKey));
// 准备数据
for(int i=0;i<ck.length;i++){
put.addColumn(Bytes.toBytes(family),
Bytes.toBytes(ck[i]),
Bytes.toBytes(cv[i]));
}
// 添加（更新）数据
table.put(put);
// 释放Table资源
table.close();
} catch (IOException e) {
System.out.println("添加（更新）数据发生异常："+e.getMessage());
}
}
/**
* 根据rowKey获取数据
*/
public static void get(String t_name,String rowKey){
// 定义表名称
TableName tableName=TableName.valueOf(t_name);
try {
// 获取表
Table table = conn.getTable(tableName);
// 创建Get对象
Get get = new Get(Bytes.toBytes(rowKey));
// 获取数据
Result result = table.get(get);
// 打印数据
List<Cell> cells = result.listCells();
for(Cell c:cells){
//打印rowKey,family,qualifier,value
System.out.println(Bytes.toString(CellUtil.cloneRow(c))// 行键
+ "==> " + Bytes.toString(CellUtil.cloneFamily(c))// 列簇
+ "{" + Bytes.toString(CellUtil.cloneQualifier(c))// 列
+ ":" + Bytes.toString(CellUtil.cloneValue(c)) + "}");// 值
}
// 释放资源
table.close();
} catch (IOException e) {
System.out.println("根据rowKey获取数据发生异常："+e.getMessage());
}
}
/**
* 范围扫描数据
*/
public static void scan(String t_name,String ... start_end_rowKey){
// 定义表的名称
TableName tableName = TableName.valueOf(t_name);
try {
// 获取表
Table table = conn.getTable(tableName);
// 定义扫描器
Scan scan = new Scan();
// 设置扫描范围
if(start_end_rowKey.length>1){
scan.setStartRow(Bytes.toBytes(start_end_rowKey[0]));
scan.setStopRow(Bytes.toBytes(start_end_rowKey[1]));
}
// 获取扫描结果集
ResultScanner scanner = table.getScanner(scan);
Result result = null;
while ((result = scanner.next()) != null){
// 获取单元格
List<Cell> cells = result.listCells();
// 打印 rowKey,family,qualifier,value
for(Cell c:cells){
System.out.println(Bytes.toString(CellUtil.cloneRow(c))
+ "==> " + Bytes.toString(CellUtil.cloneFamily(c))
+ "{" + Bytes.toString(CellUtil.cloneQualifier(c))
+ ":" + Bytes.toString(CellUtil.cloneValue(c)) + "}");
}
}
// 释放资源
table.close();
} catch (IOException e) {
System.out.println("范围扫描数据发生异常："+e.getMessage());
}
}
/**
* 删除数据
* 1.参数说明：
* t_name：表名称
* rowKey：行键
* family_qualifier：可变参数，传入列簇名称，和列名称
*
*/
public static void del(String t_name,String rowKey,String ... family_qualifier){
// 定义表名称
TableName tableName=TableName.valueOf(t_name);
try {
// 获取表
Table table = conn.getTable(tableName);
// 创建删除对象
Delete delete = new Delete(Bytes.toBytes(rowKey));
// 明确删除某一列
if(family_qualifier.length>1){
delete.addColumn(Bytes.toBytes(family_qualifier[0]),Bytes.toBytes(family_qualifier[1]));
}
// 执行删除
table.delete(delete);
// 释放资源
table.close();
} catch (IOException e) {
System.out.println("删除表数据发生异常："+e.getMessage());
}
}
//表DML操作=============================================================================end
//Filter查询===========================================================================start
/**
* 过滤器实现高级查询
*/
public static void scanByFilter(String t_name,Filter filter){
// 定义表的名称
TableName tableName = TableName.valueOf(t_name);
try {
// 获取表
Table table = conn.getTable(tableName);
// 定义扫描器
Scan scan = new Scan();
scan.setFilter(filter);
// 执行扫描
ResultScanner scanner = table.getScanner(scan);
Result result = null;
while ((result = scanner.next()) != null){
// 获取单元格
List<Cell> cells = result.listCells();
// 打印 rowKey,family,qualifier,value
for(Cell c:cells){
System.out.println(Bytes.toString(CellUtil.cloneRow(c))
+ "==> " + Bytes.toString(CellUtil.cloneFamily(c))
+ "{" + Bytes.toString(CellUtil.cloneQualifier(c))
+ ":" + Bytes.toString(CellUtil.cloneValue(c)) + "}");
}
}
// 释放资源
table.close();
} catch (IOException e) {
System.out.println("过滤查询数据发生异常："+e.getMessage());
}
}
//Filter查询=============================================================================end
}
5.3.操作名称空间
package cn.liny.hbase;
import org.apache.hadoop.hbase.NamespaceDescriptor;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.hadoop.hbase.client.Connection;
/**
* 学习HBase操作名称空间
*/
public class HbaseNameSpace {
public static void main(String[] args) throws Exception{
// 1.获取连接对象
Connection conn = HBaseUtil.getConnection();
// 2.获取管理员对象Admin，执行管理任务操作
Admin admin = HBaseUtil.getAdmin();
// 3.操作名称空间namespace
// 3.1.列出所有的名称空间
System.out.println("-----------------3.1.列出所有名称空间--------------------");
NamespaceDescriptor[] list = admin.listNamespaceDescriptors();
for(NamespaceDescriptor ns:list){
System.out.println("名称空间："+ns.getName());
}
// 3.2.创建名称空间
System.out.println("-----------------3.2.创建名称空间-------------------------");
HBaseUtil.createNameSpace("my_ns1");
// 3.3.删除名称空间
System.out.println("-----------------3.3.删除名称空间-------------------------");
HBaseUtil.deleteNameSpace("my_ns2");
// 2.关闭连接对象
HBaseUtil.closeConnection();
}
}
5.4.操作表
5.4.1.表DDL操作
package cn.liny.hbase;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.hadoop.hbase.client.Connection;
/**
* 学习HBase操作表：DDL
*/
public class HBaseTableDDL {
public static void main(String[] args) throws Exception {
// 1.获取连接对象
Connection conn = HBaseUtil.getConnection();
// 2.获取管理员对象Admin，执行管理任务操作
Admin admin = HBaseUtil.getAdmin();
// 3.表DDL操作
// 3.1.查询所有表
System.out.println("----------------------3.1.查询所有表------------------------");
TableName[] tableNames = admin.listTableNames();
for(TableName t:tableNames){
System.out.println("表名称："+t.getNameAsString());
}
// 3.2.创建表
System.out.println("----------------------3.2.创建表-----------------------------");
HBaseUtil.createTable("student","base_info");
// 3.3.获取表的详情信息
System.out.println("----------------------3.3.获取表的详情信息---------------------");
HBaseUtil.getTableInfo("student");
// 3.4.修改表
System.out.println("----------------------3.4.修改表-----------------------------");
HBaseUtil.updateTable("student","ext_info",true);
// 3.5.删除表
System.out.println("----------------------3.5.删除表-----------------------------");
HBaseUtil.deleteTable("student");
// 关闭连接对象
HBaseUtil.closeConnection();
}
}
5.4.2.表DML操作
package cn.liny.hbase;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.hadoop.hbase.client.Connection;
/**
* 学习HBase操作表：DML
*/
public class HBaseTableDML {
public static void main(String[] args) throws Exception{
// 1.获取连接对象
Connection conn = HBaseUtil.getConnection();
// 2.获取管理员对象Admin，执行管理任务操作
Admin admin = HBaseUtil.getAdmin();
// 3.表DML操作
// 3.1.创建表
System.out.println("----------------------3.1.创建表-----------------------------");
HBaseUtil.createTable("my_ns:user","base_info");
// 3.2.添加（更新）数据
System.out.println("----------------------3.2.添加（更新）数据---------------------");
// 准备数据
String row_key="rowkey_10";
String[] ck = {"username","sex","address","birthday"};
String[] cv = {"张三","1","北京市","2014-07-10"};
HBaseUtil.put("my_ns:user",row_key,"base_info",ck,cv);
// 3.3.根据rowKey获取数据
System.out.println("----------------------3.3.根据rowKey获取数据---------------------");
HBaseUtil.get("my_ns:user",row_key);
// 3.4.范围扫描数据
System.out.println("----------------------3.4.范围扫描数据----------------------------");
//HBaseUtil.scan("my_ns:user");// 全表扫描
HBaseUtil.scan("my_ns:user","rowkey_16","rowkey_26");// 指定rowKey范围扫描
// 3.5.删除数据
System.out.println("----------------------3.5.删除数据----------------------------");
// HBaseUtil.del("my_ns:user","rowkey_16");// 删除整行
HBaseUtil.del("my_ns:user","rowkey_22","base_info","address");// 明确删除列
// 关闭连接对象
HBaseUtil.closeConnection();
}
}
5.5.HBase过滤查询
5.5.1.关于过滤查询
基础API中的查询操作，在面对大量数据的时候是非常苍白的，Hbase提供了高级的查询方法：Filter。
Filter根据簇、列、版本等更多的条件来对数据进行过滤，基于Hbase提供的三维有序（主键有序、列有序、版本有序），这些Filter可以高效的完成查询过滤的务。
要完成过滤的操作，至少需要两个参数：
-
抽象操作符
LESS ：<
LESS_OR_EQUAL： <=
EQUAL： =
NOT_EQUAL： <>
GREATER ：>
GREATER_OR_EQUAL ：>=
NO_OP ：排除所有
-
比较器
BinaryComparator ：按字节索引顺序比较指定字节数组，采用 Bytes.compareTo(byte[])
BinaryPrefixComparator： 与BinaryComparator相同，仅比较左端的数据是否相同
NullComparator ：判断给定的是否为空
BitComparator： 按位比较
SubstringComparator： 判断提供的子串是否出现在 value 中
5.5.2.过滤查询案例
以下案例演示了常用过滤器的使用：
- 行键过滤器：RowFilter
- 列簇过滤器：FamilyFilter
- 列过滤器：QualifierFilter
- 值过滤器：ValueFilter
- 行键前缀过滤器：PreFixFilter
- 列前缀过滤器：ColumnPrefixFilter
package cn.liny.hbase;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.filter.*;
/**
* 学习HBase高级查询：Filter
*/
public class HBaseFilter {
public static void main(String[] args) {
// 1.获取连接对象
Connection conn = HBaseUtil.getConnection();
// 2.行键过滤器：RowFilter
System.out.println("----------------------2.行键过滤器：RowFilter-----------------------------");
// 定义过滤器
Filter rowFilter = new RowFilter(CompareFilter.CompareOp.GREATER, new BinaryComparator("rowkey_10".getBytes()));
HBaseUtil.scanByFilter("my_ns:user",rowFilter);
//3.列簇过滤器： FamilyFilter
System.out.println("----------------------3.列簇过滤器： FamilyFilter-----------------------------");
// 定义过滤器
Filter familyFilter = new FamilyFilter(CompareFilter.CompareOp.EQUAL, new BinaryComparator("ext_info".getBytes()));
HBaseUtil.scanByFilter("my_ns:user",familyFilter);
//4.列过滤器 ：QualifierFilter
System.out.println("----------------------4.列过滤器 ：QualifierFilter-----------------------------");
// 定义过滤器
Filter qualifierFilter = new QualifierFilter(CompareFilter.CompareOp.EQUAL, new BinaryComparator("username".getBytes()));
HBaseUtil.scanByFilter("my_ns:user",qualifierFilter);
//5.值过滤器 ：ValueFilter
System.out.println("----------------------5.值过滤器 ：ValueFilter-----------------------------");
// 定义过滤器
Filter valueFilter = new ValueFilter(CompareFilter.CompareOp.EQUAL, new SubstringComparator("张三"));
HBaseUtil.scanByFilter("my_ns:user",valueFilter);
// 6.前缀过滤器：PrefixFilter----针对行键
System.out.println("----------------------6.前缀过滤器：PrefixFilter----针对行键-----------------------------");
// 定义过滤器
Filter prefixFilter = new PrefixFilter("rowkey_1".getBytes());
HBaseUtil.scanByFilter("my_ns:user",prefixFilter);
// 7.列前缀过滤器：ColumnPrefixFilter
System.out.println("----------------------7.列前缀过滤器：ColumnPrefixFilter-----------------------------");
// 定义过滤器
Filter columnPrefixFilter = new ColumnPrefixFilter("a".getBytes());
HBaseUtil.scanByFilter("my_ns:user",columnPrefixFilter);
// 关闭连接对象
HBaseUtil.closeConnection();
}
}
6.HBase的rowkey设计原则
HBase是三维有序存储的，通过rowkey（行键），column key（column family和qualifier）和TimeStamp（时间戳）这个三个维度可以对HBase中的数据进行快速定位。
HBase中rowkey可以唯一标识一行记录，三种查询方式
- 通过get方式，指定rowkey获取唯一一条记录
- 通过scan方式，设置startRow和stopRow参数进行范围匹配
- 全表扫描，即直接扫描整张表中所有行记录
6.1.Rowkey长度原则
rowkey是一个二进制码流，可以是任意字符串，最大长度64kb，实际应用中一般为10-100bytes，以byte[]形式保存，一般设计成定长。
建议越短越好，不要超过16个字节
案例说明：
- 数据的持久化文件HFile中是按照Key/Value存储的，如果rowkey过长，比如超过100字节，1000w行数据，光rowkey就要占用100*1000w=10亿个字节，将近1G数据，这样会极大影响HFile的存储效率；
- MemStore将缓存部分数据到内存，如果rowkey字段过长，内存的有效利用率就会降低，系统不能缓存更多的数据，这样会降低检索效率。
目前操作系统都是64位系统，内存8字节对齐，控制在16个字节，8字节的整数倍利用了操作系统的最佳特性。
6.2.Rowkey 散列原则
如果rowkey按照时间戳的方式递增，不要将时间放在二进制码的前面，建议将rowkey的高位作为散列字段，由程序随机生成，低位放时间字段，这样将提高数据均衡分布在每个RegionServer，以实现负载均衡的几率。
如果没有散列字段，首字段直接是时间信息，所有的数据都会集中在一个RegionServer上，这样在数据检索的时候负载会集中在个别的RegionServer上，造成热点问题，会降低查询效率。
6.3.Rowkey唯一原则
必须在设计上保证其唯一性，rowkey是按照字典顺序排序存储的，因此，设计rowkey的时候，要充分利用这个排序的特点，将经常读取的数据存储到一块，将最近可能会被访问的数据放到一块。但是这里的量不能太大，如果太大需要拆分到多个节点上去 。
6.4.具体设计参考
6.4.1.加盐
加盐指的是在rowkey的前面分配随机数，当给rowkey随机前缀后，它就能分布到不同的region中，这里的前缀应该和你想要数据分散的不同的region的数量有关。
- 案例需求
以电信公司为例 。当我们去电信公司打印通话记录。对于通话记录来说，每个人每月可能都有很多通话记录，同时电信的用户以亿计。这样的海量信息，可以考虑存入hbase当中 。那么在hbase中如何设计这样一张表呢？
-
确定需要保存的信息
对于通话记录 ，有主叫和被叫 信息，有通话时长，有通话时间 ，有主叫的位置信息，和被叫的位置信息 。那么可以确定要保存的信息：主叫、被叫、时长、时间、主叫位置、被叫位置
-
如何设计hbase表
hbase表是依靠rowkey来定位的，我们应该尽可能多的将查询的信息编入rowkey当中。设计通话记录的rowkey时，需要将能唯一确定该条记录的数据编入rowkey当中：主叫、被叫、时间
17766657999 18699886666 201806121502 #主叫，被叫，时间 -
该rowkey合理吗
该rowkey可能会造成热点问题。例如电话以177开头，hbase集群有100台，那么该数据可能只被存入一台或者两台机器的region中。当需要打印通话记录时，就只有一台机器提供服务。而如果数据均匀分散到100机器中，则是整个集群提供服务。两者之间效率速度差了不止一个数量级 。
因此我们可以考虑：hbase集群有100台，可以把在0-99之间中的随机数字，添加到rowkey首部 。
10 17766657999 18699886666 201806121502 #随机数，主叫，被叫，时间
6.4.2.预分区
hbase会自动处理region拆分，当region的大小到达一定阈值后，region将被拆分成两个。这个过程当中，会出现两个问题：
- 第一点还是热点问题，数据会继续往一个region中写，出现写热点问题
- 第二点是拆分合并风暴，当用户的region大小以恒定的速度增长，region的拆分会在同一时间发生，因为同时需要压缩region中的存储文件，这个过程会重写拆分后的region，这将会引起磁盘I/O上升 。
要解决以上问题，预分区（预先创建hbase表分区 ）是一种很好的方案，可以和加盐结合起来使用。使用预分区需要明确rowkey的取值范围和构成逻辑 。
-
案例需求：
还是上面电信电话详单表 ，通过加盐我们得到的 rowkey构成是：
随机数+主叫+被叫+时间，如果当前并没有100台机器，只有10台。但是预计未来将扩展到100台的规模。那么仍然设计0到99的随机数，将以主叫177开头的通话记录分配到十个region当中，将随机数均分成十个区域，范围如下：-10,10-20,20-30,30-40,40-50,50-60,60-70,70-80,80-90,90-将预分区存入数组当中，当插入数据时，先根据插入数据的首部随机数，判断分区位置，再进行插入数据。这样也能使得各台节点负载均衡。
6.4.3.哈希
哈希会使同一行永远用一个前缀加盐。哈希也可以使负载分散到整个集群。同时读是可以预测的。使用确定的哈希可以让客户端重构完整的rowkey，可以使用get操作准确获取某一个行数据
6.4.4.反转
对于手机号码，比较固定开头的rowkey（177,159,188），而后几位都是随机的，没有规律的。可以将手机号反转之后作为rowkey，避免热点问题 。
这就是rowkey设计的另一种方法：反转。通过反转固定长度或者数字格式的rowkey ，把rowkey中经常改变的部分（最没有意义的部分）放在前面 。可以有效的随机rowkey ，不过这样一来就牺牲了rowkey的有序性 。
7.MapReduce操作HBase
7.1.创建项目
7.2.导入依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>cn.liny</groupId>
<artifactId>spark-teach-day08-02hbase-hdfs</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<properties>
<!--hbase版本-->
<hbase.version>1.3.1</hbase.version>
</properties>
<dependencies>
<!--hbase依赖-->
<dependency>
<groupId>org.apache.hbase</groupId>
<artifactId>hbase-client</artifactId>
<version>${hbase.version}</version>
</dependency>
<dependency>
<groupId>org.apache.hbase</groupId>
<artifactId>hbase-server</artifactId>
<version>${hbase.version}</version>
</dependency>
</dependencies>
</project>
7.3.MapReduce从hdfs读取数据到HBase
7.3.1.案例代码
package cn.liny.hbase.hdfs;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.mapreduce.TableMapReduceUtil;
import org.apache.hadoop.hbase.mapreduce.TableReducer;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import java.io.IOException;
/**
* 学习HBase读取hdfs数据：通过MapReduce实现
*/
public class HBaseFromHDFS {
public static void main(String[] args) throws Exception{
// 创建配置对象
Configuration conf = HBaseConfiguration.create();
conf.set("hbase.zookeeper.quorum", "node01:2181,node02:2181,node03:2181");
// 创建Job
Job job = Job.getInstance(conf,"HBaseFromHDFS");
job.setJarByClass(HBaseFromHDFS.class);
// 设置map
job.setMapperClass(HDFSToHBaseMapper.class);
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(Text.class);
// 设置输入目录
FileInputFormat.addInputPath(job, new Path(args[0]));
TableMapReduceUtil.initTableReducerJob(args[1],HDFSToHBaseReducer.class, job);
job.waitForCompletion(true);
}
// HDFSToHBaseMapper
public static class HDFSToHBaseMapper extends Mapper<LongWritable, Text, Text, Text> {
private Text outKey = new Text();
private Text outValue = new Text();
// map函数
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
String[] splits = value.toString().split(" ");
outKey.set(splits[0]);
outValue.set(splits[1]+" "+splits[2]+" "+splits[3]+" "+splits[4]);
context.write(outKey, outValue);
}
}
// HDFSToHBaseReducer
public static class HDFSToHBaseReducer extends TableReducer<Text, Text, NullWritable> {
// reduce函数
protected void reduce(Text key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
Put put = new Put(key.getBytes());
String family="base_info";
for (Text v : values) {
String[] split = v.toString().split(" ");
if(split[0]!=null && !"NULL".equals(split[0])){
put.addColumn(family.getBytes(),"username".getBytes(),split[0].getBytes());
}
if(split[1]!=null && !"NULL".equals(split[1])){
put.addColumn(family.getBytes(),"sex".getBytes(),split[1].getBytes());
}
if(split[2]!=null && !"NULL".equals(split[2])){
put.addColumn(family.getBytes(),"birthday".getBytes(),split[2].getBytes());
}
if(split[3]!=null && !"NULL".equals(split[3])){
put.addColumn(family.getBytes(),"address".getBytes(),split[3].getBytes());
}
}
// 输出
context.write(NullWritable.get(),put);
}
}
}
7.3.2.配置执行环境
-
准备数据文件
user.txt：
rowkey_10 张三 1 2014-07-10 北京市 rowkey_16 张小明 1 2014-07-10 北京 rowkey_22 陈小明 1 2014-07-10 上海 rowkey_24 张三丰 1 2014-07-10 河南 rowkey_25 陈大明 1 2014-07-10 西安上传到hdfs：
#创建hdfs目录 hdfs dfs -mkdir -p /anan/hbase/input #上传文件 hdfs dfs -put /usr/local/develop/testdata/user.txt /anan/hbase/input
-
创建hbase表
create 'my_ns:huser','base_info' -
配置hadoop依赖hbase相关包
vi /usr/local/develop/hadoop274/etc/hadoop/hadoop-env.sh #配置HADOOP_CLASSPATH环境变量，指定hbase依赖包目录 export HADOOP_CLASSPATH=$HADOOP_CLASSPATH:/usr/local/develop/hbase131/lib/* -
项目打包，上传到linux服务器
7.3.3.提交任务执行
hadoop提交任务：
hadoop jar /usr/local/develop/testjar/spark-teach-day08-02hbase-hdfs-1.0-SNAPSHOT.jar \
cn.itheima.hbase.hdfs.HBaseFromHDFS \
/anan/hbase/input/user.txt my_ns:huser
执行结果：
7.4.MapReduce从HBase读取数据到hdfs
7.4.1.案例代码
package cn.liny.hbase.hdfs;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.mapreduce.TableMapReduceUtil;
import org.apache.hadoop.hbase.mapreduce.TableMapper;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import java.io.IOException;
import java.util.List;
/**
* 学习读取HBase保存到hdfs数据：通过MapReduce实现
*/
public class HBaseToHDFS {
public static void main(String[] args) throws Exception{
// 创建配置对象
Configuration conf = HBaseConfiguration.create();
conf.set("hbase.zookeeper.quorum", "node01:2181,node02:2181,node03:2181");
// 创建Job
Job job = Job.getInstance(conf,"HBaseToHDFS");
job.setJarByClass(HBaseToHDFS.class);
Scan scan = new Scan();
TableMapReduceUtil.initTableMapperJob(args[0], scan, HBaseToHDFSMapper.class, Text.class, Text.class, job);
// 设置输入目录
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(Text.class);
FileOutputFormat.setOutputPath(job, new Path(args[1]));
job.waitForCompletion(true);
}
// mapper
public static class HBaseToHDFSMapper extends TableMapper<Text, Text> {
Text outKey = new Text();
Text outValue = new Text();
/**
*map方法：
* 参数说明：
* key：hbase中的行键
* value：行键对应的所有数据
*/
protected void map(ImmutableBytesWritable key, Result value, Context context) throws IOException, InterruptedException {
StringBuilder builder =new StringBuilder();
boolean isContainsColumn = value.containsColumn("base_info".getBytes(),"username".getBytes());
if(isContainsColumn) {
List<Cell> listCells = value.getColumnCells("base_info".getBytes(), "username".getBytes());
Cell cell = listCells.get(0);
byte[] cloneValue = CellUtil.cloneValue(cell);
builder.append(Bytes.toString(cloneValue)).append(" ");
}
isContainsColumn = value.containsColumn("base_info".getBytes(),"sex".getBytes());
if(isContainsColumn) {
List<Cell> listCells = value.getColumnCells("base_info".getBytes(), "sex".getBytes());
Cell cell = listCells.get(0);
byte[] cloneValue = CellUtil.cloneValue(cell);
builder.append(Bytes.toString(cloneValue)).append(" ");
}
isContainsColumn = value.containsColumn("base_info".getBytes(),"birthday".getBytes());
if(isContainsColumn) {
List<Cell> listCells = value.getColumnCells("base_info".getBytes(), "birthday".getBytes());
Cell cell = listCells.get(0);
byte[] cloneValue = CellUtil.cloneValue(cell);
builder.append(Bytes.toString(cloneValue)).append(" ");
}
isContainsColumn = value.containsColumn("base_info".getBytes(),"address".getBytes());
if(isContainsColumn) {
List<Cell> listCells = value.getColumnCells("base_info".getBytes(), "address".getBytes());
Cell cell = listCells.get(0);
byte[] cloneValue = CellUtil.cloneValue(cell);
builder.append(Bytes.toString(cloneValue)).append(" ");
}
// 输出
outKey.set(Bytes.toString(key.get()));
outValue.set(builder.toString());
context.write(outKey,outValue);
}
}
//reducer
public static class HBaseToHDFSReducer extends Reducer<Text, Text, Text, Text> {
Text outValue = new Text();
protected void reduce(Text key, Iterable<Text> values,Context context)
throws IOException, InterruptedException {
outValue.set(values.toString());
context.write(key, outValue);
}
}
}
7.4.2.打包，提交任务执行
hadoop提交任务：
hadoop jar /usr/local/develop/testjar/spark-teach-day08-02hbase-hdfs-1.0-SNAPSHOT.jar \
cn.itheima.hbase.hdfs.HBaseToHDFS \
my_ns:huser /anan/hbase/output
执行结果：
hdfs dfs -cat /anan/hbase/output/part-r-00000
8.spark操作HBase
8.1.创建项目
8.2.导入依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>cn.liny</groupId>
<artifactId>spark-teach-day08-03hbase-spark</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<properties>
<scala.version>2.11.8</scala.version>
<spark.version>2.0.2</spark.version>
<!--hbase版本-->
<hbase.version>1.3.1</hbase.version>
</properties>
<dependencies>
<!--scala依赖-->
<dependency>
<groupId>org.scala-lang</groupId>
<artifactId>scala-library</artifactId>
<version>${scala.version}</version>
</dependency>
<!--spark依赖-->
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-streaming_2.11</artifactId>
<version>${spark.version}</version>
</dependency>
<!--hbase依赖-->
<dependency>
<groupId>org.apache.hbase</groupId>
<artifactId>hbase-client</artifactId>
<version>${hbase.version}</version>
</dependency>
<dependency>
<groupId>org.apache.hbase</groupId>
<artifactId>hbase-server</artifactId>
<version>${hbase.version}</version>
</dependency>
</dependencies>
<build>
<plugins>
<!--scala编译插件-->
<plugin>
<groupId>org.scala-tools</groupId>
<artifactId>maven-scala-plugin</artifactId>
<version>2.15.2</version>
<executions>
<execution>
<goals>
<goal>compile</goal>
</goals>
</execution>
</executions>
</plugin>
<!--项目打包插件-->
<plugin>
<artifactId>maven-assembly-plugin</artifactId>
<configuration>
<archive>
<manifest>
<mainClass>cn.itheima.hbase.spark.SparkToHBase</mainClass>
</manifest>
</archive>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
</configuration>
</plugin>
</plugins>
</build>
</project>
8.3.spark写入数据到HBase
8.3.1.编写案例代码
package cn.liny.hbase.spark
import org.apache.hadoop.conf.Configuration
import org.apache.hadoop.hbase.HBaseConfiguration
import org.apache.hadoop.hbase.client.Put
import org.apache.hadoop.hbase.io.ImmutableBytesWritable
import org.apache.hadoop.hbase.mapred.TableOutputFormat
import org.apache.hadoop.hbase.util.Bytes
import org.apache.hadoop.mapred.JobConf
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
/**
* spark将RDD数据写入HBase
*/
object SparkToHBase {
// 执行入口
def main(args: Array[String]): Unit = {
// 1.创建HBase配置
val conf: Configuration = HBaseConfiguration.create()
conf.set("hbase.zookeeper.quorum", "node01:2181,node02:2181,node03:2181")
// 2.指定输出格式和输出表名
val jobConf: JobConf = new JobConf(conf,this.getClass)
jobConf.setOutputFormat(classOf[TableOutputFormat])
jobConf.set(TableOutputFormat.OUTPUT_TABLE,"my_ns:s_user")
// 3.创建SparkContext对象
// 本地测试使用
val sparkConf: SparkConf = new SparkConf().setAppName("SparkToHBase").setMaster("local[2]")
//打包到集群环境使用
//val sparkConf: SparkConf = new SparkConf().setAppName("SparkToHBase")
val sc: SparkContext = new SparkContext(sparkConf)
sc.setLogLevel("WARN")
// 构建RDD数据
val dataRDD = List(("rowkey_1","lilei","16"), ("rowkey_2","hanmeimei","17"), ("rowkey_3","lucy","18"))
val resultRDD: RDD[(ImmutableBytesWritable, Put)] = sc.parallelize(dataRDD).map(convert)
// 写入HBase表
resultRDD.saveAsHadoopDataset(jobConf)
}
// 定义元组转换函数
// (1,"lilei",18)
def convert(tuple: (String, String, String)) = {
// 定义put
val put = new Put(Bytes.toBytes(tuple._1))
// 添加列数据
put.addColumn(Bytes.toBytes("base_info"),Bytes.toBytes("name"),Bytes.toBytes(tuple._2))
put.addColumn(Bytes.toBytes("base_info"),Bytes.toBytes("age"),Bytes.toBytes(tuple._3))
// 返回
(new ImmutableBytesWritable, put)
}
}
8.3.2.配置执行环境
-
创建hbase表
create 'my_ns:s_user','base_info' #查询数据 scan 'my_ns:s_user' -
如果要在集群环境使用，则需要启动spark集群，提交命令如下：
spark-submit --class cn.itheima.hbase.spark.SparkToHBase \ --master spark://hadoop01:7077 \ --executor-memory 1g --total-executor-cores 1 \ /usr/local/develop/testjar/spark-teach-day08-03hbase-spark-1.0-SNAPSHOT-jar-with-dependencies.jar
8.3.3.执行结果
8.4.spark从HBase读取数据
8.4.1.编写案例代码
package cn.liny.hbase.spark
import org.apache.hadoop.conf.Configuration
import org.apache.hadoop.hbase.HBaseConfiguration
import org.apache.hadoop.hbase.client.Result
import org.apache.hadoop.hbase.io.ImmutableBytesWritable
import org.apache.hadoop.hbase.mapreduce.TableInputFormat
import org.apache.hadoop.hbase.util.Bytes
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
/**
* spark从HBase读取数据，转换成RDD
*/
object SparkFromHBase {
// 执行入口
def main(args: Array[String]): Unit = {
// 1.创建HBase配置
val conf: Configuration = HBaseConfiguration.create()
conf.set("hbase.zookeeper.quorum", "hadoop01:2181,hadoop02:2181,hadoop03:2181")
// 2.设置查询的表名
conf.set(TableInputFormat.INPUT_TABLE, "my_ns:s_user")
// 3.创建SparkContext对象
val sparkConf: SparkConf = new SparkConf().setAppName("SparkFromHBase").setMaster("local[2]")
// 设置序列化
sparkConf.set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
sparkConf.registerKryoClasses(Array(classOf[org.apache.hadoop.hbase.io.ImmutableBytesWritable]))
val sc: SparkContext = new SparkContext(sparkConf)
sc.setLogLevel("WARN")
// 4.通过SparkContext 提供的newAPIHadoopRDD获取内容
val dataRDD: RDD[(ImmutableBytesWritable, Result)] = sc.newAPIHadoopRDD(conf, classOf[TableInputFormat],
classOf[ImmutableBytesWritable],
classOf[Result])
//5.遍历输出
dataRDD.foreach{ case (_,result) =>
val key = Bytes.toString(result.getRow)
val name = Bytes.toString(result.getValue("base_info".getBytes,"name".getBytes))
val age = Bytes.toString(result.getValue("base_info".getBytes,"age".getBytes))
println("Row key:"+key+",name="+name+",age="+age)
}
}
}
8.4.2.执行结果
扫一扫
239
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
