HBase介绍

这篇具有很好参考价值的文章主要介绍了HBase介绍。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

第1章 HBase简介

1.1 HBase定义

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

1.2 HBase数据模型

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

1.2.1 HBase逻辑结构

hbase数据库,大数据

1.2.2 HBase物理存储结构

 hbase数据库,大数据

1.2.3 数据模型

1)Name Space

命名空间,类似于关系型数据库的database概念,每个命名空间下有多个表。HBase两个自带的命名空间,分别是hbase和default,hbase中存放的是HBase内置的表,default表是用户默认使用的命名空间。

2)Table

类似于关系型数据库的表概念。不同的是,HBase定义表时只需要声明列族即可,不需要声明具体的列。这意味着,往HBase写入数据时,字段可以动态按需指定。因此,和关系型数据库相比,HBase能够轻松应对字段变更的场景。

3)Row

HBase表中的每行数据都由一个RowKey和多个Column(列)组成,数据是按照RowKey的字典顺序存储的,并且查询数据时只能根据RowKey进行检索,所以RowKey的设计十分重要。

4)Column

HBase中的每个列都由Column Family(列族)Column Qualifier(列限定符)进行限定,例如info:name,info:age。建表时,只需指明列族,而列限定符无需预先定义。

5)Time Stamp

用于标识数据的不同版本(version),每条数据写入时,系统会自动为其加上该字段,其值为写入HBase的时间。

6)Cell

由{rowkey, column Family:column Qualifier, time Stamp} 唯一确定的单元。cell中的数据全部是字节码形式存贮。

 1.3 HBase基本架构hbase数据库,大数据

架构角色:

1)Region Server

Region Server为 Region的管理者,其实现类为HRegionServer,主要作用如下:

对于数据的操作:get, put, delete;

对于Region的操作:splitRegion、compactRegion。

2)Master

Master是所有Region Server的管理者,其实现类为HMaster,主要作用如下:

    对于表的操作:create, delete, alter

对于RegionServer的操作:分配regions到每个RegionServer,监控每个RegionServer的状态,负载均衡和故障转移。

3)Zookeeper

HBase通过Zookeeper来做master的高可用、RegionServer的监控、元数据的入口以及集群配置的维护等工作。

4)HDFS

HDFS为Hbase提供最终的底层数据存储服务,同时为HBase提供高容错的支持。

第2章 HBase进阶

2.1 RegionServer 架构

hbase数据库,大数据

1)StoreFile

保存实际数据的物理文件,StoreFile以Hfile的形式存储在HDFS上。每个Store会有一个或多个StoreFile(HFile),数据在每个StoreFile中都是有序的。

2)MemStore

写缓存,由于HFile中的数据要求是有序的,所以数据是先存储在MemStore中,排好序后,等到达刷写时机才会刷写到HFile,每次刷写都会形成一个新的HFile。

3)WAL

由于数据要经MemStore排序后才能刷写到HFile,但把数据保存在内存中会有很高的概率导致数据丢失,为了解决这个问题,数据会先写在一个叫做Write-Ahead logfile的文件中,然后再写入MemStore中。所以在系统出现故障的时候,数据可以通过这个日志文件重建。

4)BlockCache

读缓存,每次查询出的数据会缓存在BlockCache中,方便下次查询。

2.2 写流程

hbase数据库,大数据

写流程:

1)Client先访问zookeeper,获取hbase:meta表位于哪个Region Server。

2)访问对应的Region Server,获取hbase:meta表,根据写请求的namespace:table/rowkey,查询出目标数据位于哪个Region Server中的哪个Region中。并将该table的region信息以及meta表的位置信息缓存在客户端的meta cache,方便下次访问。

3)与目标Region Server进行通讯;

4)将数据顺序写入(追加)到WAL;

5)将数据写入对应的MemStore,数据会在MemStore进行排序;

6)向客户端发送ack;

7)等达到MemStore的刷写时机后,将数据刷写到HFile。

2.3 MemStore Flush

hbase数据库,大数据

MemStore刷写时机:

