大数据技术之HBase+Redis详解

转化为中文描述就是

;1;先淘汰缓存

;2;再写数据库;这两步和原来一样;

;3;休眠1秒;再次淘汰缓存

这么做;可以将1秒内所造成的缓存脏数据;再次删除。

那么;这个1秒怎么确定的;具体该休眠多久呢?

针对上面的情形;读者应该自行评估自己的项目的读数据业务逻辑的耗时。然后写数据的休眠时间则在读数据业务逻辑的耗时基础上;加几百ms即可。这么做的目的;就是确保读请求结束;写请求可以删除读请求造成的缓存脏数据。

如果你用了mysql的读写分离架构怎么办?

ok;在这种情况下;造成数据不一致的原因如下;还是两个请求;一个请求A进行更新操作;另一个请求B进行查询操作。

;1;请求A进行写操作;删除缓存

;2;请求A将数据写入数据库了;

;3;请求B查询缓存发现;缓存没有值

;4;请求B去从库查询;这时;还没有完成主从同步;因此查询到的是旧值

;5;请求B将旧值写入缓存

;6;数据库完成主从同步;从库变为新值

上述情形;就是数据不一致的原因。还是使用双删延时策略。只是;睡眠时间修改为在主从同步的延时时间基础上;加几百ms。

采用这种同步淘汰策略;吞吐量降低怎么办?

ok;那就将第二次删除作为异步的。自己起一个线程;异步删除。这样;写的请求就不用沉睡一段时间后了;再返回。这么做;加大吞吐量。

第二次删除,如果删除失败怎么办?

这是个非常好的问题;因为第二次删除失败;就会出现如下情形。还是有两个请求;一个请求A进行更新操作;另一个请求B进行查询操作;为了方便;假设是单库;

;1;请求A进行写操作;删除缓存

;2;请求B查询发现缓存不存在

;3;请求B去数据库查询得到旧值

;4;请求B将旧值写入缓存

;5;请求A将新值写入数据库

;6;请求A试图去删除请求B写入对缓存值;结果失败了。

ok,这也就是说。如果第二次删除缓存失败;会再次出现缓存和数据库不一致的问题。

如何解决呢?

具体解决方案;且看博主对第(3)种更新策略的解析。

(3)先更新数据库;再删缓存

首先;先说一下。老外提出了一个缓存更新套路;名为《Cache-Aside pattern》。其中就指出

失效;应用程序先从cache取数据;没有得到;则从数据库中取数据;成功后;放到缓存中。

命中;应用程序从cache中取数据;取到后返回。

更新;先把数据存到数据库中;成功后;再让缓存失效。

另外;知名社交网站facebook也在论文《Scaling Memcache at Facebook》中提出;他们用的也是先更新数据库;再删缓存的策略。

这种情况不存在并发问题么?

不是的。假设这会有两个请求;一个请求A做查询操作;一个请求B做更新操作;那么会有如下情形产生

;1;缓存刚好失效

;2;请求A查询数据库;得一个旧值

;3;请求B将新值写入数据库

;4;请求B删除缓存

;5;请求A将查到的旧值写入缓存

ok;如果发生上述情况;确实是会发生脏数据。

然而;发生这种情况的概率又有多少呢?

发生上述情况有一个先天性条件;就是步骤;3;的写数据库操作比步骤;2;的读数据库操作耗时更短;才有可能使得步骤;4;先于步骤;5;。可是;大家想想;数据库的读操作的速度远快于写操作的;不然做读写分离干嘛;做读写分离的意义就是因为读操作比较快;耗资源少;;因此步骤;3;耗时比步骤;2;更短;这一情形很难出现。

假设;有人非要抬杠;有强迫症;一定要解决怎么办?

如何解决上述并发问题?

首先;给缓存设有效时间是一种方案。其次;采用策略;2;里给出的异步延时删除策略;保证读请求完成以后;再进行删除操作。

还有其他造成不一致的原因么?

有的;这也是缓存更新策略;2;和缓存更新策略;3;都存在的一个问题;如果删缓存失败了怎么办;那不是会有不一致的情况出现么。比如一个写数据请求;然后写入数据库了;删缓存失败了;这会就出现不一致的情况了。这也是缓存更新策略;2;里留下的最后一个疑问。

如何解决?

提供一个保障的重试机制即可;这里给出两套方案。

方案一;

如下图所示;

流程如下所示;

;1;更新数据库数据;

;2;缓存因为种种问题删除失败

;3;将需要删除的key发送至消息队列

;4;自己消费消息;获得需要删除的key

;5;继续重试删除操作;直到成功

