hbase 订阅
HBase是一个分布式的、面向列的开源数据库,该技术来源于 Fay Chang 所撰写的Google论文“Bigtable:一个结构化数据的分布式存储系统”。就像Bigtable利用了Google文件系统(File System)所提供的分布式数据存储一样,HBase在Hadoop之上提供了类似于Bigtable的能力。HBase是Apache的Hadoop项目的子项目。HBase不同于一般的关系数据库,它是一个适合于非结构化数据存储的数据库。另一个不同的是HBase基于列的而不是基于行的模式。 展开全文
HBase是一个分布式的、面向列的开源数据库,该技术来源于 Fay Chang 所撰写的Google论文“Bigtable:一个结构化数据的分布式存储系统”。就像Bigtable利用了Google文件系统(File System)所提供的分布式数据存储一样,HBase在Hadoop之上提供了类似于Bigtable的能力。HBase是Apache的Hadoop项目的子项目。HBase不同于一般的关系数据库,它是一个适合于非结构化数据存储的数据库。另一个不同的是HBase基于列的而不是基于行的模式。
信息
系    统
Google
属    性
开源数据库
结    构
分布式存储系统
来    源
Fay Chang 所撰写的“Bigtable
中文名
HBase
隶    属
Apache的Hadoop项目
HBase结构介绍
HBase – Hadoop Database,是一个高可靠性、高性能、面向列、可伸缩的分布式存储系统,利用HBase技术可在廉价PC Server上搭建起大规模结构化存储集群。与FUJITSU Cliq等商用大数据产品不同,HBase是Google Bigtable的开源实现,类似Google Bigtable利用GFS作为其文件存储系统,HBase利用Hadoop HDFS作为其文件存储系统;Google运行MapReduce来处理Bigtable中的海量数据,HBase同样利用Hadoop MapReduce来处理HBase中的海量数据;Google Bigtable利用 Chubby作为协同服务,HBase利用Zookeeper作为对应。 [1]  上图描述Hadoop EcoSystem中的各层系统。其中,HBase位于结构化存储层,Hadoop HDFS为HBase提供了高可靠性的底层存储支持,Hadoop MapReduce为HBase提供了高性能的计算能力,Zookeeper为HBase提供了稳定服务和failover机制。 此外,Pig和Hive还为HBase提供了高层语言支持,使得在HBase上进行数据统计处理变的非常简单。 Sqoop则为HBase提供了方便的RDBMS数据导入功能,使得传统数据库数据向HBase中迁移变的非常方便。
收起全文
精华内容
参与话题
问答
  • hbase

    千次阅读 2018-08-03 11:34:02
    HBase是一个高可靠性、高性能、面向列、可伸缩的分布式存储系统。  适合于存储大表数据(表的规模可以达到数十亿行以及数百万列),并且对大表数据的读、写访问可以达到实时级别;  利用Hadoop HDFS...

    一、hbase

    HBase是一个高可靠性、高性能、面向列、可伸缩的分布式存储系统。

     适合于存储大表数据(表的规模可以达到数十亿行以及数百万列),并且对大表数据的读、写访问可以达到实时级别;
     利用Hadoop HDFS(Hadoop Distributed File System)作为其文件存储系统,提供高可靠性、高性能、列存储、可伸缩、实时读写的数据库系统;
     利用ZooKeeper作为协同服务。

    与RMDB比较:

    HBase
    分布式存储,面向列。
    动态扩展列。
    普通商用硬件支持,扩容成本低。
    RMDB
    数据结构固定。
    需要预先定义好数据结构。
    需要大量IO,扩展成本大。

    HBase适合具有如下需求的应用:

    海量数据(TB、PB)
    高吞吐量
    需要在海量数据中实现高效的随机读取
    需要很好的性能伸缩能力
    能够同时处理结构化和非结构化的数据
    不需要完全拥有传统关系型数据库所具备的ACID特性

    数据结构介绍:

    结构化数据
     具有固定的结构,属性划分,以及类型等信息。我们通常所理解的关系型数据库中所存储的数据信息,大多是结构化数据, 如职工信息表,拥有ID、Name、Phone、Address等属性信息。
     通常直接存放在数据库表中。数据记录的每一个属性对应数据表的一个字段。
    非结构化数据
     无法用统一的结构来表示,如文本文件、图像、视频、声音、网页等信息。
     数据记录较小时(如KB级别),可考虑直接存放到数据库表中(整条记录映射到某一个列中),这样也有利于整条记录的快速检索。
     数据较大时,通常考虑直接存放在文件系统中。数据库可用来存放相关数据的索引信息。
    半结构化数据
     具有一定的结构,但又有一定的灵活可变性。典型如XML、HTML等数据。其实也是非结构化数据的一种。
     可以考虑直接转换成结构化数据进行存储。
     根据数据记录的大小和特点,选择合适的存储方式。这一点与非结构化数据的存储类似。

    行列存储:
    按行存储:
    : 数据按行存储在底层文件系统中。通常,每一行会被分配固定的空间。
     优点:有利于增加/修改整行记录等操作;有利于整行数据的读取操作;
     缺点:单列查询时,会读取一些不必要的数据。

    按列存储:
    数据以列为单位,存储在底层文件系统中。
     优点:有利于面向单列数据的读取/统计等操作。
     缺点:整行读取时,可能需要多次I/O操作。

    主键设置规则:

    这里写图片描述

    Secondary Index

     HBase是一个Key-Value类型的分布式存储数据库。每张表的数据,是按照RowKey的字典顺序排序的,因此,如果按照某个指定的RowKey去查询数据,或者指定某一个RowKey范围去扫描数据时,HBase可以快速定位到需要读取的数据位置,从而可以高效地获取到所需要的数据。
     在实际应用中,很多场景是查询某一个列值为XXX的数据。HBase提供了Filter特性去支持这样的查询,它的原理是:按照RowKey的顺序,去遍历所有可能的数据,再依次去匹配那一列的值,直到获取到所需要的数据。可以看出,可能仅仅为了获取一行数据,它却扫描了很多不必要的数据。因此,如果对于这样的查询请求非常频繁并且对查询性能要求较高,使用Filter无法满足这个需求。
    这就是HBase二级索引产生的背景。二级索引为HBase提供了按照某些列的值进行索引的能力。
    这里写图片描述
    一般HBase的查询都是通过RowKey(要把多条件组合查询的字段都拼接在RowKey中显然不太可能),或者全表扫描再结合过滤器筛选出目标数据(太低效),所以通过设计HBase的二级索引来解决这个问题。
    对于HBase而言,如果想精确地定位到某行记录,唯一的办法是通过rowkey来查询。如果不通过rowkey来查找数据,就必须逐行地比较每一列的值,即全表扫瞄。对于较大的表,全表扫瞄的代价是不可接受的。
    但是,很多情况下,需要从多个角度查询数据。例如,在定位某个人的时候,可以通过姓名、身份证号、学籍号等不同的角度来查询,要想把这么多角度的数据都放到rowkey中几乎不可能(业务的灵活性不允许,对rowkey长度的要求也不允许)。
    所以,需要secondary index来完成这件事。secondary index的原理很简单,但是如果自己维护的话则会麻烦一些。现在,Phoenix已经提供了对HBase secondary index的支持,下面将说明这样用Phoenix来在HBase中创建二级索引。
    create index my_index on example (m.c0);

    ###HBase FileStream
    HBase文件存储模块(HBase FileStream,简称HFS)是HBase的独立模块,它作为对HBase与HDFS接口的封装,应用在FusionInsight HD的上层应用,为上层应用提供文件的存储、读取、删除等功能。
    在Hadoop生态系统中,无论是HDFS,还是HBase,均在面对海量文件的存储的时候,在某些场景下,都会存在一些很难解决的问题:
     如果把海量小文件直接保存在HDFS中,会给NameNode带来极大的压力。
     由于HBase接口以及内部机制的原因,一些较大的文件也不适合直接保存到HBase中。
    HFS的出现,就是为了解决需要在Hadoop中存储海量小文件,同时也要存储一些大文件的混合的
    场景。简单来说,就是在HBase表中,需要存放大量的小文件(10MB以下),同时又需要存放一
    些比较大的文件(10MB以上)。
    HFS为以上场景提供了统一的操作接口,这些操作接口与HBase的函数接口类似。
    注意事项
     如果只有小文件,确定不会有大文件的场景下,建议使用HBase的原始接口进行操作。
     HFS接口需要同时对HBase和HDFS进行操作,所以客户端用户需要同时拥有这两个组件的操作权限。
     直接存放在HDFS中的大文件,HFS在存储时会加入一些元数据信息,所以存储的文件不是直接等于原文件的。不能直接从HDFS中移动出来使用,而需要用HFS的接口进行读取。
     使用HFS接口存储在HDFS中的数据,暂不支持备份与容灾。
    这里写图片描述

    HBASE+Solr全文检索

    背景
    某电信项目中采用HBase来存储用户终端明细数据,供前台页面即时查询。HBase无可置疑拥有其优势,但其本身只对rowkey支持毫秒级的快速检索,对于多字段的组合查询却无能为力。针对HBase的多条件查询也有多种方案,但是这些方案要么太复杂,要么效率太低,本文只对基于Solr的HBase多条件查询方案进行测试和验证。
    原理
    基于Solr的HBase多条件查询原理很简单,将HBase表中涉及条件过滤的字段和rowkey在Solr中建立索引,通过Solr的多条件查询快速获得符合过滤条件的rowkey值,拿到这些rowkey之后在HBASE中通过指定rowkey进行查询。
    这里写图片描述
    HBase与Solr系统架构设计
    使用HBase搭建结构数据存储云,用来存储海量数据;使用SolrCloud集群用来搭建搜索引擎,将要查找的结构化数据的ID查找出来,只配置它存储ID。
    这里写图片描述
    wd代表用户write data写数据,从用户提交写数据请求wd1开始,经历wd2,写入MySQL数据库,或写入结构数据存储云中,wd3,提交到Solr集群中,从而依据业务需求创建索引。
    rd代表用户read data读数据,从用户提交读数据请求rd1开始,经历rd2,直接读取MySQL中数据,或向Solr集群请求搜索服务,rd3,向Solr集群请求得到的搜索结果为ID,再向结构数据存储云中通过ID取出数据,最后返回给用户结果。

    实现方法有两种
    手工编码,直接用HBASE的API,可以参考下文
    http://www.cnblogs.com/chenz/articles/3229997.html
    可以使用HBASE/Solr的LUNA接口,就不用自己管理两者。
    这里写图片描述

    二、部署

    当我们按照hadoop完全分布式集群搭建博客搭建了hadoop以后,发现这是一个空的hadoop,只有YARN,MapReduce,HDFS,而这些实际上我们一般不会直接使用,而是需要另外部署Hadoop的其他组件,来辅助使用。比如我们需要数据库,那么hadoop提供了分布式非关系型数据库hbase,用来存储半结构化,非结构化的一些数据,供我们查询使用等,下面我们来介绍一下,如何实现在完全分布式hadoop集群之上安装hbase。

    操作步骤

    1. 下载hbase1.2.6压缩包

    hbase1.2.6下载地址
    下载后上传到管理节点的opt目录下

    2. 解压缩hbase和修改目录名

     # cd /opt
     # tar -xzvf hbase-1.2.6-bin.tar.gz
     # mv hbase-1.2.6 hbase1.2.6
     # chmod 777 -R /opt/hbase1.2.6
    

    3. 配置环境变量

     # vim /etc/profile
    
    export JAVA_HOME=/opt/jdk1.8
    export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
    export PATH=$PATH:$JAVA_HOME/bin
    
    export HADOOP_HOME=/opt/hadoop2.6.0
    export PATH=$HADOOP_HOME/bin:$HADOOP_HOME/sbin:$PATH
    
    export HIVE_HOME=/opt/hive2.1.1
    export HIVE_CONF_DIR=$HIVE_HOME/conf
    export CLASSPATH=.:$HIVE_HOME/lib:$CLASSPATH
    export PATH=$PATH:$HIVE_HOME/bin
    
    export SQOOP_HOME=/opt/sqoop1.4.6
    export PATH=$PATH:$SQOOP_HOME/bin
    
    export ZOOKEEPER_HOME=/opt/zookeeper3.4.10
    export PATH=$PATH:$ZOOKEEPER_HOME/bin
    
    export HBASE_HOME=/opt/hbase1.2.6
    export PATH=$PATH:$HBASE_HOME/bin           #添加最后两行,hbase的相关环境变量属性
    
     # source /etc/profile              #使环境变量配置生效
    

    4. 修改hbase-env.sh配置文件

     # vim /opt/hbase1.2.6/conf/hbase-env.sh
    
    export JAVA_HOME=/opt/jdk1.8  
    export HADOOP_HOME=/opt/hadoop2.6.0 
    export HBASE_HOME=/opt/hbase1.2.6 
    export HBASE_CLASSPATH=/opt/hadoop2.6.0/etc/hadoop  
    export HBASE_PID_DIR=/opt/hbase1.2.6/pids  
    export HBASE_MANAGES_ZK=false
    

    这里写图片描述

    5. 修改hbase-site.xml配置文件

    # 创建目录
     # mkdir  /opt/hbase1.2.6/tmp  
     # mkdir  /opt/hbase1.2.6/pids 
    
     # cd /opt/hbase1.2.6/conf/
     # vim hbase-site.xml
    
    <configuration>
      <property>
        <name>hbase.rootdir</name>
        <value>hdfs://hadoop0:9000/hbase</value>
        <description>The directory shared byregion servers.</description>
      </property>
      <property>
        <name>hbase.zookeeper.property.clientPort</name>
        <value>2181</value>
        <description>Property from ZooKeeper'sconfig zoo.cfg. The port at which the clients will connect.
        </description>
      </property>
      <property>
        <name>zookeeper.session.timeout</name>
        <value>120000</value>
      </property>
      <property>
        <name>hbase.zookeeper.quorum</name>
        <value>hadoop0,hadoop1,hadoop2</value>   
      </property>
      <property>
        <name>hbase.tmp.dir</name>
        <value>/opt/hbase1.2.6/tmp</value>
      </property>
      <property>
        <name>hbase.cluster.distributed</name>
       <value>true</value>
      </property>
    </configuration>
    

    6. 修改regionservers配置文件

     # cd /opt/hbase1.2.6/conf
     # vim regionservers        # 添加集群的三个主机名
     
    hadoop0
    hadoop1
    hadoop2
    

    7. 拷贝管理节点的hbase到其他两个节点

     # cd /opt/ 
     # scp -r hbase1.2.6 root@hadoop1:/opt/ 
     # scp -r hbase1.2.6 root@hadoop2:/opt/  
    
    # 修改环境变量添加【在其他两个节点】
    
    export HBASE_HOME=/opt/hbase1.2.6
    export PATH=$PATH:$HBASE_HOME/bin
    

    8. 启动和测试

    启动

    首先先确保,hadoop和zookeeper正常运行,然后只需要在管理节点启动Hbase即可。

     # cd /opt//hbase1.2.6/bin     
     # ./start-hbase.sh
    

    这里写图片描述

    浏览器访问:http://192.168.210.70:16010/master-status

    这里写图片描述

    测试

    在主节点命令行,输入hbase shell,启动hbase后台

    这里写图片描述

    三、注意

    在Hbase搭建完之后,本想开开心心的启动Hbase,进行测试使用hbase,但是发现启动hbase的时候,报各种各样的错误,java_home,hbase,hadoop等找不到文件或目录,no such file or directory!

    [root@hadoop0 bin]# start-hbase.sh 
    /opt/hbase1.2.6/conf/hbase-env.sh: line 50: export JAVA_HOME=/opt/jdk1.8: No such file or directory
    /opt/hbase1.2.6/conf/hbase-env.sh: line 52: export HBASE_HOME=/opt/hbase1.2.6: No such file or directory
    /opt/hbase1.2.6/conf/hbase-env.sh: line 53: export HBASE_CLASSPATH=/opt/hadoop2.6.0/etc/hadoop: No such file or directory
    /opt/hbase1.2.6/conf/hbase-env.sh: line 54: export HBASE_PID_DIR=/opt/hbase1.2.6/pids: No such file or directory
    starting master, logging to /opt/hbase1.2.6/logs/hbase-root-master-hadoop0.out
    Java HotSpot(TM) 64-Bit Server VM warning: ignoring option PermSize=128m; support was removed in 8.0
    Java HotSpot(TM) 64-Bit Server VM warning: ignoring option MaxPermSize=128m; support was removed in 8.0
    Java HotSpot(TM) 64-Bit Server VM warning: ignoring option PermSize=128m; support was removed in 8.0
    Java HotSpot(TM) 64-Bit Server VM warning: ignoring option MaxPermSize=128m; support was removed in 8.0
    Java HotSpot(TM) 64-Bit Server VM warning: ignoring option PermSize=128m; support was removed in 8.0
    Java HotSpot(TM) 64-Bit Server VM warning: ignoring option MaxPermSize=128m; support was removed in 8.0
    Java HotSpot(TM) 64-Bit Server VM warning: ignoring option PermSize=128m; support was removed in 8.0
    Java HotSpot(TM) 64-Bit Server VM warning: ignoring option MaxPermSize=128m; support was removed in 8.0
    Java HotSpot(TM) 64-Bit Server VM warning: ignoring option PermSize=128m; support was removed in 8.0
    Java HotSpot(TM) 64-Bit Server VM warning: ignoring option MaxPermSize=128m; support was removed in 8.0
    hadoop0: /opt/hbase1.2.6/conf/hbase-env.sh: line 50: export JAVA_HOME=/opt/jdk1.8: No such file or directory
    hadoop0: /opt/hbase1.2.6/conf/hbase-env.sh: line 52: export HBASE_HOME=/opt/hbase1.2.6: No such file or directory
    hadoop0: /opt/hbase1.2.6/conf/hbase-env.sh: line 53: export HBASE_CLASSPATH=/opt/hadoop2.6.0/etc/hadoop: No such file or directory
    hadoop0: /opt/hbase1.2.6/conf/hbase-env.sh: line 54: export HBASE_PID_DIR=/opt/hbase1.2.6/pids: No such file or directory
    hadoop0: +======================================================================+
    hadoop0: |                    Error: JAVA_HOME is not set                       |
    hadoop0: +----------------------------------------------------------------------+
    hadoop0: | Please download the latest Sun JDK from the Sun Java web site        |
    hadoop0: |     > http://www.oracle.com/technetwork/java/javase/downloads        |
    hadoop0: |                                                                      |
    hadoop0: | HBase requires Java 1.7 or later.                                    |
    hadoop0: +======================================================================+
    hadoop2: /opt/hbase1.2.6/conf/hbase-env.sh: line 50: export JAVA_HOME=/opt/jdk1.8: No such file or directory
    hadoop2: /opt/hbase1.2.6/conf/hbase-env.sh: line 51: export HADOOP_HOME=/opt/hadoop2.6.0: No such file or directory
    hadoop2: /opt/hbase1.2.6/conf/hbase-env.sh: line 52: export HBASE_HOME=/opt/hbase1.2.6: No such file or directory
    hadoop2: /opt/hbase1.2.6/conf/hbase-env.sh: line 53: export HBASE_CLASSPATH=/opt/hadoop2.6.0/etc/hadoop: No such file or directory
    hadoop1: /opt/hbase1.2.6/conf/hbase-env.sh: line 50: export JAVA_HOME=/opt/jdk1.8: No such file or directory
    hadoop1: /opt/hbase1.2.6/conf/hbase-env.sh: line 51: export HADOOP_HOME=/opt/hadoop2.6.0: No such file or directory
    hadoop2: /opt/hbase1.2.6/conf/hbase-env.sh: line 54: export HBASE_PID_DIR=/opt/hbase1.2.6/pids: No such file or directory
    hadoop1: /opt/hbase1.2.6/conf/hbase-env.sh: line 52: export HBASE_HOME=/opt/hbase1.2.6: No such file or directory
    hadoop1: /opt/hbase1.2.6/conf/hbase-env.sh: line 53: export HBASE_CLASSPATH=/opt/hadoop2.6.0/etc/hadoop: No such file or directory
    hadoop2: /opt/hbase1.2.6/conf/hbase-env.sh: line 55: $'export\302\240HBASE_MANAGES_ZK=false': command not found
    hadoop1: /opt/hbase1.2.6/conf/hbase-env.sh: line 54: export HBASE_PID_DIR=/opt/hbase1.2.6/pids: No such file or directory
    hadoop1: /opt/hbase1.2.6/conf/hbase-env.sh: line 55: $'export\302\240HBASE_MANAGES_ZK=false': command not found
    hadoop2: +======================================================================+
    hadoop2: |                    Error: JAVA_HOME is not set                       |
    hadoop2: +----------------------------------------------------------------------+
    hadoop2: | Please download the latest Sun JDK from the Sun Java web site        |
    hadoop2: |     > http://www.oracle.com/technetwork/java/javase/downloads        |
    hadoop2: |                                                                      |
    hadoop2: | HBase requires Java 1.7 or later.                                    |
    hadoop2: +======================================================================+
    hadoop1: +======================================================================+
    hadoop1: |                    Error: JAVA_HOME is not set                       |
    hadoop1: +----------------------------------------------------------------------+
    hadoop1: | Please download the latest Sun JDK from the Sun Java web site        |
    hadoop1: |     > http://www.oracle.com/technetwork/java/javase/downloads        |
    hadoop1: |                                                                      |
    hadoop1: | HBase requires Java 1.7 or later.                                    |
    hadoop1: +======================================================================+
    

    解决方案

    # 查看hbase-env.sh文件
    
     # cd /opt/hbase1.2.6/conf
     # vim hbase-env.sh
    
    export HBASE_MANAGES_ZK=false
    export JAVA_HOME="/opt/jdk1.8"
    export HADOOP_HOME="/opt/hadoop2.6.0"
    export HBASE_HOME="/opt/hbase1.2.6"
    export HBASE_CLASSPATH="/opt/hadoop2.6.0/etc/hadoop"
    export HBASE_PID_DIR="/opt/hbase1.2.6/pids"
    
    # 上面这一块配置,全部重新手写,不要从网上复制过来直接黏贴,其中可能有中文字符,导致找不到环境变量
    

    修改后直接在主节点启动Hbase

     # start-hbase.sh    
    

    注:只需要在主节点上启动,从节点会自动全部开启hbase服务

    这里写图片描述

    这里写图片描述

    这里写图片描述

    四、自动关闭

    HBase启动后HMaster进程启动几秒后自动关闭
    产生错误的原因:zookeeper 链接信息过期了

    解决办法:进入zookeeper 删除hbase (rmr /hbase )重启zookeeper即可

    具体步骤:

    • 1、停止hbase(./stop-hbase.sh)
    • 2、hbase zkcli
    • 3、 ls / #扫描zookeeper中的数据
    • 4、 rmr / hbase #删除zookeeper中的hbase数据
    • 5、重新启动hbase即可

    五、python连hbase

    开启thrift:

    hbase thrift -p 9090 start
    ./hbase-daemons.sh start thrift

    代码测试

    from thrift.transport import TSocket,TTransport
    from thrift.protocol import TBinaryProtocol
    from hbase import Hbase
    
    # thrift默认端口是9090
    socket = TSocket.TSocket('192.168.186.48',9090)
    socket.setTimeout(5000)
    print("连接成功!")
    
    transport = TTransport.TBufferedTransport(socket)
    protocol = TBinaryProtocol.TBinaryProtocol(transport)
    
    client = Hbase.Client(protocol)
    socket.open()
    print(client.getTableNames())
    print(client.get('xmstest','xms','f1:name'))
    
    socket.close()
    
    展开全文
  • HBase

    千次阅读 2019-12-28 20:30:58
    Hbase全称为Hadoop Database(基于HDFS的数据库),设计来源Google 的bigtable,Hbase 仿照 bigtable设计基于HDFS上的一款数据库。 1.1 CAP原则 CAP原则又称之为CAP原理,指的是在分布式系统当中,一致性、可用性、...

    一、概述

    Hbase全称为Hadoop Database(基于HDFS的数据库),设计来源Google 的bigtable,Hbase 仿照 bigtable设计基于HDFS上的一款数据库。

    在这里插入图片描述

    1.1 CAP原则

    CAP原则又称之为CAP原理,指的是在分布式系统当中,一致性、可用性、分区容错性,三者不可兼得

    在这里插入图片描述

    HBase 是保证CP

    1.2 什么是基于列式存储?

    HBase 是基于列式存储的NoSql

    这个概念和RDBMS作对比,传统的数据库对数据的操作单位是一行(若干字段)

    select username ,pass from user where id = 1update  user set username ="gjf " where id =1; 
    

    即使操纵的是某一行记录当中的字段,其实RDBMS是查询了整行的内容加载完后完成对数据的修改

    行存储问题

    在这里插入图片描述

    列存储

    在这里插入图片描述

    1.3 HBase

    https://hbase.apache.org/

    Hbase 是基于列式存储的分布式的、面向列、基于HDFS的数据库,在需要实时读写,需要访问超大规模数据时,可以使用HBASE。

    1.3.1 特点:

    • 大 : 一个表可以有上亿行,可有上百万列
    • 面向列:可以支持稀疏存储
    • 无模式:表的结构灵活,可以任意增加和减少字段
    • 数据多版本:每个cell中的数据可以用多个版本,在默认情况下,版本号自动分配,版本的个数可以自己设置
    • 数据类型单一:Hbase中的数据都是字符串,没有类型

    1.3.2 名词解释

    • RowKey :与NoSQL数据库一样,rowkey是用来检索记录的主键
    • 列簇:列的合计,列簇必须在使用前进行定义
    • 时间戳:主要为版本提供方便
    • Cell单元格:由{rowkey,列名,列簇,时间戳}

    1.3.3 Hbase和关系型数据库的区别

    • 数据库类型:HBase中数据库类型都是字符串类型(String)
    • 数据操作:Hbase只有普通的增删查改等操作,没有表之间的关联查询
    • 存储模式:Hbase是基于列式存储的,而RDBMS是基于行式存储的
    • 应用场景:Hbase适合存储大容量数据,查询效率极高

    二、Hbase 环境搭建-单机

    2.1 环境

    • Hadoop
    • ZK

    2.2 下载安装

    [root@HadoopNode00 ~]# mkdir /home/hbase
    [root@HadoopNode00 ~]# tar -zxvf hbase-1.2.4-bin.tar.gz -C /home/hbase/
    [root@HadoopNode00 ~]# vi .bashrc
    export HBASE_HOME=/home/hbase/hbase-1.2.4
    export HBASE_MANAGES_ZK=false
    export PATH=$PATH:$HBASE_HOME/bin
    
    [root@HadoopNode00 ~]# vi /home/hbase/hbase-1.2.4/conf/hbase-site.xml
    
    <property>
         <name>hbase.rootdir</name>
         <value>hdfs://HadoopNode00:9000/hbase</value>
    </property>
    
    <property>
    	<name>hbase.zookeeper.quorum</name>
    	<value>HadoopNode00</value>
    </property>
    
    <property>
    	<name>hbase.zookeeper.property.clientPort</name>
    	<value>2181</value>
    </property>
    
    <property>
            <name>hbase.cluster.distributed</name>
            <value>true</value>
    </property>
    [root@HadoopNode00 ~]# vi /home/hbase/hbase-1.2.4/conf/regionservers
    HadoopNode00
    

    2.3 启动

    # 保证zk和hdfs启动成功
    [root@HadoopNode00 zookeeper-3.4.6]# start-hbase.sh
    starting master, logging to /home/hbase/hbase-1.2.4/logs/hbase-root-master-HadoopNode00.out
    Java HotSpot(TM) 64-Bit Server VM warning: ignoring option PermSize=128m; support was removed in 8.0
    Java HotSpot(TM) 64-Bit Server VM warning: ignoring option MaxPermSize=128m; support was removed in 8.0
    HadoopNode00: starting regionserver, logging to /home/hbase/hbase-1.2.4/logs/hbase-root-regionserver-HadoopNode00.out
    HadoopNode00: Java HotSpot(TM) 64-Bit Server VM warning: ignoring option PermSize=128m; support was removed in 8.0
    HadoopNode00: Java HotSpot(TM) 64-Bit Server VM warning: ignoring option MaxPermSize=128m; support was removed in 8.0
    [root@HadoopNode00 zookeeper-3.4.6]# jps
    2257 QuorumPeerMain
    2642 HRegionServer
    1906 DataNode
    1811 NameNode
    2485 HMaster
    2121 SecondaryNameNode
    2938 Jps
    
    

    web界面 : http://hadoopnode00:16010/master-status

    2.4 连接

    [root@HadoopNode00 zookeeper-3.4.6]# hbase shell
    

    三、Shell操作

    3.1 常见命令

    hbase(main):001:0> status
    1 active master, 0 backup masters, 1 servers, 0 dead, 2.0000 average load
    
    hbase(main):003:0> version
    1.2.4, rUnknown, Wed Feb 15 18:58:00 CST 2017
    
    hbase(main):004:0> whoami
    root (auth:SIMPLE)
        groups: root
    

    3.2 命名空间操作

    namespace 相当于MySQL中的数据库

    # 创建一个普通的命名空间
    hbase(main):006:0> create_namespace "baizhi"
    0 row(s) in 0.0870 seconds
    
    # 创建带属性的命名空间
    hbase(main):007:0> create_namespace "shahe",{'subway'=>'shahezhan'}
    0 row(s) in 0.0130 seconds
    
    #删除命名空间
    hbase(main):001:0> drop_namespace 'baizhi'
    0 row(s) in 0.1440 seconds
    
    # 描述命名空间
    hbase(main):001:0> describe_namespace 'shahe'
    DESCRIPTION
    {NAME => 'shahe', subway => 'shahezhan'}
    1 row(s) in 0.1300 seconds
    
    # 修改命名空间
    hbase(main):003:0> alter_namespace 'shahe',{METHOD => 'set', 'subway'=>'gonghuacheng'}
    0 row(s) in 0.0240 seconds
    
    hbase(main):004:0> describe_namespace 'shahe'
    DESCRIPTION
    {NAME => 'shahe', subway => 'gonghuacheng'}
    1 row(s) in 0.0060 seconds
    
    # 列出所有命名空间
    hbase(main):005:0> list_namespace
    NAMESPACE
    default
    hbase
    shahe
    3 row(s) in 0.0160 seconds
    
    

    3.3 表操作(DDL 数据定义语言)

    # 创建命名空间为baizhi
    hbase(main):007:0> create_namespace 'baizhi'
    0 row(s) in 0.0230 seconds
    
    # 创建baizhi namespace的下的表叫做 t_user,有两个列簇叫做 cf1 cf2
    hbase(main):008:0> create 'baizhi:t_user','cf1','cf2'
    0 row(s) in 2.2930 seconds
    
    => Hbase::Table - baizhi:t_user
    
    hbase(main):001:0> describe 'baizhi:t_user'
    Table baizhi:t_user is ENABLED
    baizhi:t_user
    COLUMN FAMILIES DESCRIPTION
    {NAME => 'cf1', BLOOMFILTER => 'ROW', VERSIONS => '1', IN_MEMORY => 'false', KEEP_DELETED_CELLS => 'FALSE', DATA_BL
    CODING => 'NONE', TTL => 'FOREVER', COMPRESSION => 'NONE', MIN_VERSIONS => '0', BLOCKCACHE => 'true', BLOCKSIZE =>
    ', REPLICATION_SCOPE => '0'}
    {NAME => 'cf2', BLOOMFILTER => 'ROW', VERSIONS => '1', IN_MEMORY => 'false', KEEP_DELETED_CELLS => 'FALSE', DATA_BL
    CODING => 'NONE', TTL => 'FOREVER', COMPRESSION => 'NONE', MIN_VERSIONS => '0', BLOCKCACHE => 'true', BLOCKSIZE =>
    ', REPLICATION_SCOPE => '0'}
    2 row(s) in 0.1930 seconds
    
    
    
    # 直接删除无法删除,需要将其先disable掉
    hbase(main):002:0> drop 'baizhi:t_user'
    
    ERROR: Table baizhi:t_user is enabled. Disable it first.
    
    Here is some help for this command:
    Drop the named table. Table must first be disabled:
      hbase> drop 't1'
      hbase> drop 'ns1:t1'
    
    # disable 表 (禁用表)
    hbase(main):003:0> disable
    disable                     disable_all                 disable_peer                disable_table_replication
    hbase(main):003:0> disable 'baizhi:t_user'
    0 row(s) in 2.2570 seconds
    
    # 删除表
    hbase(main):004:0> drop 'baizhi:t_user'
    0 row(s) in 1.2370 seconds
    
    
    hbase(main):001:0> create 'baizhi:t_user','cf1','cf2'
    0 row(s) in 1.3470 seconds
    
    => Hbase::Table - baizhi:t_user
    
    # 列出所有的表
    hbase(main):002:0> list
    TABLE
    baizhi:t_user
    1 row(s) in 0.0120 seconds
    
    => ["baizhi:t_user"]
    
    # 列出某个命名空间下的表
    hbase(main):003:0> list_namespace_tables 'baizhi'
    TABLE
    t_user
    1 row(s) in 0.0130 seconds
    
    
    

    3.4 数据操作(数据管理语言 DML)

    3.4.1 put

    # 最普通的插入语句的方式
    hbase(main):005:0> put 'baizhi:t_user','1','cf1:name','zhangsan'
    0 row(s) in 0.1010 seconds
    
    
    # 将表对象复制给变量t
    hbase(main):006:0> t = get_table 'baizhi:t_user'
    0 row(s) in 0.0010 seconds
    
    => Hbase::Table - baizhi:t_user
    
    # 使用复制对象t 对表进行操作
    hbase(main):007:0> t.put '1','cf1:age',18
    0 row(s) in 0.0110 seconds
    
    # 覆盖操作和put插入相似 写入相同的条件  写入值就可覆盖
    hbase(main):008:0> t.put '1','cf1:age',19
    0 row(s) in 0.0070 seconds
    # 扫描 当前的表
    hbase(main):009:0> t.scan
    ROW                           COLUMN+CELL
     1                            column=cf1:age, timestamp=1569278257582, value=19
     1                            column=cf1:name, timestamp=1569277976093, value=zhangsan
    1 row(s) in 0.0180 seconds
    
    

    3.4.2 get

    
    # 获取baizhi:t_user 下的rowk为1 的所有的cell
    hbase(main):013:0> get 'baizhi:t_user' ,'1'
    COLUMN                        CELL
     cf1:age                      timestamp=1569278257582, value=19
     cf1:name                     timestamp=1569277976093, value=zhangsan
    2 row(s) in 0.0120 seconds
    
    hbase(main):014:0> t.get '1'
    COLUMN                        CELL
     cf1:age                      timestamp=1569278257582, value=19
     cf1:name                     timestamp=1569277976093, value=zhangsan
    2 row(s) in 0.0030 seconds
    # 发现获取版本只有一个,是因为表目前不支持多版本
    hbase(main):015:0> t.get '1',{COLUMN=>'cf1:name',VERSIONS=>3}
    
    
    # 创建一个最多有三个版本的表
    hbase(main):001:0> create 'baizhi:t_user',{NAME=>'cf1',VERSIONS=>3}
    0 row(s) in 1.3510 seconds
    
    => Hbase::Table - baizhi:t_user
    
    hbase(main):006:0> t.get '1',{COLUMN=>'cf1:name',VERSIONS=>3}
    COLUMN                        CELL
     cf1:name                     timestamp=1569279103046, value=zs
     cf1:name                     timestamp=1569279081528, value=zhangsan
    2 row(s) in 0.0090 seconds
    
    

    3.4.3 delete /deleteall

    hbase(main):009:0> t.delete '1','cf1:name'
    0 row(s) in 0.0270 seconds
    hbase(main):010:0> t.scan
    ROW                           COLUMN+CELL
     1                            column=cf1:age, timestamp=1569279066158, value=18
    1 row(s) in 0.0090 seconds
    
    
    
    # 根据时间戳进行删除
    hbase(main):012:0> t.get '1',{COLUMN=>'cf1:age',VERSIONS=>3}
    COLUMN                        CELL
     cf1:age                      timestamp=1569279425168, value=19
     cf1:age                      timestamp=1569279066158, value=18
    2 row(s) in 0.0080 seconds
    hbase(main):013:0> t.delete '1','cf1:age',1569279066158
    0 row(s) in 0.0060 seconds
    hbase(main):014:0> t.get '1',{COLUMN=>'cf1:age',VERSIONS=>3}
    COLUMN                        CELL
     cf1:age                      timestamp=1569279425168, value=19
    1 row(s) in 0.0030 seconds
    
    hbase(main):002:0> deleteall 'baizhi:t_user','1'
    0 row(s) in 0.1600 seconds
    
    hbase(main):003:0> scan 'baizhi:t_user'
    ROW                           COLUMN+CELL
    0 row(s) in 0.0120 seconds
    
    
    

    3.4.4 scan

    #  查询列簇为cf1 从第一行开始
    hbase(main):019:0> scan 'baizhi:t_user',{COLUMNS=>['cf1'],STARTROW=>'1'}
    ROW                           COLUMN+CELL
     1                            column=cf1:age, timestamp=1569279798830, value=20
     1                            column=cf1:name, timestamp=1569279748288, value=zhangsan
     2                            column=cf1:age, timestamp=1569279809118, value=22
     2                            column=cf1:name, timestamp=1569279779869, value=wangwubaizhi
    2 row(s) in 0.0100 seconds
    
    #  查询列簇为cf1 从第二行开始
    hbase(main):020:0> scan 'baizhi:t_user',{COLUMNS=>['cf1'],STARTROW=>'2'}
    ROW                           COLUMN+CELL
     2                            column=cf1:age, timestamp=1569279809118, value=22
     2                            column=cf1:name, timestamp=1569279779869, value=wangwubaizhi
    1 row(s) in 0.0080 seconds
    
    #  查询列簇为cf1 从第三行开始
    hbase(main):021:0> scan 'baizhi:t_user',{COLUMNS=>['cf1'],STARTROW=>'3'}
    ROW                           COLUMN+CELL
    0 row(s) in 0.0040 seconds
    
    #  查询列簇为cf1 从第一行开始 只显示一行
    hbase(main):022:0> scan 'baizhi:t_user',{COLUMNS=>['cf1'],STARTROW=>'1',LIMIT=>1}
    ROW                           COLUMN+CELL
     1                            column=cf1:age, timestamp=1569279798830, value=20
     1                            column=cf1:name, timestamp=1569279748288, value=zhangsan
    1 row(s) in 0.0070 seconds
    #  查询列簇为cf1 从第一行开始 只显示两行
    hbase(main):023:0> scan 'baizhi:t_user',{COLUMNS=>['cf1'],STARTROW=>'1',LIMIT=>2}
    ROW                           COLUMN+CELL
     1                            column=cf1:age, timestamp=1569279798830, value=20
     1                            column=cf1:name, timestamp=1569279748288, value=zhangsan
     2                            column=cf1:age, timestamp=1569279809118, value=22
     2                            column=cf1:name, timestamp=1569279779869, value=wangwubaizhi
    2 row(s) in 0.0260 seconds
    
    

    3.4.5 count

    hbase(main):025:0> count 'baizhi:t_user'
    2 row(s) in 0.0130 seconds
    
    => 2
    
    

    3.4.6 append

    hbase(main):026:0> append 'baizhi:t_user','1','cf1:name','110'
    0 row(s) in 0.0070 seconds
    
    hbase(main):027:0> scan 'baizhi:t_user'
    ROW                           COLUMN+CELL
     1                            column=cf1:age, timestamp=1569279798830, value=20
     1                            column=cf1:name, timestamp=1569280127798, value=zhangsan110
     2                            column=cf1:age, timestamp=1569279809118, value=22
     2                            column=cf1:name, timestamp=1569279779869, value=wangwubaizhi
    2 row(s) in 0.0090 seconds
    
    
    

    3.4.7 truncate

    清空数据

    hbase(main):028:0> truncate 'baizhi:t_user'
    Truncating 'baizhi:t_user' table (it may take a while):
     - Disabling table...
     - Truncating table...
    0 row(s) in 3.4400 seconds
    
    hbase(main):001:0> scan 'baizhi:t_user'
    ROW                           COLUMN+CELL
    0 row(s) in 0.1550 seconds
    
    

    四、Java API

    4.1 依赖

    <!-- https://mvnrepository.com/artifact/org.apache.hbase/hbase-client -->
    <dependency>
        <groupId>org.apache.hbase</groupId>
        <artifactId>hbase-client</artifactId>
        <version>1.2.4</version>
    </dependency>
    
    

    4.2 核心操作

    获取客户端对象和连接对象

    
        @Before
        public void getClient() throws Exception {
            configuration = new Configuration();
    
            configuration.set("hbase.zookeeper.quorum", "HadoopNode00");
            configuration.set("hbase.zookeeper.property.clientPort", "2181");
            conn = ConnectionFactory.createConnection(configuration);
            admin = conn.getAdmin();
    
        }
        
    
        @After
        public void close() throws Exception {
            admin.close();
            conn.close();
    
        }
    

    4.3 namespace常规操作

     @Test
        public void createNameSpace() throws Exception {
            NamespaceDescriptor namespaceDescriptor = NamespaceDescriptor.create("baizhi123").addConfiguration("admin", "gjf").build();
            admin.createNamespace(namespaceDescriptor);
        }
    
        @Test
        public void listNameSpace() throws Exception {
    
            NamespaceDescriptor[] listNamespaceDescriptors = admin.listNamespaceDescriptors();
    
            for (NamespaceDescriptor listNamespaceDescriptor : listNamespaceDescriptors) {
                System.out.println(listNamespaceDescriptor.getName());
            }
    
    
        }
    
        @Test
        public void modifyNameSpace() throws Exception {
            NamespaceDescriptor namespaceDescriptor = NamespaceDescriptor.create("baizhi123").addConfiguration("aa", "bb").removeConfiguration("admin").build();
            admin.modifyNamespace(namespaceDescriptor);
    
    
        }
    
        @Test
        public void deleteNameSpace() throws Exception{
            admin.deleteNamespace("baizhi123");
    
        }
    

    4.4 表常规操作

    参考 http://hbase.apache.org/apidocs/org/apache/hadoop/hbase/

    @Test
        public void createTables() throws Exception {
    
            /*
            创建表名的对象(封装表名字)
            * */
            TableName tableName = TableName.valueOf("baizhi:t_user1");
    
    
            /*
             * 封装  表 的相关信息
             * */
    
    
            HTableDescriptor hTableDescriptor = new HTableDescriptor(tableName);
    
            /*
             * 封装列簇的相关信息
             * */
            HColumnDescriptor cf1 = new HColumnDescriptor("cf1");
            cf1.setMaxVersions(3);
    
    = 
            /*
             *
             * */
            HColumnDescriptor cf2 = new HColumnDescriptor("cf2");
            cf2.setMaxVersions(3);
    
            /*
             * 在hTableDescriptor 对象中添加列簇描述对象
             * */
    
    
            hTableDescriptor.addFamily(cf1);
            hTableDescriptor.addFamily(cf2);
    
    
            /*
             * 创建 table
             * */
            admin.createTable(hTableDescriptor);
    
        }
    
        @Test
    
        public void dropTable() throws Exception {
    
    
            TableName tableName = TableName.valueOf("baizhi:t_user1");
            admin.disableTable(tableName);
            admin.deleteTable(tableName);
        }
    
    

    4.5 CURD

    4.5.1 put

    更新单个记录

    @Test
        public void testPutOne() throws Exception {
    
            TableName tableName = TableName.valueOf("baizhi:t_user");
            /*
             * 通过conn对象获得table的操作对象
             * */
            Table table = conn.getTable(tableName);
    
            Put put1 = new Put("1".getBytes());
            put1.addColumn("cf1".getBytes(), "name".getBytes(), "zhangsan".getBytes());
            put1.addColumn("cf1".getBytes(), "age".getBytes(), "18".getBytes());
            put1.addColumn("cf1".getBytes(), "sex".getBytes(), "false".getBytes());
    
           
            table.put(put1);
            table.close();
    
        }
    

    插入多个记录

     @Test
        public void testPutList() throws Exception {
    
            TableName tableName = TableName.valueOf("baizhi:t_user");
            BufferedMutator bufferedMutator = conn.getBufferedMutator(tableName);
    
    
            Put put1 = new Put("4".getBytes());
            put1.addColumn("cf1".getBytes(), "name".getBytes(), "zhangsan".getBytes());
            put1.addColumn("cf1".getBytes(), "age".getBytes(), "18".getBytes());
            put1.addColumn("cf1".getBytes(), "sex".getBytes(), "false".getBytes());
    
            Put put2 = new Put("5".getBytes());
            put2.addColumn("cf1".getBytes(), "name".getBytes(), "zhangsan".getBytes());
            put2.addColumn("cf1".getBytes(), "age".getBytes(), "18".getBytes());
            put2.addColumn("cf1".getBytes(), "sex".getBytes(), "false".getBytes());
    
            Put put3 = new Put("6".getBytes());
            put3.addColumn("cf1".getBytes(), "name".getBytes(), "zhangsan".getBytes());
            put3.addColumn("cf1".getBytes(), "age".getBytes(), "18".getBytes());
            put3.addColumn("cf1".getBytes(), "sex".getBytes(), "false".getBytes());
    
            ArrayList<Put> puts = new ArrayList<Put>();
            puts.add(put1);
            puts.add(put2);
            puts.add(put3);
    
            bufferedMutator.mutate(puts);
    
            bufferedMutator.close();
    
        }
    
    

    4.5.2 delete

    单个删除

    
        @Test
        public void tetsDelete() throws Exception {
    
            TableName tableName = TableName.valueOf("baizhi:t_user");
            Table table = conn.getTable(tableName);
            Delete delete = new Delete("6".getBytes());
    
            table.delete(delete);
            table.close();
    
        }
    
    

    批量删除

    
        @Test
        public void testDeleteList() throws Exception{
    
    
            TableName tableName = TableName.valueOf("baizhi:t_user");
            BufferedMutator bufferedMutator = conn.getBufferedMutator(tableName);
    
            Delete delete1 = new Delete("1".getBytes());
            Delete delete2 = new Delete("2".getBytes());
            Delete delete3 = new Delete("3".getBytes());
    
            ArrayList<Delete> deletes = new ArrayList<Delete>();
    
            deletes.add(delete1);
            deletes.add(delete2);
            deletes.add(delete3);
    
            bufferedMutator.mutate(deletes);
    
            bufferedMutator.close();
    
    
        }
    

    4.5.3 get

    
    
    
        @Test
    
        public void testGet() throws Exception {
    
            TableName tableName = TableName.valueOf("baizhi:t_user");
            Table table = conn.getTable(tableName);
    
            Get get = new Get("4".getBytes());
    
    
            Result result = table.get(get);
    
            byte[] name = result.getValue("cf1".getBytes(), "name".getBytes());
            byte[] age = result.getValue("cf1".getBytes(), "age".getBytes());
            byte[] sex = result.getValue("cf1".getBytes(), "sex".getBytes());
    
            System.out.println(new String(name) + "-" + new String(age) + "-" + new String(sex));
    
        }
    
    
        @Test
        public void testGet02() throws Exception {
            /*
            *
            * hbase(main):012:0>  t.get '4',{COLUMN=>'cf1:name',VERSIONS=>3}
                COLUMN                        CELL
                cf1:name                     timestamp=1569284691440, value=zs
                cf1:name                     timestamp=1569283965094, value=zhangsan
    
            * */
    
            TableName tableName = TableName.valueOf("baizhi:t_user");
            Table table = conn.getTable(tableName);
    
            Get get = new Get("4".getBytes());
            get.setMaxVersions(2);
    
            get.addColumn("cf1".getBytes(), "name".getBytes());
    
            Result result = table.get(get);
    
            List<Cell> cellList = result.getColumnCells("cf1".getBytes(), "name".getBytes());
    
    
            for (Cell cell : cellList) {
                /*
                 * rowkey 列名  列值  时间戳
                 * */
    
    
                byte[] rowkey = CellUtil.cloneRow(cell);
                byte[] cf = CellUtil.cloneFamily(cell);
                byte[] qualifier = CellUtil.cloneQualifier(cell);
                byte[] value = CellUtil.cloneValue(cell);
                long timestamp = cell.getTimestamp();
    
                System.out.println(new String(rowkey) + "--" + new String(cf) + "--" + new String(qualifier) + "--" + new String(value) +"--" +timestamp);
    
    
            }
    
    
    

    4.5.4 scan

     @Test
        public void testScan() throws Exception {
    
            TableName tableName = TableName.valueOf("baizhi:t_user");
            Table table = conn.getTable(tableName);
    
            Scan scan = new Scan();
    
    
            PrefixFilter prefixFilter1 = new PrefixFilter("4".getBytes());
            PrefixFilter prefixFilter2 = new PrefixFilter("5".getBytes());
    
            FilterList list = new FilterList(FilterList.Operator.MUST_PASS_ONE,prefixFilter1, prefixFilter2);
            scan.setFilter(list);
    
    
            ResultScanner results = table.getScanner(scan);
    
            for (Result result : results) {
    
                byte[] row = result.getRow();
                byte[] name = result.getValue("cf1".getBytes(), "name".getBytes());
                byte[] age = result.getValue("cf1".getBytes(), "age".getBytes());
                byte[] sex = result.getValue("cf1".getBytes(), "sex".getBytes());
    
                System.out.println(new String(row) + "--" + new String(name) + "-" + new String(age) + "-" + new String(sex));
            }
    
    
        }
    
    

    五、MapReduce on Hbase

    5.1 依赖

    <dependency>
        <groupId>org.apache.hadoop</groupId>
        <artifactId>hadoop-hdfs</artifactId>
        <version>2.6.0</version>
    </dependency>
    <dependency>
        <groupId>org.apache.hadoop</groupId>
        <artifactId>hadoop-common</artifactId>
        <version>2.6.0</version>
    </dependency>
    
    <dependency>
        <groupId>org.apache.hadoop</groupId>
        <artifactId>hadoop-mapreduce-client-core</artifactId>
        <version>2.6.0</version>
    </dependency>
    <dependency>
        <groupId>org.apache.hadoop</groupId>
        <artifactId>hadoop-mapreduce-client-jobclient</artifactId>
        <version>2.6.0</version>
    </dependency>
    
    <dependency>
        <groupId>org.apache.hbase</groupId>
        <artifactId>hbase-client</artifactId>
        <version>1.2.4</version>
    </dependency>
    <dependency>
        <groupId>org.apache.hbase</groupId>
        <artifactId>hbase-server</artifactId>
        <version>1.2.4</version>
    </dependency>
    
    

    5.2 模拟问题

    HBase中有相关的数据 
    书写MR 程序
    运行
    
    baidu sina ali
    rowkey  salary  name age 
    
    package com.baizhi.mr;
    
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.hbase.client.Scan;
    import org.apache.hadoop.hbase.mapreduce.TableInputFormat;
    import org.apache.hadoop.hbase.mapreduce.TableMapReduceUtil;
    import org.apache.hadoop.hbase.mapreduce.TableOutputFormat;
    import org.apache.hadoop.io.DoubleWritable;
    import org.apache.hadoop.io.Text;
    import org.apache.hadoop.mapreduce.Job;
    import org.apache.hadoop.mapreduce.MRJobConfig;
    
    import javax.swing.*;
    
    public class JobRunner {
        public static void main(String[] args) throws Exception {
            System.setProperty("HADOOP_USER_NAME", "root");
    
            Configuration configuration = new Configuration();
    
            configuration.set("hbase.zookeeper.quorum", "HadoopNode00");
            configuration.set("hbase.zookeeper.property.clientPort", "2181");
    
            configuration.addResource("conf2/core-site.xml");
            configuration.addResource("conf2/hdfs-site.xml");
            configuration.addResource("conf2/mapred-site.xml");
            configuration.addResource("conf2/yarn-site.xml");
            configuration.set(MRJobConfig.JAR, "G:\\IDEA_WorkSpace\\BigData\\HBase_Test\\target\\HBase_Test-1.0-SNAPSHOT.jar");
            configuration.set("mapreduce.app-submission.cross-platform", "true");
    
            Job job = Job.getInstance(configuration);
            job.setJarByClass(JobRunner.class);
    
            /*
             *
             * */
            job.setInputFormatClass(TableInputFormat.class);
            job.setOutputFormatClass(TableOutputFormat.class);
    
    
    
            /*
             *
             * 设置mapper 相关
             * */
            TableMapReduceUtil.initTableMapperJob(
                    "baizhi:t_user1",
                    new Scan(),
                    UserMapper.class,
                    Text.class,
                    DoubleWritable.class,
                    job
            );
    
    
            TableMapReduceUtil.initTableReducerJob(
                    "baizhi:t_result",
                    UserReducer.class,
                    job);
    
    
            job.waitForCompletion(true);
        }
    }
    
    
    package com.baizhi.mr;
    
    import org.apache.hadoop.hbase.client.Result;
    import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
    import org.apache.hadoop.hbase.mapreduce.TableMapper;
    import org.apache.hadoop.hbase.util.Bytes;
    import org.apache.hadoop.io.DoubleWritable;
    import org.apache.hadoop.io.Text;
    
    import java.io.IOException;
    
    public class UserMapper extends TableMapper<Text, DoubleWritable> {
        @Override
        protected void map(ImmutableBytesWritable key, Result value, Context context) throws IOException, InterruptedException {
    
    
            byte[] bytes = key.get();
            String rowkey = Bytes.toString(bytes);
    
            String company = rowkey.split(":")[0];
    
            byte[] salaryByte = value.getValue("cf1".getBytes(), "salary".getBytes());
    
            double salary = Bytes.toDouble(salaryByte);
    
    
            context.write(new Text(company), new DoubleWritable(salary));
    
    
        }
    }
    
    
    package com.baizhi.mr;
    
    
    import org.apache.hadoop.hbase.client.Put;
    import org.apache.hadoop.hbase.mapreduce.TableReducer;
    import org.apache.hadoop.io.DoubleWritable;
    import org.apache.hadoop.io.NullWritable;
    import org.apache.hadoop.io.Text;
    
    import java.io.IOException;
    
    public class UserReducer extends TableReducer<Text, DoubleWritable, NullWritable> {
    
        @Override
        protected void reduce(Text key, Iterable<DoubleWritable> values, Context context) throws IOException, InterruptedException {
            double totalSalary = 0.0;
    
            int count = 0;
    
    
            for (DoubleWritable value : values) {
                totalSalary += value.get();
                count++;
    
            }
    
            Put put = new Put(key.getBytes());
    
            put.addColumn("cf1".getBytes(), "avgSalary".getBytes(), (totalSalary / count + "").getBytes());
    
    
            context.write(NullWritable.get(), put);
    
    
        }
    }
    
    

    5.3 最终结果

    在这里插入图片描述

    六、HBase 架构 (重点)

    6.1 名词解释

    (1)ZooKeeper

    • HBase 通过ZK来做Master 的高可用,如果Master异常,通过竞争选举产生新的Master 提供服务
    • HBase 通过ZK 来做 RegionServer的监控,当RegionServer异常时,调用的相关的容错机制
    • 元数据的入口和集群配置的维护工作,通过zk做外部统一入口

    (2)HMaster

    • 为RegionServer分配Region
    • 维护整个集群的负载均衡
    • 维护集群的元数据信息
    • 发现失效的Region,将失效的Region分配给正常的RegionServer
    • 当RegionServer失效时,协调对应的HLog拆分

    (3)HRegionServer

    • HRegionServer直接对接用户的读写请求
    • 管理Master 为其分配的Region
    • 处理来自客户端的请求,负责与HDFS 做交互,存储到HDFS
    • 负责对Region(变大)的拆分

    1)Region

    • Regions代表着一个表所有的数据
    • Region往往会做拆分,因为一个Region是无法存储Hbase 表中所有的数据
      • 拆分机制|切割条件:数据大小>=N^2 * 128MB,N 是Region的数量,当N=9 时,一般大小会超过10GB,此时以后按照10Gb进行拆分
    • Region 由Store组成
    • Region会分配到集群中称之为"RegionServer"的节点

    2)Store

    • 每一个Region有一个或者多个Store,至少有一个
    • 使用列簇划分Store,有几个列簇就有几个Stroe
    • 一个Store由一个MemStore和0或者多个HFile(StoreFile)组成

    3)MemStore

    • 写缓存,数据先写到MemStore中,在Flush到磁盘中
    • 以key value形式存储到磁盘中
    • MemStore flush 触发机制
      • MemStore级别限制:当Region中任意一个MemStore大小达到上限(hbase.region.master.flush.size 默认128MB)
      • Region级别限制:当Region中给所有的MemStore的大小总和达到了256MB(hbase.hregion.memstore.block.multiplier * hbase.hregion.memstore.flush.size,默认 2* 128M = 256M)
      • RegionServer 级别:当一个RegionServer中所有的MemStore大小总和上限到了(hbase.regionserver.global.memstore.upperLimit * hbase_heapsize,默认 40%的JVM内存使用量)
      • 当一个RegionServer中HLog数量达到上限(可通过参数hbase.regionserver.maxlogs配置),系统会选取最早的一个 HLog对应的一个或多个Region进行flush
      • Hbase 定时刷新:默认一个小时,确保数据不会长时间停留在内存中
      • 手动Flush:用户可以通过shell命令 flush ‘tablename’或者flush ‘region name’分别对一个表或者一个Region进行flush。

    4)HLog|WAL

    • 一个文件

    • 0.94之前叫做HLog,0.94 之后叫做WAL

    • 记录RegionServer上所有的编辑信息(Put、Deletes操作属于那个Region),在数据写入MemStore之前

    • 默认为一个WAL 日志,操作为串行操作,可能造成性能瓶颈,可以配置多个WAL 实例,进行并行写入(但是并行化是通过对多个Region进行分区实现的,如果只有一个Region那么该方案无效)

      • hbase-site.xml
        
        <property>   
          <name>hbase.wal.provider</name>   
          <value>multiwal</value> 
        </property>
        
    • RegionServer 宕机时 ,实现数据恢复

    5)HFile| StoreFile

    HFile( StoreFile)用于存储HBase 的数据,在HBase中数据是按照Rowkey|ColumnFamily|Column 排序。对与相同的Cell按照时间戳进行排序

    (4)HDFS

    HDFS 为HBase 存储提供服务,理论上Hbase 是可以无限扩容的,不用担心容量和容灾的问题,只需要保证其自身的高可用即可,不用去考虑存储系统的相关的问题

    6.2 HBase 架构图

    在这里插入图片描述

    七、集群搭建

    在这里插入图片描述

    HadoopNode01 HadoopNode02 HadoopNode03
    nn1 nn2
    journal node journal node journal node
    zkfc zkfc
    datanode datanode datanode
    zk01 zk02 zk03
    rm1 rm2
    nodemanager nodemanager nodemanager
    hregionserver hregionserver hregionserver
    hmaster hmaster hmaster
    • 必须安装Hadoop环境,并且HADOOP_HOME,因为HBase 会自动读取HDFS
    • 安装ZK集群(伪集群|单节点),保证其正常启动
    • 安装Hbase
    # 首先在三台zk节点中保证ZK成功启动
    
    [root@ZK01 ~]# /home/zk/zookeeper-3.4.6/bin/zkServer.sh start /home/zk/zookeeper-3.4.6/conf/zk.conf
    JMX enabled by default
    Using config: /home/zk/zookeeper-3.4.6/conf/zk.conf
    Starting zookeeper ... STARTED
    [root@ZK01 ~]# /home/zk/zookeeper-3.4.6/bin/zkServer.sh status /home/zk/zookeeper-3.4.6/conf/zk.conf
    JMX enabled by default
    Using config: /home/zk/zookeeper-3.4.6/conf/zk.conf
    Mode: follower
    
    
    # 配置安装Hbase 
    [root@HadoopNodeX ~]# mkdir /home/hbase
    [root@HadoopNodeX ~]# tar -zxvf hbase-1.2.4-bin.tar.gz -C /home/hbase/
    
    # 配置环境比变量
    
    [root@HadoopNodeX ~]# vi .bashrc
    export HBASE_HOME=/home/hbase/hbase-1.2.4
    export HBASE_MANAGES_ZK=false
    export PATH=$PATH:$HBASE_HOME/bin
    # 环境变量生效
    [root@HadoopNodeX ~]# source .bashrc
    
    
    [root@HadoopNodeX ~]# vi /home/hbase/hbase-1.2.4/conf/hbase-site.xml
    
    <property>
         <name>hbase.rootdir</name>
         <value>hdfs://mycluster/hbase</value>
    </property>
    
    <property>
    	<name>hbase.zookeeper.quorum</name>
    	<value>ZK01,ZK02,ZK03</value>
    </property>
    
    <property>
    	<name>hbase.zookeeper.property.clientPort</name>
    	<value>2181</value>
    </property>
    
    <property>
            <name>hbase.cluster.distributed</name>
            <value>true</value>
    </property>
    [root@HadoopNodeX ~]# vi /home/hbase/hbase-1.2.4/conf/regionservers
    HadoopNode01
    HadoopNode02
    HadoopNode03
    
    [root@HadoopNodeX ~]# hbase-daemon.sh start master
    [root@HadoopNodeX ~]# hbase-daemon.sh start regionserver
    

    八 、HBase 读写流程

    8.1 读流程

    在这里插入图片描述

    HBase读数据流程
    1 Client先访问zookeeper,从meta表读取region的位置,然后读取meta表中的数据。meta中又存储了用户表的region信息。
    2 根据namespace、表名和rowkey在meta表中找到对应的region信息
    3 找到这个region对应的regionserver
    4 查找对应的region
    5 先从MemStore找数据,如果没有,再到StoreFile上读(为了读取的效率)
    

    8.2 写流程

    在这里插入图片描述

    (1)Client向HRedgionServer  发送请求
    (2)HRegionServer将数据写到HLog(write ahead log)。为了数据的持久化和恢复;
    (3)HRegionServer将数据写到内存(MEMStroe)
    (4)反馈Client 写成功。
    
    HBase写数据流程
    1 Client首先访问zookeeper,从meta表获取相应region信息,然后找到meta表的数据
    2 根据namespace、表名和rowkey根据meta表的数据找到写入数据对应的region信息
    3 找到对应的regionserver
    4 把数据分别写到HLog和MemStore上一份
    4 MemStore达到一个阈值后则把数据刷成一个StoreFile文件。(若MemStore中的数据有丢失,则可以从HLog上恢复)
    5 当多个StoreFile文件达到一定的大小后,会触发Compact合并操作,合并为一个StoreFile,(这里同时进行版本的合并和数据删除。)
    6 当Storefile大小超过一定阈值后,会把当前的Region分割为两个(Split),并由Hmaster分配到相应的HRegionServer,实现负载均衡
    

    cluster.distributed
    true

    [root@HadoopNodeX ~]# vi /home/hbase/hbase-1.2.4/conf/regionservers
    HadoopNode01
    HadoopNode02
    HadoopNode03

    [root@HadoopNodeX ~]# hbase-daemon.sh start master
    [root@HadoopNodeX ~]# hbase-daemon.sh start regionserver

    
    
    
    
    
    
    
    # 八 、HBase 读写流程
    
    
    
    ## 8.1 读流程
    
    [外链图片转存中...(img-I6CAAwGz-1577535780190)]
    
    
    
    
    
    

    HBase读数据流程
    1 Client先访问zookeeper,从meta表读取region的位置,然后读取meta表中的数据。meta中又存储了用户表的region信息。
    2 根据namespace、表名和rowkey在meta表中找到对应的region信息
    3 找到这个region对应的regionserver
    4 查找对应的region
    5 先从MemStore找数据,如果没有,再到StoreFile上读(为了读取的效率)

    
    
    
    ## 8.2 写流程
    
    
    
    [外链图片转存中...(img-R2BGtO7h-1577535780190)]
    
    

    (1)Client向HRedgionServer 发送请求
    (2)HRegionServer将数据写到HLog(write ahead log)。为了数据的持久化和恢复;
    (3)HRegionServer将数据写到内存(MEMStroe)
    (4)反馈Client 写成功。

    
    

    HBase写数据流程
    1 Client首先访问zookeeper,从meta表获取相应region信息,然后找到meta表的数据
    2 根据namespace、表名和rowkey根据meta表的数据找到写入数据对应的region信息
    3 找到对应的regionserver
    4 把数据分别写到HLog和MemStore上一份
    4 MemStore达到一个阈值后则把数据刷成一个StoreFile文件。(若MemStore中的数据有丢失,则可以从HLog上恢复)
    5 当多个StoreFile文件达到一定的大小后,会触发Compact合并操作,合并为一个StoreFile,(这里同时进行版本的合并和数据删除。)
    6 当Storefile大小超过一定阈值后,会把当前的Region分割为两个(Split),并由Hmaster分配到相应的HRegionServer,实现负载均衡

    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    展开全文
  • 1HBase是一种 数据库A.列式数据库 B.键值数据库 C.文档数据库 D.关系数据库 2下列对HBase数据模型的描述错误的是A.HBase中执行更新操作时,会删除数据旧的版本,并生成一个新的版本 B.每个HBase表都由若干行组成,...

    1HBase是一种    数据库
    A.列式数据库
    B.键值数据库
    C.文档数据库
    D.关系数据库

    2下列对HBase数据模型的描述错误的是
    A.HBase中执行更新操作时,会删除数据旧的版本,并生成一个新的版本
    B.每个HBase表都由若干行组成,每个行由行键(row key)来标识
    C.HBase列族支持动态扩展,可以很轻松地添加一个列族或列
    D.HBase是一个稀疏、多维度、排序的映射表,这张表的索引是行键、列族、列限定符和时间戳

    3下列说法正确的是
    A.Zookeeper是一个集群管理工具,常用于分布式计算,提供配置维护、域名服务、分布式同步等。
    B.如果不启动Hadoop,则HBase完全无法使用
    C.如果通过HBase Shell插入表数据,可以插入一行数据或一个单元格数据。
    D.HBase的实现包括的主要功能组件是库函数,一个Master主服务器和一个Region服务器

    4每个Region的建议最佳大小是
    A.2GB-4GB
    B.1GB-2GB
    C.100MB-200MB
    D.500MB-1000MB

    5HBase三层结构的顺序是
    A.-ROOT-表,Zookeeper文件,.MEATA.表
    B..MEATA.表,Zookeeper文件,-ROOT-表
    C.Zookeeper文件,.MEATA.表,-ROOT-表
    D.Zookeeper文件,-ROOT-表,.MEATA.表

    6客户端是通过    级寻址来定位Region
    A.一
    B.二
    C.四
    D.三


    7关于HBase Shell命令解释错误的是
    A.list:显示表的所有数据
    B.create:创建表
    C.get:通过表名、行、列、时间戳、时间范围和版本号来获得相应单元格的值
    D.put:向表、行、列指定的单元格添加数据

    8下列对HBase的理解正确的是
    A.HBase是一种关系型数据库,现成功应用于互联网服务领域
    B.HBase是一个行式分布式数据库,是Hadoop生态系统中的一个组件
    C.HBase多用于存储非结构化和半结构化的松散数据
    D.HBase是针对谷歌BigTable的开源实现

    9HBase和传统关系型数据库的区别在于
    A.数据操作
    B.可伸缩性
    C.数据模型
    D.数据索引


    10访问HBase表中的行,有哪些方式
    A.全表扫描
    B.通过一个行健的区间来访问
    C.通过单个行健访问

    D.通过某列的值区间

     

     

    展开全文
  • HBase Shell命令大全

    万次阅读 多人点赞 2019-03-18 20:55:18
    HBase关键名称: Row Key 列族 column family 单元 Cell 时间戳 timestamp HBase Shell 是官方提供的一组命令,用于操作HBase。如果配置了HBase的环境变量了,就可以知己在命令行中输入hbase shell 命令进入命令行。...

    一:简介

    HBase的名字的来源于Hadoop database,即hadoop数据库,不同于一般的关系数据库,它是非结构化数据存储的数据库,而且它是基于列的而不是基于行的模式。

    HBase是一个分布式的、面向列的、基于Google Bigtable的开源实现。
    利用Hadoop HDFS作为其文件存储系统,
    利用Hadoop MapReduce来处理HBase中的海量数据,
    利用Zookeeper作为协同服务。

    二:HBase重要概念

    HBase的表结构

    HBase以表的形式存储数据。表有行和列组成。列划分为若干个列族/列簇(column family),每个列族/列簇下面可以有多个普通列。

    在这里插入图片描述

    表Table

    HBase是用表来存储数据的。

    命名空间namespace

    namespace命名空间指对一组表的逻辑分组,类似RDBMS中的database,方便对表在业务上划分。
    HBase系统默认定义了两个缺省的namespace:

    • hbase:系统内建表,包含namespace和meta表
    • default:用户建表时未指定namespace的表都创建在此

    行键 Row Key

    行键,每一行的主键列,每行的行键要唯一,行键的值为任意字符串(最大长度是 64KB,实际应用中长度一般为 10-100bytes),在HBase内部,rowKey保存为字节数组byte[]
    行的一次读写是原子操作 (不论一次读写多少列)

    区域Region

    Table在行的方向上分割为多个Region。

    Region是按大小分割的,每个表开始只有一个region,随着数据的增多,region不断增大,当增大到一个阀值的时候,region就会等分为两个新的region,之后会有越来越多的region。

    Region是HBase中分布式存储和负载均衡的最小单元。不同的Region分布到不同的RegionServer上。

    Region由一个或者多个Store组成, 每个Store保存一个column family, 每个Store又由一个MemStore(存储在内存中)和0到多个StoreFile(存储在HDFS上)组成
    在这里插入图片描述

    列族 column family

    列族是每个子列的父级,每个子列都属于一个列族,一个列族包含一个或者多个相关列,创建表的时候需要指定列族,而列不需要必须指定。通过“列族名:列名”来表示某个具体的子列。

    HBase中的Schema就是 TableName + Column Family Name

    列限定符

    就是列族下的每个子列名称,或者称为相关列,或者称为限定符,只是翻译不同。
    通过columnFamily:column来定位某个子列。

    存储单元 cell

    我们外观看到的每个单元格其实都对应着多个存储单元,默认情况下一个单元格对应着一个存储单元,一个存储单元可以存储一份数据,如果一个单元格有多个存储单元就表示一个单元格可以存储多个值。可以通过version来设置存储单元个数。可以通过
    rowKey + columnFamily + column + timestamp来唯一确定一个存储单元。cell中的数据是没有类型的,全部是字节码形式存贮。

    hbase按照时间戳降序排列各时间版本,其他映射建按照升序排序。

    时间戳版本号 timestamp

    每个cell都保存着同一份数据的多个版本。版本通过时间戳来索引。时间戳的类型是 64位整型。时间戳可以由hbase(在数据写入时自动 )赋值,此时时间戳是精确到毫秒的当前系统时间。时间戳也可以由客户显式赋值。如果应用程序要避免数据版本冲突,就必须自己生成具有唯一性的时间戳。每个cell中,不同版本的数据按照时间倒序排序,即最新的数据排在最前面。

    为了避免数据存在过多版本造成的的管理 (包括存贮和索引)负担,hbase提供了两种数据版本回收方式。一是保存数据的最后n个版本,二是保存最近一段时间内的版本(比如最近七天)。用户可以针对每个列族进行设置。

    三:HBase Shell

    命名 描述 语法
    help ‘命名名’ 查看命令的使用描述 help ‘命令名’
    whoami 我是谁 whoami
    version 返回hbase版本信息 version
    status 返回hbase集群的状态信息 status
    table_help 查看如何操作表 table_help
    create 创建表 create ‘表名’, ‘列族名1’, ‘列族名2’, ‘列族名N’
    alter 修改列族 添加一个列族:alter ‘表名’, ‘列族名’
    删除列族:alter ‘表名’, {NAME=> ‘列族名’, METHOD=> ‘delete’}
    describe 显示表相关的详细信息 describe ‘表名’
    list 列出hbase中存在的所有表 list
    exists 测试表是否存在 exists ‘表名’
    put 添加或修改的表的值 put ‘表名’, ‘行键’, ‘列族名’, ‘列值’
    put ‘表名’, ‘行键’, ‘列族名:列名’, ‘列值’
    scan 通过对表的扫描来获取对用的值 scan ‘表名’
    扫描某个列族: scan ‘表名’, {COLUMN=>‘列族名’}
    扫描某个列族的某个列: scan ‘表名’, {COLUMN=>‘列族名:列名’}
    查询同一个列族的多个列: scan ‘表名’, {COLUMNS => [ ‘列族名1:列名1’, ‘列族名1:列名2’, …]}
    get 获取行或单元(cell)的值 get ‘表名’, ‘行键’
    get ‘表名’, ‘行键’, ‘列族名’
    count 统计表中行的数量 count ‘表名’
    incr 增加指定表行或列的值 incr ‘表名’, ‘行键’, ‘列族:列名’, 步长值
    get_counter 获取计数器 get_counter ‘表名’, ‘行键’, ‘列族:列名’
    delete 删除指定对象的值(可以为表,行,列对应的值,另外也可以指定时间戳的值) 删除列族的某个列: delete ‘表名’, ‘行键’, ‘列族名:列名’
    deleteall 删除指定行的所有元素值 deleteall ‘表名’, ‘行键’
    truncate 重新创建指定表 truncate ‘表名’
    enable 使表有效 enable ‘表名’
    is_enabled 是否启用 is_enabled ‘表名’
    disable 使表无效 disable ‘表名’
    is_disabled 是否无效 is_disabled ‘表名’
    drop 删除表 drop的表必须是disable的
    disable ‘表名’
    drop ‘表名’
    shutdown 关闭hbase集群(与exit不同)
    tools 列出hbase所支持的工具
    exit 退出hbase shell

    HBase Shell 是官方提供的一组命令,用于操作HBase。如果配置了HBase的环境变量了,就可以知己在命令行中输入hbase shell 命令进入命令行。

    hbase shell
    

    在这里插入图片描述

    help命令

    可以通过 help '命名名称'来查看命令行的具体使用,包括命令的作用和用法。
    通过help ‘hbase’ 命名来查看hbase shell 支持的所有命令,hbase将命令进行分组,其中ddl、dml使用较多。
    在这里插入图片描述

    在这里插入图片描述

    四:general 命名

    1. 显示集群状态status

    可以为 ‘summary’, ‘simple’, ‘detailed’, or ‘replication’. 默认为 ‘summary’

    hbase> status
    hbase> status 'simple'
    hbase> status 'summary'
    hbase> status 'detailed'
    hbase> status 'replication'
    hbase> status 'replication', 'source'
    hbase> status 'replication', 'sink'
    

    在这里插入图片描述

    2. 查询数据库版本version

    在这里插入图片描述

    3. 显示当前用户与组 whoami

    在这里插入图片描述

    4. 查看操作表的命令table_help

    在这里插入图片描述

    5. 退出HBase Shell exit

    exit
    

    五:ddl命令

    1. 创建表create

    注意:创建表时只需要指定列族名称,不需要指定列名。

    # 语法
    create '表名', {NAME => '列族名1'}, {NAME => '列族名2'}, {NAME => '列族名3'}
    # 此种方式是上上面的简写方式,使用上面方式可以为列族指定更多的属性,如VERSIONS、TTL、BLOCKCACHE、CONFIGURATION等属性
    create '表名', '列族名1', '列族名2', '列族名3'
    
    create '表名', {NAME => '列族名1', VERSIONS => 版本号, TTL => 过期时间, BLOCKCACHE => true}
    
    
    # 示例
    create 'tbl_user', 'info', 'detail'
    create 't1', {NAME => 'f1', VERSIONS => 1, TTL => 2592000, BLOCKCACHE => true}
    

    在这里插入图片描述

    2. 修改(添加、删除)表结构Schema alter

    2.1 添加一个列族

    # 语法 
    alter '表名', '列族名'
    
    # 示例
    alter 'tbl_user', 'address'
    

    在这里插入图片描述

    2.2 删除一个列族

    # 语法 
    alter '表名', {NAME=> '列族名', METHOD=> 'delete'}
    
    # 示例
    alter 'tbl_user', {NAME=> 'address', METHOD=> 'delete'}
    

    在这里插入图片描述
    3.3 修改列族的属性
    可以修改列族的VERSIONS、IN_MEMORY

    # 修改f1列族的版本为5
    alter 't1', NAME => 'f1', VERSIONS => 5
    
    # 修改多个列族,修改f2为内存,版本号为5
    alter 't1', 'f1', {NAME => 'f2', IN_MEMORY => true}, {NAME => 'f3', VERSIONS => 5}
    
    # 也可以修改table-scope属性,例如MAX_FILESIZE, READONLY,MEMSTORE_FLUSHSIZE, DEFERRED_LOG_FLUSH等。
    # 例如,修改region的最大大小为128MB:
    alter 't1', MAX_FILESIZE => '134217728'
    

    3. 异步修改Schema alter_async

    # change or add the 'f1' column family in table 't1' from defaults
    to instead keep a maximum of 5 cell VERSIONS
    alter_async 't1', NAME => 'f1', VERSIONS => 5
    
    # delete the 'f1' column family in table 'ns1:t1'
    alter_async 'ns1:t1', NAME => 'f1', METHOD => 'delete'
    alter_async 'ns1:t1', 'delete' => 'f1'
    
    # change the max size of a family to 128MB
    alter 't1', METHOD => 'table_att', MAX_FILESIZE => '134217728'
    alter 't1', {NAME => 'f1'}, {NAME => 'f2', METHOD => 'delete'}
    

    4. 获取alter_async执行的状态 alter_status

    alter_status '表名'
    

    5. 获取表的描述describe

    # 语法 
    describe '表名'
    
    # 示例
    describe 'tbl_user'
    

    在这里插入图片描述

    6. 列举所有表list

    在这里插入图片描述

    7. 表是否存在exists

    # 语法 
    exists '表名'
    
    # 示例
    exists 'tbl_user'
    

    在这里插入图片描述

    8. 启用表enable和禁用表disable

    通过enable和disable来启用/禁用这个表,相应的可以通过is_enabled和is_disabled来检查表是否被禁用。

    # 语法
    enable '表名'
    is_enabled '表名'
    
    disable '表名'
    is_disabled '表名'
    
    # 示例
    disable 'tbl_user'
    is_disabled 'tbl_user'
    
    enable 'tbl_user'
    is_enabled 'tbl_user'
    

    在这里插入图片描述

    9. 禁用满足正则表达式的所有表disable_all

    • .匹配除“\n”和"\r"之外的任何单个字符
    • *匹配前面的子表达式任意次
    # 匹配以t开头的表名
    disable_all 't.*'
    # 匹配指定命名空间ns下的以t开头的所有表
    disable_all 'ns:t.*'
    # 匹配ns命名空间下的所有表
    disable_all 'ns:.*'
    

    10. 启用满足正则表达式的所有表enable_all

    enable_all 't.*'
    enable_all 'ns:t.*'
    enable_all 'ns:.*'
    

    11. 删除表drop

    需要先禁用表,然后再删除表,启用的表是不允许删除的

    # 语法
    disable '表名'
    drop '表名'
    
    # 示例
    disable 'tbl_user'
    drop 'tbl_user'
    

    在这里插入图片描述

    12. 删除满足正则表达式的所有表drop_all

    drop_all 't.*'
    drop_all 'ns:t.*'
    drop_all 'ns:.*'
    

    13. 获取某个表赋值给一个变量 get_table

    通过 var = get_table ‘表名’ 赋值给一个变量对象,然后对象.来调用,就像面向对象编程一样,通过对象.方法来调用,这种方式在操作某个表时就不必每次列举表名了。
    在这里插入图片描述

    14. 获取rowKey所在的区 locate_region

    locate_region '表名', '行键'
    

    在这里插入图片描述

    15. 显示hbase所支持的所有过滤器show_filters

    过滤器用于get和scan命令中作为筛选数据的条件,类型关系型数据库中的where的作用
    在这里插入图片描述


    六:namespace命令

    1. 列举命名空间 list_namespace

    在这里插入图片描述

    2. 获取命名空间描述 describe_namespace

    在这里插入图片描述

    3. 查看命名空间下的所有表 list_namespace_tables

    在这里插入图片描述

    4. 创建命名空间create_namespace

    在这里插入图片描述

    5. 修改命名空间的属性

    # add/modify a property
    alter_namespace 'ns1', {METHOD => 'set', 'PROPERTY_NAME' => 'PROPERTY_VALUE'}
    # delete a property
    alter_namespace 'ns1', {METHOD => 'unset', NAME=>'PROPERTY_NAME'}
    

    6. 删除命名空间drop_namespace

    drop_namespace '命名空间名称'
    

    七:dml命令

    1. 插入或者修改数据put

    # 语法
    # 当列族中只有一个列时'列族名:列名'使用'列族名'
    put '表名', '行键', '列族名', '列值'
    put '表名', '行键', '列族名:列名', '列值'
    
    # 示例
    
    # 创建表
    create 'tbl_user', 'info', 'detail', 'address'
    
    # 第一行数据
    put 'tbl_user', 'mengday', 'info:id', '1'
    put 'tbl_user', 'mengday', 'info:name', '张三'
    put 'tbl_user', 'mengday', 'info:age', '28'
    
    put 'tbl_user', 'mengday', 'detail:birthday', '1990-06-26'
    put 'tbl_user', 'mengday', 'detail:email', 'abc@163.com'
    put 'tbl_user', 'mengday', 'detail:create_time', '2019-03-04 14:26:10'
    
    put 'tbl_user', 'mengday', 'address', '上海市'
    
    # 第二行数据
    put 'tbl_user', 'vbirdbest', 'info:id', '2'
    put 'tbl_user', 'vbirdbest', 'info:name', '李四'
    put 'tbl_user', 'vbirdbest', 'info:age', '27'
    
    put 'tbl_user', 'vbirdbest', 'detail:birthday', '1990-06-27'
    put 'tbl_user', 'vbirdbest', 'detail:email', 'xxx@gmail.com'
    put 'tbl_user', 'vbirdbest', 'detail:create_time', '2019-03-05 14:26:10'
    
    put 'tbl_user', 'vbirdbest', 'address', '北京市'
    
    
    # 第一行数据
    put 'tbl_user', 'xiaoming', 'info:id', '3'
    put 'tbl_user', 'xiaoming', 'info:name', '王五'
    put 'tbl_user', 'xiaoming', 'info:age', '26'
    
    put 'tbl_user', 'xiaoming', 'detail:birthday', '1990-06-28'
    put 'tbl_user', 'xiaoming', 'detail:email', 'xyz@qq.com'
    put 'tbl_user', 'xiaoming', 'detail:create_time', '2019-03-06 14:26:10'
    
    put 'tbl_user', 'xiaoming', 'address', '杭州市'
    

    在这里插入图片描述

    2. 全表扫描scan

    获取表的所有数据

    # 语法
    scan '表名'
    
    # 示例
    scan 'tbl_user'
    

    在这里插入图片描述
    注意:中文编码了

    扫描整个列簇

    # 语法
    scan '表名', {COLUMN=>'列族名'}
    
    # 示例
    scan 'tbl_user', {COLUMN=>'info'}
    

    在这里插入图片描述

    扫描整个列簇的某个列

    # 语法
    scan '表名', {COLUMN=>'列族名:列名'}
    
    # 示例
    scan 'tbl_user', {COLUMN=>'info:age'}
    

    在这里插入图片描述

    3. 获取数据get

    # 语法
    get '表名', '行键'
    
    # 示例
    get 'tbl_user', 'mengday'
    

    在这里插入图片描述
    根据某一行某列族的数据

    # 语法
    get '表名', '行键', '列族名'
    
    # 示例
    get 'tbl_user', 'mengday', 'info'
    

    在这里插入图片描述

    # 创建表,c1版本为4, 元数据mykey=myvalue
    hbase(main):009:0> create 't1', {NAME => 'c1', VERSIONS => 4}, METADATA => { 'mykey' => 'myvalue' }
    0 row(s) in 2.2810 seconds
    
    => Hbase::Table - t1
    # 添加列族c2, c3
    hbase(main):010:0> alter 't1', 'c2', 'c3'
    Updating all regions with the new schema...
    1/1 regions updated.
    Done.
    Updating all regions with the new schema...
    1/1 regions updated.
    Done.
    0 row(s) in 3.8320 seconds
    
    # 出入数据,c1 插入4个版本的值
    hbase(main):011:0> put 't1', 'r1', 'c1', 'v1'
    0 row(s) in 0.1000 seconds
    
    hbase(main):012:0> put 't1', 'r1', 'c1', 'v11'
    0 row(s) in 0.0180 seconds
    
    hbase(main):013:0> put 't1', 'r1', 'c1', 'v111'
    0 row(s) in 0.0140 seconds
    
    hbase(main):014:0> put 't1', 'r1', 'c1', 'v1111'
    0 row(s) in 0.0140 seconds
    
    # 插入c2、c3的值
    hbase(main):015:0> put 't1', 'r1', 'c2', 'v2'
    0 row(s) in 0.0140 seconds
    
    hbase(main):016:0> put 't1', 'r1', 'c3', 'v3'
    0 row(s) in 0.0210 seconds
    
    # 获取rowKey=r1的一行记录
    hbase(main):017:0> get 't1', 'r1'
    COLUMN                                              CELL
     c1:                                                timestamp=1552819382575, value=v1111
     c2:                                                timestamp=1552819392398, value=v2
     c3:                                                timestamp=1552819398244, value=v3
    3 row(s) in 0.0550 seconds
    
    # 获取rowKey=r1并且 1552819392398 <= 时间戳范围 < 1552819398244
    hbase(main):018:0> get 't1', 'r1', {TIMERANGE => [1552819392398, 1552819398244]}
    COLUMN                                              CELL
     c2:                                                timestamp=1552819392398, value=v2
    1 row(s) in 0.0090 seconds
    
    # 获取指定列的值
    hbase(main):019:0> get 't1', 'r1', {COLUMN => 'c1'}
    COLUMN                                              CELL
     c1:                                                timestamp=1552819382575, value=v1111
    1 row(s) in 0.0160 seconds
    
    # 获取指定列的值,多个值使用数组表示
    hbase(main):020:0> get 't1', 'r1', {COLUMN => ['c1', 'c2', 'c3']}
    COLUMN                                              CELL
     c1:                                                timestamp=1552819382575, value=v1111
     c2:                                                timestamp=1552819392398, value=v2
     c3:                                                timestamp=1552819398244, value=v3
    3 row(s) in 0.0170 seconds
    
    # 获取c1的值,获取4个版本的值,默认是按照时间戳降续排序的
    hbase(main):021:0> get 't1', 'r1', {COLUMN => 'c1', VERSIONS => 4}
    COLUMN                                              CELL
     c1:                                                timestamp=1552819382575, value=v1111
     c1:                                                timestamp=1552819376343, value=v111
     c1:                                                timestamp=1552819368993, value=v11
     c1:                                                timestamp=1552819362975, value=v1
    4 row(s) in 0.0180 seconds
    
    # 获取c1的3个版本值
    hbase(main):027:0* get 't1', 'r1', {COLUMN => 'c1', VERSIONS => 3}
    COLUMN                                               CELL
     c1:                                                 timestamp=1552819382575, value=v1111
     c1:                                                 timestamp=1552819376343, value=v111
     c1:                                                 timestamp=1552819368993, value=v11
    3 row(s) in 0.0090 seconds
    
    # 获取指定时间戳版本的列
    hbase(main):022:0> get 't1', 'r1', {COLUMN => 'c1', TIMESTAMP => 1552819376343}
    COLUMN                                              CELL
     c1:                                                timestamp=1552819376343, value=v111
    1 row(s) in 0.0170 seconds
    
    hbase(main):023:0> get 't1', 'r1', {COLUMN => 'c1', TIMESTAMP => 1552819376343, VERSIONS => 4}
    COLUMN                                              CELL
     c1:                                                timestamp=1552819376343, value=v111
    1 row(s) in 0.0130 seconds
    
    # 获取rowKey=r1中的值等于v2的所有列
    hbase(main):024:0> get 't1', 'r1', {FILTER => "ValueFilter(=, 'binary:v2')"}
    COLUMN                                              CELL
     c2:                                                timestamp=1552819392398, value=v2
    1 row(s) in 0.0510 seconds
    
    
    hbase(main):025:0> get 't1', 'r1', {COLUMN => 'c1', ATTRIBUTES => {'mykey'=>'myvalue'}}
    COLUMN                                              CELL
     c1:                                                timestamp=1552819382575, value=v1111
    1 row(s) in 0.0100 seconds
    

    4. 删除某个列族中的某个列delete

    # 语法
    delete '表名', '行键', '列族名:列名'
    
    
    create 'tbl_test', 'columnFamily1'
    
    put 'tbl_test', 'rowKey1', 'columnFamily1:column1', 'value1'
    put 'tbl_test', 'rowKey1', 'columnFamily1:column2', 'value2'
    
    delete 'tbl_test', 'rowKey1', 'columnFamily1:column1'
    

    在这里插入图片描述

    5. 删除某行数据deleteall

    # 语法
    deleteall '表名', '行键'
    
    # 示例
    deleteall 'tbl_test', 'rowKey1'
    

    在这里插入图片描述

    6. 清空整个表的数据truncate

    先disable表,然后再drop表,最后重新create表

    truncate '表名'
    

    在这里插入图片描述

    7. 查询表中有多少行count

    # 语法
    count '表名'
    
    # 示例
    count 'tbl_user'
    

    在这里插入图片描述

    8. 自增incr

    # 语法
    incr '表名', '行键', '列族:列名', 步长值
    
    # 示例 
    # 注意:incr 可以对不存的行键操作,如果行键已经存在会报错,如果使用put修改了incr的值再使用incr也会报错
    # ERROR: org.apache.hadoop.hbase.DoNotRetryIOException: Field is not a long, it's 2 bytes wide
    incr 'tbl_user', 'xiaohong', 'info:age', 1
    

    在这里插入图片描述

    9. 计数器get_counter

    # 点击量:日、周、月
    create 'counters', 'daily', 'weekly', 'monthly'
    incr 'counters', '20110101', 'daily:hits', 1
    incr 'counters', '20110101', 'daily:hits', 1
    get_counter 'counters', '20110101', 'daily:hits'
    

    在这里插入图片描述

    10. 修饰词

    10.1 COLUMNS: 查询同一个列族的多个列
    # 语法
    
    scan '表名', {COLUMNS => [ '列族名1:列名1', '列族名1:列名2', ...]}
    
    # 示例
    scan 'tbl_user', {COLUMNS => [ 'info:id', 'info:age']}
    

    在这里插入图片描述

    10.2 TIMESTAMP 指定时间戳
    scan 't1', {COLUMNS => 'c2', TIMESTAMP=> 1552819392398}
    
    10.3 TIMERANGE表示的是”>=开始时间 and <结束时间“
    # 语法
    scan '表名',{TIMERANGE=>[timestamp1, timestamp2]}
    
    # 示例
    scan 'tbl_user',{TIMERANGE=>[1551938004321, 1551938036450]}
    

    在这里插入图片描述

    10.4 VERSIONS

    默认情况下一个列只能存储一个数据,后面如果修改数据就会将原来的覆盖掉,可以通过指定VERSIONS时HBase一列能存储多个值。

    create 'tbl_test', 'columnFamily1'
    describe 'tbl_test'
    
    # 修改列族版本号
    alter 'tbl_test', { NAME=>'columnFamily1', VERSIONS=>3 }
    
    put 'tbl_test', 'rowKey1', 'columnFamily1:column1', 'value1'
    put 'tbl_test', 'rowKey1', 'columnFamily1:column1', 'value2'
    put 'tbl_test', 'rowKey1', 'columnFamily1:column1', 'value3'
    
    # 默认返回最新的一条数据
    get 'tbl_test','rowKey1','columnFamily1:column1'
    
    # 返回3个
    get 'tbl_test','rowKey1',{COLUMN=>'columnFamily1:column1', VERSIONS=>3}
    # 返回2个
    get 'tbl_test','rowKey1',{COLUMN=>'columnFamily1:column1', VERSIONS=>2}
    

    在这里插入图片描述

    10.5 STARTROW

    ROWKEY起始行。会先根据这个key定位到region,再向后扫描

    # 语法
    scan '表名', { STARTROW => '行键名'}
    
    # 示例
    scan 'tbl_user', { STARTROW => 'vbirdbest'}
    

    在这里插入图片描述

    10.6 STOPROW :截止到STOPROW行,STOPROW行之前的数据,不包括STOPROW这行数据
    # 语法
    scan '表名', { STOPROW => '行键名'}
    
    # 示例
    scan 'tbl_user', { STOPROW => 'vbirdbest'}
    

    在这里插入图片描述

    10.7 LIMIT 返回的行数
    # 语法
    scan '表名', { LIMIT => 行数}
    
    # 示例
    scan 'tbl_user', { LIMIT => 2 }
    

    在这里插入图片描述

    11. FILTER条件过滤器

    过滤器之间可以使用AND、OR连接多个过滤器。

    ValueFilter 值过滤器
    # 语法:binary 等于某个值
    scan '表名', FILTER=>"ValueFilter(=,'binary:列值')"
    # 语法 substring:包含某个值
    scan '表名', FILTER=>"ValueFilter(=,'substring:列值')"
    
    # 示例
    scan 'tbl_user', FILTER=>"ValueFilter(=, 'binary:26')"
    scan 'tbl_user', FILTER=>"ValueFilter(=, 'substring:6')"
    

    在这里插入图片描述

    ColumnPrefixFilter 列名前缀过滤器
    # 语法 substring:包含某个值
    scan '表名', FILTER=>"ColumnPrefixFilter('列名前缀')"
    
    # 示例
    scan 'tbl_user', FILTER=>"ColumnPrefixFilter('birth')"
    # 通过括号、AND和OR的条件组合多个过滤器
    scan 'tbl_user', FILTER=>"ColumnPrefixFilter('birth') AND ValueFilter(=,'substring:26')"
    

    在这里插入图片描述

    rowKey字典排序

    Table中的所有行都是按照row key的字典排序的
    在这里插入图片描述

    三:HBase 常见错误

    hbase shell在使用的时候经常会报错,这里列举了几个错误:

    1. HBase创建不存在的表报已经存在错误 ERROR: Table already exists: !

    解决办法:

    # 1. 进入zookeeper client模式
    cd /usr/local/Cellar/hbase/1.2.9/bin
    hbase zkcli
    
    # 2. 在zk client模式下输入ls /hbase/table命令看到zombie table
    ls /hbase/table
    
    # 3. 删除表,TABLE_NAME为要删除的表名
    rmr /hbase/table/TABLE_NAME
    
    # 4. 重启hbase
    ./stop-hbase.sh
    ./start-hbase.sh
    
    2. ERROR: org.apache.hadoop.hbase.ipc.ServerNotRunningYetException: Server is not running yet
    # 使用jps查看是否有datanode服务
    jps
    
    删除hadoop 的临时目录
    /usr/local/Cellar/hadoop/3.1.1/libexec/tmp
    
    3. ERROR: Can’t get master address from ZooKeeper; znode data == null
    # 重启hbase
    ./stop-hbase.sh
    
    ./start-hbase.sh
    

    4. ERROR: org.apache.hadoop.hbase.PleaseHoldException: Master is initializing

    这个错误出现的原因很多,这里说一下我的错误原因是hbase-site.xml中的有个属性名配置错误, 网上有的是hbase.rootdir, name配置成这个有的时候会报错有的时候不会报错,报错的时候格式化一下hadoop然后再重新启动,这种方式有的时候能解决问题,有的时候解决不了。这里我将hbase.rootdir改为hbase.root.dir 就不报错了,不知道是不是版本不同属性名配置不同,我的hadoop版本为3.1.1,hbase版本为1.2.9

    <!-- 正确的配置的属性名应为hbase.root.dir而不是hbase.rootdir -->
    <property>
      <name>hbase.root.dir</name>
      <value>hdfs://localhost:8020/hbase</value>
    </property>
    

    相关文档

    HBase操作(Shell与Java API)https://blog.csdn.net/u013980127/article/details/52443155

    展开全文
  • 2016-04-05 08:53:06,331 WARN [main] zookeeper.ZKUtil: hconnection-0x1f6917fb0x0, quorum=salve1:2181,master:2181,salve2:2181, baseZNode=/hbase Unable to set watcher on znode (/hbase/hbaseid) ...
  • hbase笔记

    万次阅读 2020-09-08 09:39:16
    【1】HBase介绍 【2】单机部署 【3】伪分布式部署 【4】ubuntu16.04集群部署hbase 【1】HBase介绍 HBase(Hadoop Database)是一个高可靠性、高性能、面向列、可伸缩、 实时读写的分布式数据库,利用Hadoop HDFS作为其...
  • hbase我的是单机版的,不上集群,版本是1.2.6 使用Java代码对HBASE数据库进行查询期间没有报错,但就是不管为查询多少条数据都是花了20s 在 hbase-env.sh文件里面加了下面配置: export JAVA_HOME=/usr/local/jdk1.8...
  • HBase详解(很全面)

    万次阅读 多人点赞 2018-06-08 16:12:32
    【转自:http://jiajun.iteye.com/blog/899632】一、简介historystarted by chad walters and jim2006.11 G release paper on BigTable2007.2 inital HBase prototype created as Hadoop contrib2007.10 First ...
  • 我们可以利用 Hbase-shell 进行版本的查看 进入Hbase-shell 后可以看到 hbase版本 [root@cdh-manager ~]# hbase shell Java HotSpot(TM) 64-Bit Server VM warning: Using incremental CMS is deprecated and ...
  • HBase JDBC连接

    万次阅读 2018-10-17 09:26:02
    JDBC连接HBase 1.pom.xml中的依赖 <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>3.8.1</version...
  • 一篇文章让你了解Hive和HBase的区别

    万次阅读 多人点赞 2018-08-07 09:41:38
    相信做大数据开发的朋友对hive和HBase一定不会陌生。 HBASE 想了解更多大数据相关知识可以点击“了解更多” Hive是基于Hadoop的一个数据仓库工具,可以将结构化的数据文件映射为一张数据库表,并提供简单的sql...
  • HBase Java API: hbase-client

    千次阅读 2019-03-12 22:06:48
    hbase-client 是hbase的api 二:API package org.apache.hadoop.hbase.client; public class ConnectionFactory { /* * 创建连接 * @param conf hbase属性配置 */ public static Connection createConnection...
  • 万字HBase详解带你畅游大数据的海豚湾

    万次阅读 多人点赞 2020-05-20 17:18:25
    本文深入到HBase的起源开始分析,从0开始带你畅游大数据的海豚湾!让你轻松掌握HBase的原理,架构设计,存储设计,优点及适用场景。
  • 大数据HBase系列之HBase基本操作

    万次阅读 2018-11-01 18:04:52
    1. hbase命令 版本查看 hbase version 连接Zookeeper客户端 hbase zkcli 连接HBase客户端 hbase shell 2. CRUD 2.1 创建表 -- 语法:create '表名','列族名' create 'student','info' 2.2 显示所有表 ...
  • windows 下启动hbase报错

    2018-11-03 02:21:26
    D:\TSBrowserDownloads\db\hbase-2.1.0-bin\hbase-2.1.0\bin>start-hbase.cmd Exception in thread "main" java.lang.NoClassDefFoundError: org/apache/commons/logging/LogFactory at org.apache.hadoop.conf....
  • at org.apache.hadoop.hbase.client.HBaseAdmin.(HBaseAdmin.java:238) at com.atgui.TestHbase.tableExists(TestHbase.java:19) at com.atgui.TestHbase.main(TestHbase.java:42) Caused by: java.lang....
  • + exec /opt/cloudera/parcels/CDH-5.7.2-1.cdh5.7.2.p0.18/lib/hbase/../../bin/hbase --config /var/run/cloudera-scm-agent/process/469-hbase-REGIONSERVER regionserver start + znode_cleanup regionserver ++...
  • Review HBase

    千次阅读 2020-04-12 11:13:10
    hbase 的安装部署 1、软件包上传解压 2、 配置hbase.env.sh 配置java_home 使用外部zookeeper(自己独立安装的zookeeper) 3、配置 hbase-site.xml 见讲义 hbase.zookeeper.property.dataDir必须是zookeeper存储数据...
  • 使用最新的 hbase-client 2.1 操作 hbase

    千次阅读 2019-07-18 20:46:57
    文章目录概述引入依赖配置文件编写测试代码 概述 springboot 2.1 集成 hbase2.1 环境说明: hbase:2.1.5 springboot:2.1.1.RELEASE ...hbase环境:hbase 2.1 环境搭建–完全分布式模式 Advanced ...
  • hbase集群启动通过ssh启动会爆下面这个错 java.lang.RuntimeException: Failed construction of Regionserver: class org.apache.hadoop.hbase.regionserver.HRegionServer at org.apache.hadoop.hbase....
  • Hbase原理、基本概念、基本架构

    万次阅读 多人点赞 2013-12-26 16:36:37
    HBase是一个构建在HDFS上的分布式列存储系统; HBase是基于Google BigTable模型开发的,典型的key/value系统; HBase是Apache Hadoop生态系统中的重要一员,主要用于海量结构化数据存储; 从逻辑上讲,HBase将数据...
  • HBase 面试题

    万次阅读 2019-12-17 17:33:09
    文章目录HBase的基本介绍HBASE的适用场景Hbase和Hadoop之间的关系Hbase与RDBMS的关系Hbase特征简要说明hbase的基础架构HBase的底层原理HBase的表数据模型Row Key列族Column Family列 Column时间戳Cell存储数据的最小...
  • HBase:Sqoop整合HBase

    千次阅读 2019-12-20 08:40:53
    Sqoop整合HBase sqoop是一个数据导入导出的工具,可以将关系型数据库当中的数据导入到大数据平台来,也可以将大数据平台当中的数据导入到关系型数据库当中去 我们也可以通过sqoop导入数据到hbase或者从hbase当中导出...
  • Hbase的安装

    万次阅读 2019-12-13 20:25:36
    hbase 的安装部署 1、软件包上传解压 所有关于CDH版本的软件包下载地址如下 http://archive.cloudera.com/cdh5/cdh/5/ HBase对应的版本下载地址如下 ...

空空如也

1 2 3 4 5 ... 20
收藏数 81,377
精华内容 32,550
关键字:

hbase