1.当某个memstroe的大小达到了hbase.hregion.memstore.flush.size(默认值128M,其所在region的所有memstore 都会刷写。

当memstore的大小达到了

hbase.hregion.memstore.flush.size(默认值128M

* hbase.hregion.memstore.block.multiplier(默认值4

时,会阻止继续往该memstore写数据。

2.当region server中memstore的总大小达到

java_heapsize

*hbase.regionserver.global.memstore.size(默认值0.4

*hbase.regionserver.global.memstore.size.lower.limit(默认值0.95

region会按照其所有memstore的大小顺序(由大到小)依次进行刷写。直到region server中所有memstore的总大小减小到上述值以下。

当region server中memstore的总大小达到

java_heapsize

*hbase.regionserver.global.memstore.size(默认值0.4

时,会阻止继续往所有的memstore写数据。

3. 到达自动刷写的时间,也会触发memstore flush。自动刷新的时间间隔由该属性进行配置hbase.regionserver.optionalcacheflushinterval(默认1小时)

4.当WAL文件的数量超过hbase.regionserver.max.logs,region会按照时间顺序依次进行刷写,直到WAL文件数量减小到hbase.regionserver.max.log以下(该属性名已经废弃,现无需手动设置,最大值为32)。

2.4 读流程

1)整体流程

hbase数据库,大数据

 2)Merge细节

hbase数据库,大数据

读流程

1)Client先访问zookeeper,获取hbase:meta表位于哪个Region Server。

2)访问对应的Region Server,获取hbase:meta表,根据读请求的namespace:table/rowkey,查询出目标数据位于哪个Region Server中的哪个Region中。并将该table的region信息以及meta表的位置信息缓存在客户端的meta cache,方便下次访问。

3)与目标Region Server进行通讯;

4)分别在MemStore和Store File(HFile)中查询目标数据,并将查到的所有数据进行合并。此处所有数据是指同一条数据的不同版本(time stamp)或者不同的类型(Put/Delete)。

5)将查询到的新的数据块(Block,HFile数据存储单元,默认大小为64KB)缓存到Block Cache。

6)将合并后的最终结果返回给客户端。

2.5 StoreFile Compaction

由于memstore每次刷写都会生成一个新的HFile,且同一个字段的不同版本(timestamp)和不同类型(Put/Delete)有可能会分布在不同的HFile中,因此查询时需要遍历所有的HFile。为了减少HFile的个数,以及清理掉过期和删除的数据,会进行StoreFile Compaction。

Compaction分为两种,分别是Minor CompactionMajor Compaction。Minor Compaction会将临近的若干个较小的HFile合并成一个较大的HFile,并清理掉部分过期和删除的数据。Major Compaction会将一个Store下的所有的HFile合并成一个大HFile,并且清理掉所有过期和删除的数据

hbase数据库,大数据

2.6 Region Split

默认情况下,每个Table起初只有一个Region,随着数据的不断写入,Region会自动进行拆分。刚拆分时,两个子Region都位于当前的Region Server,但处于负载均衡的考虑,HMaster有可能会将某个Region转移给其他的Region Server。

Region Split时机:

1.当1个region中的某个Store下所有StoreFile的总大小超过hbase.hregion.max.filesize 10G,该Region就会进行拆分(0.94版本之前)。