然而;该方案有一个缺点;对业务线代码造成大量的侵入。于是有了方案二;在方案二中;启动一个订阅程序去订阅数据库的binlog;获得需要操作的数据。在应用程序中;另起一段程序;获得这个订阅程序传来的信息;进行删除缓存操作。

方案二;

流程如下图所示;

;1;更新数据库数据

;2;数据库会将操作信息写入binlog日志当中

;3;订阅程序提取出所需要的数据以及key

;4;另起一段非业务代码;获得该信息

;5;尝试删除缓存操作;发现删除失败

;6;将这些信息发送至消息队列

;7;重新从消息队列中获得该数据;重试操作。

备注说明;上述的订阅binlog程序在mysql中有现成的中间件叫canal;可以完成订阅binlog日志的功能。至于Oracle中;博主目前不知道有没有现成中间件可以使用。另外;重试机制;博主是采用的是消息队列的方式。如果对一致性要求不是很高;直接在程序中另起一个线程;每隔一段时间去重试即可;这些大家可以灵活自由发挥;只是提供一个思路。

存粒度控制

选用全量属性;通用性会更好;也便于维护;像user表这种;用全量属性还可以;

但我们选用缓存就需要考虑性能和空间的问题;只保存我们需要的属性就好了;但后期表结构改了;维护性很差;

3;缓存穿透;;直接对存储层操作;失去了缓存层的意义;

查询一个数据库中不存在的数据;比如商品详情;查询一个不存在的ID;每次都会访问DB;如果有人恶意破坏;很可能直接对DB造成过大地压力。

解决方案;

1.当通过某一个key去查询数据的时候;如果对应在数据库中的数据都不存在;我们将此key对应的value设置为一个默认的值;比如“NULL”;并设置一个缓存的失效时间;这时在缓存失效之前;所有通过此key的访问都被缓存挡住了。后面如果此key对应的数据在DB中存在时;缓存失效之后;通过此key再去访问数据;就能拿到新的value了。

2.常见的则是采用布隆过滤器;可以用很小的内存保留很多的数据;;将所有可能存在的数据哈希到一个足够大的bitmap中;一个一定不存在的数据会被 这个bitmap拦截掉;从而避免了对底层存储系统的查询压力。;布隆过滤器;实际上是一个很长的二进制向量和一系列随机映射函数。布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都远远超过一般的算法;缺点是有一定的误识别率和删除困难。;

关于布隆过滤器;

4;缓存雪崩;;缓存失效;

缓存同一时间大面积的失效;所以;后面的请求都会落到数据库上;造成数据库短时间内承受大量请求而崩掉。

解决方案;

1.将系统中key的缓存失效时间均匀地错开;防止统一时间点有大量的key对应的缓存失效;

2.重新设计缓存的使用方式;当我们通过key去查询数据时;首先查询缓存;如果此时缓存中查询不到;就通过分布式锁进行加锁;取得锁的进程查DB并设置缓存;然后解锁;其他进程如果发现有锁就等待;然后等解锁后返回缓存数据或者再次查询DB。

3.尽量保证整个 redis 集群的高可用性;发现机器宕机尽快补上

4.本地ehcache缓存 ; hystrix限流&降级;避免MySQL崩掉

假如已经崩溃了;也可以利用redis的持久化机制将保存的数据尽快恢复到缓存里。

5;缓存无底洞

为了满足业务大量加节点;但是性能没提升反而下降。

当客户端增加一个缓存的时候;只需要 mget 一次;但是如果增加到三台缓存;这个时候则需要 mget 三次了;网络通信的时间增加了;;每增加一台;客户端都需要做一次新的 mget;给服务器造成性能上的压力。

同时;mget 需要等待最慢的一台机器操作完成才能算是完成了 mget 操作。这还是并行的设计;如果是串行的设计就更加慢了。

通过上面这个实例可以总结出;更多的机器;=更高的性能

但是并不是没办法;一般在优化 IO 的时候可以采用以下几个方法。

1.命令的优化。例如慢查下 keys、hgetall bigkey。

2.我们需要减少网络通讯的次数。这个优化在实际应用中使用次数是最多的;我们尽量减少通讯次数。

3.降低接入成本。比如使用客户端长连接或者连接池、NIO 等等。

6;hashMap底层?为什么jdk1.8要用红黑树实现?什么时候会出现线程不安全?怎么解决线程不安全?默认初始容量是16;如果我改成7;容量会变成7么??为什么?

在JDK1.6;JDK1.7中;HashMap采用位桶;链表实现;即使用链表处理冲突;同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多;即hash值相等的元素较多时;通过key值依次查找的效率较低。而JDK1.8中;HashMap采用位桶;链表;红黑树实现;当链表长度超过阈值;8;时;将链表转换为红黑树;这样大大减少了查找时间。