2.当1个region中的某个Store下所有StoreFile的总大小超过Min(initialSize*R^3 ,hbase.hregion.max.filesize"),该Region就会进行拆分。其中initialSize的默认值为2*hbase.hregion.memstore.flush.size,R为当前Region Server中属于该Table的Region个数(0.94版本之后)。

具体的切分策略为:

第一次split:1^3 * 256 = 256MB

第二次split:2^3 * 256 = 2048MB

第三次split:3^3 * 256 = 6912MB

第四次split:4^3 * 256 = 16384MB > 10GB,因此取较小的值10GB

后面每次split的size都是10GB了。

3.Hbase 2.0引入了新的split策略:如果当前RegionServer上该表只有一个Region,按照2 * hbase.hregion.memstore.flush.size分裂,否则按照hbase.hregion.max.filesize分裂。

hbase数据库,大数据

第3章 HBase Shell操作

3.1 基本操作

1.进入HBase客户端命令行

[atguigu@hadoop102 hbase]$ bin/hbase shell

2.查看帮助命令

hbase(main):001:0> help

3.查看当前数据库中有哪些表

hbase(main):002:0> list

3.2表的操作

1.创建表

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

2.插入数据到表

hbase(main):003:0> put 'student','1001','info:sex','male'

hbase(main):004:0> put 'student','1001','info:age','18'

hbase(main):005:0> put 'student','1002','info:name','Janna'

hbase(main):006:0> put 'student','1002','info:sex','female'

hbase(main):007:0> put 'student','1002','info:age','20'

3.扫描查看表数据

hbase(main):008:0> scan 'student'

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

hbase(main):010:0> scan 'student',{STARTROW => '1001'}

4.查看表结构

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

5.更新指定字段的数据

hbase(main):012:0> put 'student','1001','info:name','Zhangsan'

hbase(main):013:0> put 'student','1001','info:age','100'

6.查看“指定行”或“指定列族:列”的数据

hbase(main):014:0> get 'student','1001'

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

7.统计表数据行数

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

8.删除数据

删除某rowkey的全部数据:

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

删除某rowkey的某一列数据:

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

9.清空表数据

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

提示:清空表的操作顺序为先disable,然后再truncate。

10.删除表

首先需要先让该表为disable状态:

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

然后才能drop这个表:

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

提示:如果直接drop表,会报错:ERROR: Table student is enabled. Disable it first.

11.变更表信息

将info列族中的数据存放3个版本:

hbase(main):022:0> alter 'student',{NAME=>'info',VERSIONS=>3}

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

第4章 HBase API

4.1 环境准备

新建项目后在pom.xml中添加依赖:

注意:可能会报错javax.el包不存在,不用管,是一个测试用的依赖,不影响使用

<dependencies>

    <dependency>

        <groupId>org.apache.hbase</groupId>

        <artifactId>hbase-server</artifactId>

        <version>2.0.5</version>

        <exclusions>

            <exclusion>

                <groupId>org.glassfish</groupId>

                <artifactId>javax.el</artifactId>

            </exclusion>

        </exclusions>

    </dependency>

    <dependency>

        <groupId>org.apache.hbase</groupId>

        <artifactId>hbase-client</artifactId>

        <version>2.0.5</version>

    </dependency>

    <dependency>

        <groupId>org.glassfish</groupId>

        <artifactId>javax.el</artifactId>

        <version>3.0.1-b06</version>

    </dependency>

</dependencies>

4.2 创建连接

4.2.1 单线程使用

基本的连接方法

package com.atguigu.hbase;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.hbase.HBaseConfiguration;

import org.apache.hadoop.hbase.client.Connection;

import org.apache.hadoop.hbase.client.ConnectionFactory;

import java.io.IOException;

/**

 * @author yhm

 * @create 2021-02-01 16:29

 */

public class HBaseConnect {

    public static void main(String[] args) throws IOException {

        // 1.获取配置类

        Configuration conf = HBaseConfiguration.create();

        // 2.给配置类添加配置

        conf.set("hbase.zookeeper.quorum","hadoop102,hadoop103,hadoop104");

        // 3.获取连接

        Connection connection = ConnectionFactory.createConnection(conf);

        // 打印连接

        System.out.println(connection);

        // 4.关闭连接

        connection.close();

    }

}

4.2.2 多线程单例使用

package com.atguigu.hbase;

import org.apache.hadoop.conf.Configuration;

/**

 * @author yhm

 * @create 2021-12-07 10:08

 */

public class HbaseDML {

    // 设置静态属性hbase连接

    public static Connection connection = null;

    static {

        // 1. 创建配置对象

        Configuration conf = new Configuration();

        // 2. 添加配置参数

        conf.set("hbase.zookeeper.quorum", "hadoop102,hadoop103,hadoop104");

        // 3. 创建hbase的连接

        try {

            connection = ConnectionFactory.createConnection(conf);

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

    public static void closeConnection() throws IOException {

        if (connection != null) {

            connection.close();

        }

    }

}

4.3 使用连接

4.3.1 插入数据

    /**

     * putCell数据

     * @param nameSpace

     * @param tableName

     * @param rowKey

     * @param family

     * @param column

     * @param value

     * @throws IOException

     */

    public static void putCell(String nameSpace,String tableName,String rowKey,String family,String column,String value) throws IOException {

        // 1.获取table

        Table table = connection.getTable(TableName.valueOf(nameSpace, tableName));

        // 2.创建Put对象

        Put put = new Put(Bytes.toBytes(rowKey));

        // 3.添加put属性

        put.addColumn(Bytes.toBytes(family),Bytes.toBytes(column),Bytes.toBytes(value));

        // 4.put数据

        table.put(put);

        // 5.关闭资源

        table.close();

}

    public static void main(String[] args) throws IOException {

     putCell("bigdata","student","1001","info","name","zhangsan");

    }

4.3.2 查询数据

    /**

     * getCell数据

     * @param nameSpace

     * @param tableName

     * @param rowKey

     * @param family

     * @param column

     * @return

     * @throws IOException

     */

    public static String getCells(String nameSpace,String tableName,String rowKey,String family,String column) throws IOException {

        // 1.获取table

        Table table = connection.getTable(TableName.valueOf(nameSpace, tableName));

        // 2.获取Get对象

        Get get = new Get(Bytes.toBytes(rowKey));

        // 3.添加get属性

        get.addColumn(Bytes.toBytes(family),Bytes.toBytes(column));

        // 4.get数据

        // 简便用法

//        byte[] bytes = table.get(get).value();

//        String value = new String(bytes);

        // 复杂用法

        // 4.1 获取result

        Result result = table.get(get);

        // 4.2 获取cells

        Cell[] cells = result.rawCells();

        // 4.3 遍历cells

        String value = "";

        for (Cell cell : cells) {

            // 4.4 输出每个cell

            value += Bytes.toString(CellUtil.cloneValue(cell)) + "-";

        }

        // 5.关闭资源

        table.close();

        return value;

}

    public static void main(String[] args) throws IOException {

//        putCell("bigdata","student","1001","info","name","zhangsan");

        String cell = getCell("bigdata", "student", "1001", "info", "name");

        System.out.println(cell);

    }

4.3.3 扫描数据

    /**

     * 扫描数据

     * @param nameSpace

     * @param tableName

     * @param startRow

     * @param stopRow

     * @return

     * @throws IOException

     */

    public static List<String> scanRows(String nameSpace, String tableName, String startRow, String stopRow) throws IOException {

        // 1.获取table

        Table table = connection.getTable(TableName.valueOf(nameSpace, tableName));

        // 2.创建Scan对象

        Scan scan = new Scan().withStartRow(Bytes.toBytes(startRow)).withStopRow(Bytes.toBytes(stopRow));

        // 3.扫描数据

        ResultScanner scanner = table.getScanner(scan);

        // 4.获取结果

        ArrayList<String> arrayList = new ArrayList<>();

        for (Result result : scanner) {

            arrayList.add(Bytes.toString(result.value()));

        }

        // 5.关闭资源

        scanner.close();

        table.close();

        return arrayList;

}

    public static void main(String[] args) throws IOException {

//        putCell("bigdata","student","1002","info","name","lisi");

//        String cell = getCell("bigdata", "student", "1001", "info", "name");

//        System.out.println(cell);

        List<String> strings = scanRows("bigdata", "student", "1001", "2000");

        for (String string : strings) {

            System.out.println(string);

        }

    }

4.3.4 删除数据

    /**

     * 删除column数据

     *

     * @param nameSpace

     * @param tableName

     * @param rowKey

     * @param family

     * @param column

     * @throws IOException

     */

    public static void deleteColumn(String nameSpace, String tableName, String rowKey, String family, String column) throws IOException {

        // 1.获取table

        Table table = connection.getTable(TableName.valueOf(nameSpace, tableName));

        // 2.创建Delete对象

        Delete delete = new Delete(Bytes.toBytes(rowKey));

        // 3.添加删除信息

        // 3.1 删除单个版本

//        delete.addColumn(Bytes.toBytes(family),Bytes.toBytes(column));

        // 3.2 删除所有版本

        delete.addColumns(Bytes.toBytes(family), Bytes.toBytes(column));

        // 3.3 删除列族

//        delete.addFamily(Bytes.toBytes(family));

        // 4.删除数据

        table.delete(delete);

        // 5.关闭资源

        table.close();

}

    public static void main(String[] args) throws IOException {

//        putCell("bigdata","student","1002","info","name","lisi");

//        String cell = getCell("bigdata", "student", "1001", "info", "name");

//        System.out.println(cell);

//        List<String> strings = scanRows("bigdata", "student", "1001", "2000");

//        for (String string : strings) {

//            System.out.println(string);

        deleteColumn("bigdata", "student", "1001", "info", "name");

    }

第5章 HBase使用设计

5.1 预分区

每一个region维护着startRow与endRowKey,如果加入的数据符合某个region维护的rowKey范围,则该数据交给这个region维护。那么依照这个原则,我们可以将数据所要投放的分区提前大致的规划好,以提高HBase性能。

1.手动设定预分区

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

2.生成16进制序列预分区

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

3.按照文件中设置的规则预分区

创建splits.txt文件内容如下:

aaaa

bbbb

cccc

dddd

然后执行:

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

5.2 RowKey设计

一条数据的唯一标识就是rowkey,那么这条数据存储于哪个分区,取决于rowkey处于哪个一个预分区的区间内,设计rowkey的主要目的 ,就是让数据均匀的分布于所有的region中,在一定程度上防止数据倾斜。接下来我们就谈一谈rowkey常用的设计方案。

1.生成随机数、hash、散列值

2.字符串反转

3.字符串拼接

需求:使用hbase存储下列数据,要求能够通过hbase的API读取数据完成两个统计需求,(1)统计张三在2021年12月份消费的总金额

(2)统计所有人在2021年12月份消费的总金额

5.2.1 实现需求1

为了能够统计张三在2021年12月份消费的总金额,我们需要用scan命令能够得到张三在这个月消费的所有记录,之后在进行累加即可。Scan需要填写startRow和stopRow:

scan :  startRow ->   zhangsan_2021-12 

         endRow   ->  zhangsan_2021-12. 

注意点

(1)姓名和日期的字段直接需要有分隔符,分隔符规则按照阿斯卡码进行,需要避免扫描到用户zhangsanfeng的数据

(2)最后的日期结尾处需要使用阿斯卡码略大于’-’的值

最终得到rowKey的设计为:

//注意rowkey相同的数据会视为相同数据覆盖掉之前的版本

rowKey:  user_date()

5.2.2 实现需求2

问题提出:按照需要1的rowKey设计,会发现对于需求2,完全没有办法写rowKey的扫描范围。此处能够看出hbase设计rowKey使用的特点为:

适用性强  泛用性差  能够完美实现一个需求  但是不能同时实现多个需要。

如果想要同时完成两个需求,需要对rowKey出现字段的顺序进行调整。

调整的原则为:可枚举的放在前面。其中时间是可以枚举的,用户名称无法枚举,所以必须把时间放在前面。

//设计如下

rowKey:  date(yyyy-MM)_user_date(-dd HH:mm:SS)

实现需求1

scan :  startRow ->  2021-12_zhangsan

        endRow   ->   2021-12_zhangsan.

实现需求2

scan : startRow ->  2021-12

       endRow  ->   2021-12.

5.2.3 添加预分区优化

预分区的分区号同样需要遵守rowKey的scan原则。所以必须添加在rowKey的最前面,前缀为最简单的数字。同时使用hash算法将用户名和月份拼接决定分区号。(单独使用用户名会造成单一用户所有数据存储在一个分区)

000.

001.

002.

...

119.

//此时rowKey设计

rowKey:  分区号(hash[user-月份]%120)_date(yyyy-MM)_user_date(-dd HH:mm:SS)

缺点:实现需求2的时候,由于每个分区都有12月份的数据,需要扫描120个分区。

解决方法:提前将分区号和月份进行对应

000. – 009. 号分区存储1月份数据

...

110. – 119. 号分区存储12月份数据

rowKey情况分区号(hash[user]%10 + 月份对应的分区开始值)_date(yyyy-MM)_user_date(-dd HH:mm:SS)

完成需求2:

scan : startRow ->  110_2021-12

       endRow  ->   110_2021-12.

       ... 扫描10

       startRow ->  119_2021-12

       endRow  ->   119_2021-12.

5.3 内存优化

HBase操作过程中需要大量的内存开销,毕竟Table是可以缓存在内存中的,但是不建议分配非常大的堆内存,因为GC过程持续太久会导致RegionServer处于长期不可用状态,一般16~36G内存就可以了,如果因为框架占用内存过高导致系统内存不足,框架一样会被系统服务拖死。

5.4 基础优化

1.Zookeeper会话超时时间

hbase-site.xml

属性:zookeeper.session.timeout

解释:默认值为90000毫秒(90s)。当某个RegionServer挂掉,90s之后Master才能察觉到。可适当减小此值,以加快Master响应,可调整至60000毫秒。

2.设置RPC监听数量

hbase-site.xml

属性:hbase.regionserver.handler.count

解释:默认值为30,用于指定RPC监听的数量,可以根据客户端的请求数进行调整,读写请求较多时,增加此值。

3.手动控制Major Compaction

hbase-site.xml

属性:hbase.hregion.majorcompaction

解释:默认值:604800000秒(7天), Major Compaction的周期,若关闭自动Major Compaction,可将其设为0

4.优化HStore文件大小

hbase-site.xml

属性:hbase.hregion.max.filesize

解释:默认值1073741824010GB),如果需要运行HBaseMR任务,可以减小此值,因为一个region对应一个map任务,如果单个region过大,会导致map任务执行时间过长。该值的意思就是,如果HFile的大小达到这个数值,则这个region会被切分为两个Hfile

5.优化HBase客户端缓存

hbase-site.xml

属性:hbase.client.write.buffer

解释:默认值2097152bytes2M)用于指定HBase客户端缓存,增大该值可以减少RPC调用次数,但是会消耗更多内存,反之则反之。一般我们需要设定一定的缓存大小,以达到减少RPC次数的目的。

6.指定scan.next扫描HBase所获取的行数

hbase-site.xml

属性:hbase.client.scanner.caching

解释:用于指定scan.next方法获取的默认行数,值越大,消耗内存越大。

7.BlockCache占用RegionServer堆内存的比例

hbase-site.xml

属性:hfile.block.cache.size

解释:默认0.4,读请求比较多的情况下,可适当调大

8.MemStore占用RegionServer堆内存的比例

hbase-site.xml

属性:hbase.regionserver.global.memstore.size

解释:默认0.4,写请求较多的情况下,可适当调大

第6章 整合Phoenix

6.1 Phoenix简介

6.1.1 Phoenix定义

Phoenix是HBase的开源SQL皮肤。可以使用标准JDBC API代替HBase客户端API来创建表,插入数据和查询HBase数据。

优点:使用简单,直接能写sql

缺点:效率没有自己设计rowKey再使用API高,性能较差。

6.1.2 Phoenix架构

hbase数据库,大数据

 

6.2 Phoenix快速入门

6.2.1 安装

1.官网地址

Overview | Apache Phoenix

2.Phoenix部署

1)上传并解压tar包