不安全原因;

(1) 在put的时候;因为该方法不是同步的;假如有两个线程A,B它们的put的key的hash值相同;不论是从头插入还是从尾插入;假如A获取了插入位置为x;但是还未插入;此时B也计算出待插入位置为x;则不论AB插入的先后顺序肯定有一个会丢失

以下是put方法;

(2) 在扩容的时候;jdk1.8之前是采用头插法;当两个线程同时检测到hashmap需要扩容;在进行同时扩容的时候有可能会造成链表的循环;主要原因就是;采用头插法;新链表与旧链表的顺序是反的;在1.8后采用尾插法就不会出现这种问题;同时1.8的链表长度如果大于8就会转变成红黑树。

默认容量为16的原因;

关于这个默认容量的选择;JDK并没有给出官方解释;笔者也没有在网上找到关于这个任何有价值的资料。;如果哪位有相关的权威资料或者想法;可以留言交流;

根据作者的推断;这应该就是个经验值;Experience Value;;既然一定要设置一个默认的2^n 作为初始值;那么就需要在效率和内存使用上做一个权衡。这个值既不能太小;也不能太大。

太小了就有可能频繁发生扩容;影响效率。太大了又浪费空间;不划算。

所以;16就作为一个经验值被采用了。

7;常见的线程池有哪些?线程池中一个线程死了;就没有线程了么?如果在线程池中new了一个线程;这个线程是存在还是不存在?线程池中的一些参数有哪些?newCachedPool最大可开启的线程数是多少?

常见的线程池;

1、newCachedThreadPool

创建一个可缓存线程池;如果线程池长度超过处理需要;可灵活回收空闲线程;若无可回收;则新建线程。

这种类型的线程池特点是;

工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger. MAX_VALUE), 这样可灵活的往线程池中添加线程。如果长时间没有往线程池中提交任务;即如果工作线程空闲了指定的时间(默认为1分钟);则该工作线程将自动终止。终止后;如果你又提交了新的任务;则线程池重新创建一个工作线程。在使用CachedThreadPool时;一定要注意控制任务的数量;否则;由于大量线程同时运行;很有会造成系统瘫痪。

2、newFixedThreadPool

创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程;如果工作线程数量达到线程池初始的最大数;则将提交的任务存入到池队列中。FixedThreadPool是一个典型且优秀的线程池;它具有线程池提高程序效率和节省创建线程时所耗的开销的优点。但是;在线程池空闲时;即线程池中没有可运行任务时;它不会释放工作线程;还会占用一定的系统资源。

3、newSingleThreadExecutor

创建一个单线程化的Executor;即只创建唯一的工作者线程来执行任务;它只会用唯一的工作线程来执行任务;保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。如果这个线程异常结束;会有另一个取代它;保证顺序执行。单工作线程最大的特点是可保证顺序地执行各个任务;并且在任意给定的时间不会有多个线程是活动的。

4、newScheduleThreadPool

创建一个定长的线程池;而且支持定时的以及周期性的任务执行;支持定时及周期性任务执行。

手撕代码;

给你一个整数数组 nums 和一个正整数 k;请你判断是否可以把这个数组划分成一些由 k 个连续数字组成的集合。

如果可以;请返回 True;否则;返回 False。

示例 1;

输入;nums = [1,2,3,3,4,4,5,6], k = 4

输出;true

解释;数组可以分成 [1,2,3,4] 和 [3,4,5,6]。

示例 2;

输入;nums = [3,2,1,2,3,4,3,4,5,9,10,11], k = 3

输出;true

解释;数组可以分成 [1,2,3] , [2,3,4] , [3,4,5] 和 [9,10,11]。

示例 3;

输入;nums = [3,3,2,2,1,1], k = 3

输出;true

示例 4;

输入;nums = [1,2,3,4], k = 3

输出;false

解释;数组不能分成几个大小为 3 的子数组。

提示;

1 <= nums.length

<= 10^5

1 <= nums[i] <= 10^9

1 <= k <= nums.length

二、HBase

1、HBase简介

HBase是一种分布式、可扩展、支持海量数据存储的NoSQL数据库。

逻辑上;HBase的数据模型同关系型数据库很类似;数据存储在一张表中;有行有列。但从HBase的底层物理存储结构;K-V;来看;HBase更像是一个multi-dimensional map。

HBase逻辑结构;

HBase物理存储结构; 

2、数据模型

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中的数据全部是字节码形式存贮。

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提供高可用的支持。

4、HBase安装部署

1. Zookeeper正常部署

首先保证Zookeeper集群的正常部署;并启动之;