[atguigu@hadoop102 module]$ tar -zxvf apache-phoenix-5.0.0-HBase-2.0-bin.tar.gz -C /opt/module/

[atguigu@hadoop102 module]$ mv apache-phoenix-5.0.0-HBase-2.0-bin phoenix

2)复制server包并拷贝到各个节点的hbase/lib

[atguigu@hadoop102 module]$ cd /opt/module/phoenix/

[atguigu@hadoop102 phoenix]$ cp /opt/module/phoenix/phoenix-5.0.0-HBase-2.0-server.jar /opt/module/hbase/lib/

[atguigu@hadoop102 phoenix]$ xsync /opt/module/hbase/lib/phoenix-5.0.0-HBase-2.0-server.jar

3)配置环境变量

#phoenix

export PHOENIX_HOME=/opt/module/phoenix

export PHOENIX_CLASSPATH=$PHOENIX_HOME

export PATH=$PATH:$PHOENIX_HOME/bin

4)重启HBase

[atguigu@hadoop102 ~]$ stop-hbase.sh

[atguigu@hadoop102 ~]$ start-hbase.sh

5) 连接Phoenix

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

6.2.2 Phoenix Shell操作

1)显示所有表

!table !tables

2)创建表

直接指定单个列作为RowKey

CREATE TABLE IF NOT EXISTS student(

id VARCHAR primary key,

name VARCHAR,

addr VARCHAR);