[yyds;hadoop102 zookeeper-3.5.7]$ bin/zkServer.sh start
[yyds;hadoop103 zookeeper-3.5.7]$ bin/zkServer.sh start
[yyds;hadoop104 zookeeper-3.5.7]$ bin/zkServer.sh start

[yyds;hadoop102 hadoop-3.1.3]$ sbin/start-dfs.sh
[yyds;hadoop103 hadoop-3.1.3]$ sbin/start-yarn.sh

[yyds;hadoop102 software]$ tar -zxvf hbase-2.0.5-bin.tar.gz -C /opt/module
[yyds;hadoop102 software]$ mv /opt/module/hbase-2.0.5 /opt/module/hbase

[yyds;hadoop102 ~]$ sudo vim /etc/profile.d/my_env.sh
添加
#HBASE_HOME
export HBASE_HOME=/opt/module/hbase
export PATH=$PATH:$HBASE_HOME/bin

export HBASE_MANAGES_ZK=false

<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>
</configuration>

hadoop102
hadoop103
hadoop104

[yyds;hadoop102 module]$ xsync hbase/

[yyds;hadoop102 hbase]$ bin/hbase-daemon.sh start master
[yyds;hadoop102 hbase]$ bin/hbase-daemon.sh start regionserver

<property>
        <name>hbase.master.maxclockskew</name>
        <value>180000</value>
        <description>Time difference of regionserver from master</description>
</property>

[yyds;hadoop102 hbase]$ bin/start-hbase.sh

[yyds;hadoop102 hbase]$ bin/stop-hbase.sh

[yyds;hadoop102 hbase]$ bin/stop-hbase.sh

[yyds;hadoop102 hbase]$ touch conf/backup-masters

[yyds;hadoop102 hbase]$ echo hadoop103 > conf/backup-masters

[yyds;hadoop102 hbase]$ scp -r conf/ hadoop103:/opt/module/hbase/
[yyds;hadoop102 hbase]$ scp -r conf/ hadoop104:/opt/module/hbase/

[yyds;hadoop102 hbase]$ bin/hbase shell

hbase(main):001:0> help

hbase(main):002:0> list_namespace

NAMESPACE                                                                                                                                                                                             
default(创建表时未指定命名空间的话默认在default下)                                                                                                
hbase(系统使用的;用来存放系统相关的元数据信息等;勿随便操作)  

hbase(main):010:0>  create_namespace ;test;

hbase(main):010:0> create_namespace ;test01;, {;author;=>;wyh;, ;create_time;=>;2020-03-10 08:08:08;}

hbase(main):010:0>  describe_namespace ;test01;

hbase(main):010:0> alter_namespace ;test01;, {METHOD => ;set;, ;author; => ;weiyunhui;}

alter_namespace ;ns1;, {METHOD => ;set;, ;PROPERTY_NAME; => ;PROPERTY_VALUE;} 

alter_namespace ;ns1;, {METHOD => ;unset;, NAME => ; PROPERTY_NAME ;} 

hbase(main):010:0> drop_namespace ;test01;

hbase(main):002:0> list

hbase(main):002:0> create ;student;,;info;

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;

hbase(main):008:0> scan ;student;
hbase(main):009:0> scan ;student;,{STARTROW => ;1001;, STOPROW  => ;1001;}
hbase(main):010:0> scan ;student;,{STARTROW => ;1001;}

hbase(main):011:0> describe ;student;

hbase(main):012:0> put ;student;,;1001;,;info:name;,;Nick;
hbase(main):013:0> put ;student;,;1001;,;info:age;,;100;

hbase(main):014:0> get ;student;,;1001;
hbase(main):015:0> get ;student;,;1001;,;info:name;

hbase(main):021:0> count ;student;

hbase(main):016:0> deleteall ;student;,;1001;

hbase(main):017:0> delete ;student;,;1002;,;info:sex;

hbase(main):018:0> truncate ;student;

hbase(main):019:0> disable ;student;

hbase(main):020:0> drop ;student;

hbase(main):022:0> alter ;student;,{NAME=>;info;,VERSIONS=>3}
hbase(main):022:0> get ;student;,;1001;,{COLUMN=>;info:name;,VERSIONS=>3}

<dependency>
    <groupId>org.apache.hbase</groupId>
    <artifactId>hbase-server</artifactId>
    <version>2.0.5</version>
</dependency>

<dependency>
    <groupId>org.apache.hbase</groupId>
    <artifactId>hbase-client</artifactId>
    <version>2.0.5</version>
</dependency>

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.NamespaceDescriptor;
import org.apache.hadoop.hbase.NamespaceExistException;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;

import java.io.IOException;

public class HBase_DDL {