phoenix中,表名等会自动转换为大写,若要小写,使用双引号,如"us_population"

指定多个列的联合作为RowKey

CREATE TABLE IF NOT EXISTS us_population (

State CHAR(2) NOT NULL,

City VARCHAR NOT NULL,

Population BIGINT

CONSTRAINT my_pk PRIMARY KEY (state, city));

注:Phoenix中建表,会在HBase中创建一张对应的表。为了减少数据对磁盘空间的占用,Phoenix默认会对HBase中的列名做编码处理。具体规则可参考官网链接:Storage Formats | Apache Phoenix,若不想对列名编码,可在建表语句末尾加上COLUMN_ENCODED_BYTES = 0;

3)插入数据

upsert into student values('1001','zhangsan','beijing');

4)查询记录

select * from student;

select * from student where id='1001';

5)删除记录

delete from student where id='1001';

6)删除表

drop table student;

7)退出命令行

!quit

6.2.3 Phoenix JDBC操作

1.胖客户端

1)maven依赖

<dependencies>

    <dependency>
        <groupId>org.apache.phoenix</groupId>
        <artifactId>phoenix-core</artifactId>
        <version>5.0.0-HBase-2.0</version>
        <exclusions>
            <exclusion>
                <groupId>org.glassfish</groupId>
                <artifactId>javax.el</artifactId>
            </exclusion>
            <exclusion>
                <groupId>org.apache.hadoop</groupId>
                <artifactId>hadoop-common</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.glassfish</groupId>
        <artifactId>javax.el</artifactId>
        <version>3.0.1-b06</version>
    </dependency>
    <dependency>
        <groupId>org.apache.hadoop</groupId>
        <artifactId>hadoop-common</artifactId>
        <version>2.8.4</version>
    </dependency>
</dependencies>

2)编写代码

import java.sql.*;

import java.util.Properties;

/**

 * @author yhm

 * @create 2021-02-03 19:52

 */

public class TestThickClient {

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

        // 1.添加链接

        String url = "jdbc:phoenix:hadoop102,hadoop103,hadoop104:2181";

        // 2.获取连接

        Connection connection = DriverManager.getConnection(url);

        // 3.编译SQL语句

        PreparedStatement preparedStatement = connection.prepareStatement("select * from student");

        // 4.执行语句

        ResultSet resultSet = preparedStatement.executeQuery();

        // 5.输出结果

        while (resultSet.next()){

            System.out.println(resultSet.getString(1) + ":" + resultSet.getString(2) + ":" + resultSet.getString(3));

        }

        // 6.关闭资源

        connection.close();

    }
}

2.瘦客户端

1)启动query server

[atguigu@hadoop102 ~]$ queryserver.py start

[atguigu@hadoop102 ~]$ sqlline-thin.py hadoop102

2)maven依赖

    <dependencies>

        <!-- https://mvnrepository.com/artifact/org.apache.phoenix/phoenix-queryserver-client -->

        <dependency>

            <groupId>org.apache.phoenix</groupId>

            <artifactId>phoenix-queryserver-client</artifactId>

            <version>5.0.0-HBase-2.0</version>

        </dependency>

    </dependencies>