    //TODO 判断表是否存在
    public static boolean isTableExist(String tableName) throws IOException {

        //1.创建配置信息并配置
        Configuration configuration = HBaseConfiguration.create();
        configuration.set(;hbase.zookeeper.quorum;, ;hadoop102,hadoop103,hadoop104;);

        //2.获取与HBase的连接
        Connection connection = ConnectionFactory.createConnection(configuration);

        //3.获取DDL操作对象
        Admin admin = connection.getAdmin();

        //4.判断表是否存在操作
        boolean exists = admin.tableExists(TableName.valueOf(tableName));

        //5.关闭连接
        admin.close();
        connection.close();

        //6.返回结果
        return exists;
    }

}

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.NamespaceDescriptor;
import org.apache.hadoop.hbase.NamespaceExistException;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;

import java.io.IOException;

public class HBase_DDL {

    //TODO 创建表
    public static void createTable(String tableName, String... cfs) throws IOException {

        //1.判断是否存在列族信息
        if (cfs.length <= 0) {
            System.out.println(;请设置列族信息;;);
            return;
        }

        //2.判断表是否存在
        if (isTableExist(tableName)) {
            System.out.println(;需要创建的表已存在;;);
            return;
        }

        //3.创建配置信息并配置
        Configuration configuration = HBaseConfiguration.create();
        configuration.set(;hbase.zookeeper.quorum;, ;hadoop102,hadoop103,hadoop104;);

        //4.获取与HBase的连接
        Connection connection = ConnectionFactory.createConnection(configuration);

        //5.获取DDL操作对象
        Admin admin = connection.getAdmin();

        //6.创建表描述器构造器
        TableDescriptorBuilder tableDescriptorBuilder = TableDescriptorBuilder.newBuilder(TableName.valueOf(tableName));

        //7.循环添加列族信息
        for (String cf : cfs) {
            ColumnFamilyDescriptorBuilder columnFamilyDescriptorBuilder = ColumnFamilyDescriptorBuilder.newBuilder(Bytes.toBytes(cf));
            tableDescriptorBuilder.setColumnFamily(columnFamilyDescriptorBuilder.build());
        }

        //8.执行创建表的操作
        admin.createTable(tableDescriptorBuilder.build());

        //9.关闭资源
        admin.close();
        connection.close();
    }

}

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.NamespaceDescriptor;
import org.apache.hadoop.hbase.NamespaceExistException;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;

import java.io.IOException;

public class HBase_DDL {

    //TODO 删除表
    public static void dropTable(String tableName) throws IOException {

        //1.判断表是否存在
        if (!isTableExist(tableName)) {
            System.out.println(;需要删除的表不存在;;);
            return;
        }

        //2.创建配置信息并配置
        Configuration configuration = HBaseConfiguration.create();
        configuration.set(;hbase.zookeeper.quorum;, ;hadoop102,hadoop103,hadoop104;);

        //3.获取与HBase的连接
        Connection connection = ConnectionFactory.createConnection(configuration);

        //4.获取DDL操作对象
        Admin admin = connection.getAdmin();

        //5.使表下线
        TableName name = TableName.valueOf(tableName);
        admin.disableTable(name);

        //6.执行删除表操作
        admin.deleteTable(name);

        //7.关闭资源
        admin.close();
        connection.close();
    }

}

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.NamespaceDescriptor;
import org.apache.hadoop.hbase.NamespaceExistException;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;

import java.io.IOException;

public class HBase_DDL {

    //TODO 创建命名空间
    public static void createNameSpace(String ns) throws IOException {

        //1.创建配置信息并配置
        Configuration configuration = HBaseConfiguration.create();
        configuration.set(;hbase.zookeeper.quorum;, ;hadoop102,hadoop103,hadoop104;);

        //2.获取与HBase的连接
        Connection connection = ConnectionFactory.createConnection(configuration);

        //3.获取DDL操作对象
        Admin admin = connection.getAdmin();

        //4.创建命名空间描述器
        NamespaceDescriptor namespaceDescriptor = NamespaceDescriptor.create(ns).build();

        //5.执行创建命名空间操作
        try {
            admin.createNamespace(namespaceDescriptor);
        } catch (NamespaceExistException e) {
            System.out.println(;命名空间已存在;;);
        } catch (Exception e) {
            e.printStackTrace();
        }

        //6.关闭连接
        admin.close();
        connection.close();

    }
}

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;

import java.io.IOException;

public class HBase_DML {