3)编写代码

import org.apache.phoenix.queryserver.client.ThinClientUtil;

import java.sql.*;

/**

 * @author yhm

 * @create 2021-02-03 20:16

 */

public class TestThinClient {

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

        // 1. 直接从瘦客户端获取链接

        String hadoop102 = ThinClientUtil.getConnectionUrl("hadoop102", 8765);

        // 2. 获取连接

        Connection connection = DriverManager.getConnection(hadoop102);

        // 3.编译SQL语句

        PreparedStatement preparedStatement = connection.prepareStatement("select * from student");

        // 4.执行语句

        ResultSet resultSet = preparedStatement.executeQuery();

        // 5.输出结果

        while (resultSet.next()){

            System.out.println(resultSet.getString(1) + ":" + resultSet.getString(2) + ":" + resultSet.getString(3));

        }

        // 6.关闭资源

        connection.close();

    }

}

6.3 Phoenix二级索引

6.3.1 二级索引配置文件

添加如下配置到HBase的HRegionserver节点的hbase-site.xml

    <!-- phoenix regionserver 配置参数-->

    <property>

        <name>hbase.regionserver.wal.codec</name>

        <value>org.apache.hadoop.hbase.regionserver.wal.IndexedWALEditCodec</value>

    </property>

6.3.2 全局索引(global index)

Global Index是默认的索引格式,创建全局索引时,会在HBase中建立一张新表。也就是说索引数据和数据表是存放在不同的表中的,因此全局索引适用于多读少写的业务场景。

写数据的时候会消耗大量开销,因为索引表也要更新,而索引表是分布在不同的数据节点上的,跨节点的数据传输带来了较大的性能消耗。

在读数据的时候Phoenix会选择索引表来降低查询消耗的时间。

创建单个字段的全局索引

CREATE INDEX my_index ON my_table (my_col);

如果想查询的字段不是索引字段的话索引表不会被使用,也就是说不会带来查询速度的提升。

若想解决上述问题,可采用如下方案:

1)使用包含索引

2)使用本地索引

6.3.3 包含索引(covered index)

创建携带其他字段的全局索引

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

6.3.3 本地索引(local index)

Local Index适用于写操作频繁的场景。

索引数据和数据表的数据是存放在同一张表中(且是同一个Region),避免了在写操作的时候往不同服务器的索引表中写索引带来的额外开销。

CREATE LOCAL INDEX my_index ON my_table (my_column);文章来源地址https://www.toymoban.com/news/detail-579534.html