    //TODO 插入数据
    public static void putData(String tableName, String rowKey, String cf, String cn, String value) throws IOException {

        //1.获取配置信息并设置连接参数
        Configuration configuration = HBaseConfiguration.create();
        configuration.set(;hbase.zookeeper.quorum;, ;hadoop102,hadoop103,hadoop104;);

        //2.获取连接
        Connection connection = ConnectionFactory.createConnection(configuration);

        //3.获取表的连接
        Table table = connection.getTable(TableName.valueOf(tableName));

        //4.创建Put对象
        Put put = new Put(Bytes.toBytes(rowKey));

        //5.放入数据
        put.addColumn(Bytes.toBytes(cf), Bytes.toBytes(cn), Bytes.toBytes(value));

        //6.执行插入数据操作
        table.put(put);

        //7.关闭连接
        table.close();
        connection.close();
    }

}

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;

import java.io.IOException;

public class HBase_DML {

    //TODO 单条数据查询(GET)
    public static void getDate(String tableName, String rowKey, String cf, String cn) throws IOException {

        //1.获取配置信息并设置连接参数
        Configuration configuration = HBaseConfiguration.create();
        configuration.set(;hbase.zookeeper.quorum;, ;hadoop102,hadoop103,hadoop104;);

        //2.获取连接
        Connection connection = ConnectionFactory.createConnection(configuration);

        //3.获取表的连接
        Table table = connection.getTable(TableName.valueOf(tableName));

        //4.创建Get对象
        Get get = new Get(Bytes.toBytes(rowKey));
        // 指定列族查询
        // get.addFamily(Bytes.toBytes(cf));
        // 指定列族:列查询
        // get.addColumn(Bytes.toBytes(cf), Bytes.toBytes(cn));

        //5.查询数据
        Result result = table.get(get);

        //6.解析result
        for (Cell cell : result.rawCells()) {
            System.out.println(;ROW:; ; Bytes.toString(CellUtil.cloneRow(cell)) ;
                        ; CF:; ; Bytes.toString(CellUtil.cloneFamily(cell));
                        ; CL:; ; Bytes.toString(CellUtil.cloneQualifier(cell));
                        ; VALUE:; ; Bytes.toString(CellUtil.cloneValue(cell)));
        }

        //7.关闭连接
        table.close();
        connection.close();

    }

}

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;

import java.io.IOException;

public class HBase_DML {

    //TODO 扫描数据(Scan)
    public static void scanTable(String tableName) throws IOException {

        //1.获取配置信息并设置连接参数
        Configuration configuration = HBaseConfiguration.create();
        configuration.set(;hbase.zookeeper.quorum;, ;hadoop102,hadoop103,hadoop104;);

        //2.获取连接
        Connection connection = ConnectionFactory.createConnection(configuration);

        //3.获取表的连接
        Table table = connection.getTable(TableName.valueOf(tableName));

        //4.创建Scan对象
        Scan scan = new Scan();

        //5.扫描数据
        ResultScanner results = table.getScanner(scan);

        //6.解析results
        for (Result result : results) {
            for (Cell cell : result.rawCells()) {
      System.out.println(
                        Bytes.toString(CellUtil.cloneRow(cell));;:;;
                                Bytes.toString(CellUtil.cloneFamily(cell));;:; ;
                                Bytes.toString(CellUtil.cloneQualifier(cell)) ;;:; ;
                                Bytes.toString(CellUtil.cloneValue(cell))
                );
            }
        }

        //7.关闭资源
        table.close();
        connection.close();

    }

}

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;

import java.io.IOException;

public class HBase_DML {

    //TODO 删除数据
    public static void deletaData(String tableName, String rowKey, String cf, String cn) throws IOException {

        //1.获取配置信息并设置连接参数
        Configuration configuration = HBaseConfiguration.create();
        configuration.set(;hbase.zookeeper.quorum;, ;hadoop102,hadoop103,hadoop104;);

        //2.获取连接
        Connection connection = ConnectionFactory.createConnection(configuration);

        //3.获取表的连接
        Table table = connection.getTable(TableName.valueOf(tableName));

        //4.创建Delete对象
        Delete delete = new Delete(Bytes.toBytes(rowKey));

        // 指定列族删除数据
        // delete.addFamily(Bytes.toBytes(cf));
        // 指定列族:列删除数据(所有版本)
        // delete.addColumn(Bytes.toBytes(cf), Bytes.toBytes(cn));
        // 指定列族:列删除数据(指定版本)
        // delete.addColumns(Bytes.toBytes(cf), Bytes.toBytes(cn));

        //5.执行删除数据操作
        table.delete(delete);

        //6.关闭资源
        table.close();
        connection.close();

}

}

hbase> create ;staff1;,;info;,SPLITS => [;1000;,;2000;,;3000;,;4000;]

create ;staff2;,;info;,{NUMREGIONS => 15, SPLITALGO => ;HexStringSplit;}

aaaa
bbbb
cccc
dddd

create ;staff3;,;info;,SPLITS_FILE => ;splits.txt;

//自定义算法;产生一系列Hash散列值存储在二维数组中
byte[][] splitKeys = 某个散列值函数
//创建HbaseAdmin实例
HBaseAdmin hAdmin = new HBaseAdmin(HbaseConfiguration.create());
//创建HTableDescriptor实例
HTableDescriptor tableDesc = new HTableDescriptor(tableName);
//通过HTableDescriptor实例和散列值二维数组创建带有预分区的Hbase表
hAdmin.createTable(tableDesc, splitKeys);

比如;
原本rowKey为1001的;SHA1后变成;dd01903921ea24941c26a48f2cec24e0bb0e8cc7
原本rowKey为3001的;SHA1后变成;49042c54de64a1e9bf0b33e00245660ef92dc7bd
原本rowKey为5001的;SHA1后变成;7b61dec07e02c188790670af43e717f0f46e8913
在做此操作之前;一般我们会选择从数据集中抽取样本;来决定什么样的rowKey来Hash后作为每个分区的临界值。

20170524000001转成10000042507102
20170524000002转成20000042507102

20170524000001_a12e
20170524000001_93i7

属性;zookeeper.session.timeout
解释;默认值为90000毫秒;90s;。当某个RegionServer挂掉;90s之后Master才能察觉到。可适当减小此值;以加快Master响应;可调整至60000毫秒。

属性;hbase.regionserver.handler.count
解释;默认值为30;用于指定RPC监听的数量;可以根据客户端的请求数进行调整;读写请求较多时;增加此值。

属性;hbase.hregion.majorcompaction
解释;默认值;604800000秒;7天;; Major Compaction的周期;若关闭自动Major Compaction;可将其设为0

属性;hbase.hregion.max.filesize
解释;默认值10737418240;10GB;;如果需要运行HBase的MR任务;可以减小此值;因为一个region对应一个map任务;如果单个region过大;会导致map任务执行时间过长。该值的意思就是;如果HFile的大小达到这个数值;则这个region会被切分为两个Hfile。

属性;hbase.client.write.buffer
解释;默认值2097152bytes;2M;用于指定HBase客户端缓存;增大该值可以减少RPC调用次数;但是会消耗更多内存;反之则反之。一般我们需要设定一定的缓存大小;以达到减少RPC次数的目的。

属性;hbase.client.scanner.caching
解释;用于指定scan.next方法获取的默认行数;值越大;消耗内存越大。

属性;hfile.block.cache.size
解释;默认0.4;读请求比较多的情况下;可适当调大

属性;hbase.regionserver.global.memstore.size
解释;默认0.4;写请求较多的情况下;可适当调大

[yyds;hadoop102 module]$ tar -zxvf apache-phoenix-5.0.0-HBase-2.0-bin.tar.gz -C /opt/module/
[yyds;hadoop102 module]$ mv apache-phoenix-5.0.0-HBase-2.0-bin phoenix

[yyds;hadoop102 module]$ cd /opt/module/phoenix/
[yyds;hadoop102 phoenix]$ cp /opt/module/phoenix/phoenix-5.0.0-HBase-2.0-server.jar /opt/module/hbase/lib/
[yyds;hadoop102 phoenix]$ xsync /opt/module/hbase/lib/phoenix-5.0.0-HBase-2.0-server.jar

#phoenix
export PHOENIX_HOME=/opt/module/phoenix
export PHOENIX_CLASSPATH=$PHOENIX_HOME
export PATH=$PATH:$PHOENIX_HOME/bin

[yyds;hadoop102 ~]$ stop-hbase.sh
[yyds;hadoop102 ~]$ start-hbase.sh

[yyds;hadoop101 phoenix]$ /opt/module/phoenix/bin/sqlline.py hadoop102,hadoop103,hadoop104:2181

 <property>
        <name>phoenix.schema.isNamespaceMappingEnabled</name>
        <value>true</value>
    </property>

[yyds;hadoop102 ~]$ stop-hbase.sh
[yyds;hadoop102 ~]$ start-hbase.sh
[yyds;hadoop102 ~]$ /opt/module/phoenix/bin/sqlline.py hadoop102,hadoop103,hadoop104:2181

create schema bigdata;

!table 或 !tables

CREATE TABLE IF NOT EXISTS student(
id VARCHAR primary key,
name VARCHAR,
addr VARCHAR);

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));

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

[yyds;hadoop102 ~]$ /opt/module/hbase/bin/hbase shell

hbase(main):001:0> create ;test;,;info1;,;info2;