到了这里,关于HBase介绍的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 使用IDEA连接hbase数据库

     Hbase是安装在另一台LINUX服务器上的,需要本地通过JAVA连接HBase数据库进行操作。由于是第一次接触HBase,过程当中百度了很多资料,也遇到了很多的问题。耗费了不少时间才成功连接上。特记录下过程当中遇到的问题。 JAVA连接HBase代码如下: 首先通过POM将需要的JAR包导入。

    2024年02月03日
    浏览(93)
  • HBase的数据库与HadoopEcosyste

    HBase是一个分布式、可扩展、高性能、高可用性的列式存储系统,基于Google的Bigtable设计。HBase是Hadoop生态系统的一个重要组成部分,与Hadoop HDFS、MapReduce、ZooKeeper等产品密切相关。本文将从以下几个方面进行深入探讨: 背景介绍 核心概念与联系 核心算法原理和具体操作步骤

    2024年02月20日
    浏览(45)
  • 大数据NoSQL数据库HBase集群部署

    目录 1.  简介 2.  安装 1. HBase依赖Zookeeper、JDK、Hadoop(HDFS),请确保已经完成前面 2. 【node1执行】下载HBase安装包 3. 【node1执行】,修改配置文件,修改conf/hbase-env.sh文件 4. 【node1执行】,修改配置文件,修改conf/hbase-site.xml文件 5. 【node1执行】,修改配置文件,修改conf/regi

    2024年02月08日
    浏览(54)
  • HBase的数据库容量规划与优化

    HBase的数据库容量规划与优化 HBase是一个分布式、可扩展、高性能的列式存储系统,基于Google的Bigtable设计。它是Hadoop生态系统的一部分,可以与HDFS、MapReduce、ZooKeeper等组件集成。HBase适用于大规模数据存储和实时数据访问场景,如日志处理、实时统计、搜索引擎等。 在实际

    2024年02月20日
    浏览(45)
  • HBase的数据库备份与恢复策略

    HBase是一个分布式、可扩展、高性能的列式存储系统,基于Google的Bigtable设计。它是Hadoop生态系统的一部分,可以与HDFS、MapReduce、ZooKeeper等组件集成。HBase具有高可用性、高可扩展性和高性能等优势,适用于大规模数据存储和实时数据处理。 在实际应用中,数据备份和恢复是

    2024年02月19日
    浏览(61)
  • HBase的数据库安全与权限管理

    HBase是一个分布式、可扩展、高性能的列式存储系统,基于Google的Bigtable设计。它是Hadoop生态系统的一部分,可以与HDFS、MapReduce、ZooKeeper等组件集成。HBase具有高可靠性、高性能和高可扩展性等特点,适用于大规模数据存储和实时数据处理。 在现代企业中,数据安全和权限管

    2024年02月20日
    浏览(45)
  • 大数据NoSQL数据库HBase集群部署——详细讲解~

    HBase 是一种分布式、可扩展、支持海量数据存储的 NoSQL 数据库。 和Redis一样,HBase是一款KeyValue型存储的数据库。 不过和Redis设计方向不同 Redis设计为少量数据,超快检索 HBase设计为海量数据,快速检索 HBase在大数据领域应用十分广泛,现在我们来在node1、node2、node3上部署H

    2024年02月11日
    浏览(48)
  • HBase的数据库设计模式与实践

    HBase是一个分布式、可扩展、高性能的列式存储系统,基于Google的Bigtable设计。它是Hadoop生态系统的一部分,可以与HDFS、MapReduce、ZooKeeper等组件集成。HBase适用于大规模数据存储和实时数据访问的场景,如日志记录、实时数据分析、实时搜索等。 在现实应用中,HBase的数据库设

    2024年02月20日
    浏览(44)
  • 客户端读写HBase数据库的运行原理

    1.HBase的特点 HBase是一个数据库,与RDMS相比,有以下特点: ① 它不支持SQL ② 不支持事务 ③ 没有表关系,不支持JOIN ④ 有列族,列族下可以有上百个列 ⑤ 单元格,即列值,可以存储多个版本的值,每个版本都有对应时间戳 ⑥ 行键按照字典序升序排列 ⑦ 元数据 和 数据 分

    2024年02月10日
    浏览(57)
  • 分布式数据库HBase,它到底是怎么组成的?

    原文链接:http://www.ibearzmblog.com/#/technology/info?id=8ac4902f82f525e1456624d5d7a545dc 大数据的核心问题无非就是存储和计算这两个。Hadoop中的HDFS解决了数据存储的问题,而HBase就是在HDFS上构建,因此Hbase既能解决大数据存储的问题,又能解决数据实时查询的问题。 HBase是一个高可靠、高

    2024年02月16日
    浏览(38)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包