0: jdbc:phoenix:hadoop101,hadoop102,hadoop103> create view ;test;(id varchar primary key,;info1;.;name; varchar, ;info2;.;address; varchar);

0: jdbc:phoenix:hadoop101,hadoop102,hadoop103> drop view ;test;;

0: jdbc:phoenix:hadoop101,hadoop102,hadoop103> create table ;test;(id varchar primary key,;info1;.;name; varchar, ;info2;.;address; varchar) column_encoded_bytes=0;

hbase(main):001:0> create ;person;,;info;
hbase(main):001:0> put ;person;,;1001;, ;info:salary;,Bytes.toBytes(123456)

create table ;person;(id varchar primary key,;info;.;salary; integer )
column_encoded_bytes=0;
select * from ;person;

create table ;person;(id varchar primary key,;info;.;salary; unsigned_long )
column_encoded_bytes=0;

[yyds;hadoop102 ~]$ queryserver.py start

    <dependencies>
        <dependency>
            <groupId>org.apache.phoenix</groupId>
            <artifactId>phoenix-queryserver-client</artifactId>
            <version>5.0.0-HBase-2.0</version>
        </dependency>
    </dependencies>

package com.yyds;

import java.sql.*;
import org.apache.phoenix.queryserver.client.ThinClientUtil;

public class PhoenixTest {
public static void main(String[] args) throws SQLException {

        String connectionUrl = ThinClientUtil.getConnectionUrl(;hadoop102;, 8765);
        
        Connection connection = DriverManager.getConnection(connectionUrl);
        PreparedStatement preparedStatement = connection.prepareStatement(;select * from student;);

        ResultSet resultSet = preparedStatement.executeQuery();

        while (resultSet.next()) {
            System.out.println(resultSet.getString(1) ; ;	; ; resultSet.getString(2));
        }

        //关闭
        connection.close();

}
}

    <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.glassfish</groupId>
            <artifactId>javax.el</artifactId>
            <version>3.0.1-b06</version>
        </dependency>
    </dependencies>

package com.yyds.phoenix.thin;

import java.sql.*;
import java.util.Properties;

public class TestThick {

    public static void main(String[] args) throws SQLException {
        String url = ;jdbc:phoenix:hadoop102,hadoop103,hadoop104:2181;;
        Properties props = new Properties();
        props.put(;phoenix.schema.isNamespaceMappingEnabled;,;true;);
        Connection connection = DriverManager.getConnection(url,props);
        PreparedStatement ps = connection.prepareStatement(;select * from ;test;;);
        ResultSet rs = ps.executeQuery();
        while(rs.next()){
            System.out.println(rs.getString(1);;:; ;rs.getString(2));
        }
    }
}

    <!-- phoenix 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>

CREATE INDEX my_index ON my_table (my_col);

CREATE INDEX my_index ON my_table (v1) INCLUDE (v2);

CREATE LOCAL INDEX my_index ON my_table (my_column);

    <property>
        <name>hive.zookeeper.quorum</name>
        <value>hadoop102,hadoop103,hadoop104</value>
    </property>

    <property>
        <name>hive.zookeeper.client.port</name>
        <value>2181</value>
    </property>

CREATE TABLE hive_hbase_emp_table(
empno int,
ename string,
job string,
mgr int,
hiredate string,
sal double,
comm double,
deptno int)
STORED BY ;org.apache.hadoop.hive.hbase.HBaseStorageHandler;
WITH SERDEPROPERTIES (;hbase.columns.mapping; = ;:key,info:ename,info:job,info:mgr,info:hiredate,info:sal,info:comm,info:deptno;)
TBLPROPERTIES (;hbase.table.name; = ;hbase_emp_table;);

CREATE TABLE emp(
empno int,
ename string,
job string,
mgr int,
hiredate string,
sal double,
comm double,
deptno int)
row format delimited fields terminated by ;	;;

hive> load data local inpath ;/home/admin/softwares/data/emp.txt; into table emp;

hive> insert into table hive_hbase_emp_table select * from emp;

hive> select * from hive_hbase_emp_table;

Hbase> scan ;hbase_emp_table;

CREATE EXTERNAL TABLE relevance_hbase_emp(
empno int,
ename string,
job string,
mgr int,
hiredate string,
sal double,
comm double,
deptno int)
STORED BY 
;org.apache.hadoop.hive.hbase.HBaseStorageHandler;
WITH SERDEPROPERTIES (;hbase.columns.mapping; = 
;:key,info:ename,info:job,info:mgr,info:hiredate,info:sal,info:comm,info:deptno;) 
TBLPROPERTIES (;hbase.table.name; = ;hbase_emp_table;);

hive (default)> select * from relevance_hbase_emp;