【十八掌●武功篇】第八掌：HBase之基本操作Java API

最新推荐文章于 2020-07-22 00:49:54 发布
最新推荐文章于 2020-07-22 00:49:54 发布
阅读量523 收藏 1
点赞数
分类专栏： 大数据技术 文章标签： hbase 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chybin500/article/details/78673435
版权

这一篇博文是【大数据技术●降龙十八掌】系列文章的其中一篇，点击查看目录：这里写图片描述大数据技术●降龙十八掌

系列文章：
:【十八掌●武功篇】第八掌：HBase之基本概念
【十八掌●武功篇】第八掌：HBase之Shell
【十八掌●武功篇】第八掌：HBase之基本操作Java API
【十八掌●武功篇】第八掌：HBase之过滤器总结
【十八掌●武功篇】第八掌：HBase之性能调优
【十八掌●武功篇】第八掌：HBase之安装与集成 [草稿]

第一部分： HBase 基本读写API

一、 写入数据
1、 单行Put

HBase Java API使用Put对象封装一行数据，包括rowkey、列族信息、列标签信息、单元格版本信息、单元格值。然后使用Put对象对Table中的数据进行写入，包括插入和更新操作。
Put对象插入和更新HBase数据适合小数据量的写操作。


private static void test1() {
    Configuration conf = HBaseConfiguration.create();
    Connection connection = null;
    Table table = null;
    try {
        connection = ConnectionFactory.createConnection(conf);
        table = connection.getTable(TableName.valueOf("DLR:ft_fact_data_month_quarter"));
        //实例化一个Put对象，指定Rowkey
        Put put = new Put(Bytes.toBytes("100003_00201612_500000"));
        //向Put对象里添加一列，列族为cf,列标签为factory_id,值为100003，版本默认为当前时间戳
        put.addColumn(Bytes.toBytes("cf"), Bytes.toBytes("factory_id"),Bytes.toBytes("100003"));
        //向Put对象里添加一列，列族为cf,列标签为log_date,值为00201612
        put.addColumn(Bytes.toBytes("cf"), Bytes.toBytes("log_date"),Bytes.toBytes("00201612"));
        //将put对象添加进table
        table.put(put);
    } catch (IOException e) {
        e.printStackTrace();
    }
    finally {
        try {
            if (table != null) {
                table.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
2、 Put列表

Table表的put方法可以传入一个List。
当列表中的多个Put有部分出错时，不会影响其他Put的写入操作。

private static void test3() {
    Configuration conf = HBaseConfiguration.create();
    Connection connection = null;
    Table table = null;
    try {
        connection = ConnectionFactory.createConnection(conf);
        table = connection.getTable(TableName.valueOf("DLR:ft_fact_data_month_quarter"));
        List<Put> list = new ArrayList<>();
        //实例化一个Put对象，指定Rowkey
        Put put = new Put(Bytes.toBytes("100003_00201612_500000"));
        //向Put对象里添加一列，列族为cf,列标签为factory_id,值为100003,版本默认为当前时间戳
        put.addColumn(Bytes.toBytes("cf"), Bytes.toBytes("factory_id"), Bytes.toBytes("100008"));
        list.add(put);

        Put put2 = new Put(Bytes.toBytes("100004_00201612_500000"));
        //向Put对象里添加一列，列族为cf,列标签为factory_id,值为100003,版本默认为当前时间戳
        put2.addColumn(Bytes.toBytes("cf"), Bytes.toBytes("factory_id"), Bytes.toBytes("100009"));
        list.add(put2);

        table.put(list);
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if (table != null) {
                table.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
3、 写缓冲区

每一个table的put操作都是一个客户端和HBase服务器的RPC通信操作，高频率的写入操作时会产生大量的网络数据传输次数，效率比较低。
解决这个问题的一种方法是使用BufferedMutator对象，使用缓冲区，缓冲区负责收集put操作，然后调用RPC操作一次性地put到HBase服务器上。当缓冲区里的数据量到达一定的阀值时或者在调用BufferedMutator的close()方法时，客户端能自动提交更新到HBase服务器。

private static void test2() {
    Configuration conf = HBaseConfiguration.create();
    Connection connection = null;
    BufferedMutator t = null;
    try {
        connection = ConnectionFactory.createConnection(conf);
        t = connection.getBufferedMutator(TableName.valueOf("DLR:ft_fact_data_month_quarter"));

        Put put = null;
        //实例化一个Put对象，指定Rowkey,将put对象添加进table
        put = new Put(Bytes.toBytes("100004_00201612_500000"));
        put.addColumn(Bytes.toBytes("cf"), Bytes.toBytes("factory_id"), Bytes.toBytes("100004"));
        t.mutate(put);

        //实例化一个Put对象，指定Rowkey,将put对象添加进table
        put = new Put(Bytes.toBytes("100005_00201612_500000"));
        put.addColumn(Bytes.toBytes("cf"), Bytes.toBytes("factory_id"), Bytes.toBytes("100005"));
        t.mutate(put);

        //实例化一个Put对象，指定Rowkey,将put对象添加进table
        put = new Put(Bytes.toBytes("100006_00201612_500000"));
        put.addColumn(Bytes.toBytes("cf"), Bytes.toBytes("factory_id"), Bytes.toBytes("100006"));

        t.mutate(put);
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if (t != null) {
                t.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
4、 原子性Put

原子性Put可以保证Put操作本身是原子性的，它是通过在更新之前先检查现有的值，如果和预期一致则进行更新操作，如果不一致就放弃Put操作。
这种原子性的Put非常适用于多客户端并发修改的时候使用。

private static void test4() {
    Configuration conf = HBaseConfiguration.create();
    Connection connection = null;
    Table table = null;
    try {
        connection = ConnectionFactory.createConnection(conf);
        table = connection.getTable(TableName.valueOf("DLR:ft_fact_data_month_quarter"));
        Put put = new Put(Bytes.toBytes("100003_00201612_500000"));
        put.addColumn(Bytes.toBytes("cf"), Bytes.toBytes("factory_id"), Bytes.toBytes("100004"));

        //第一个参数为Rowkey,第二个参数为列族，第三个参数为列标签，第四个参数为参考值，第五个为put对象
        boolean isPass = table.checkAndPut(Bytes.toBytes("100003_00201612_500000"), Bytes.toBytes("cf"),
                Bytes.toBytes("factory_id"), Bytes.toBytes("100006"), put);
        if (isPass) {
            System.out.println("更新成功！");
        } else {
            System.out.println("放弃操作！");
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if (table != null) {
                table.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
二、 读取数据
5、 单行Get

可以使用Get对象来读取HBase里的一行数据，可以指定读取的列族、列标签、版本。

private static void test1() {
    Configuration conf = HBaseConfiguration.create();
    Connection connection = null;
    Table table = null;
    try {
        connection = ConnectionFactory.createConnection(conf);
        table = connection.getTable(TableName.valueOf("DLR:ft_fact_data_month_quarter"));
        //实例化一个Get对象
        Get get = new Get(Bytes.toBytes("100003_00201612_500000"));

        //添加一个要Get的列族
        get.addFamily(Bytes.toBytes("cf"));
        //添加一个要Get的列标签
        get.addColumn(Bytes.toBytes("cf"), Bytes.toBytes("factory_id"));
        //添加一个要Get的列标签
        get.addColumn(Bytes.toBytes("cf"), Bytes.toBytes("log_date"));
        //去HBase服务器执行查询
        Result result = table.get(get);
        System.out.println(result);
        //结果行的RowKey
        String rowKey=Bytes.toString(result.getRow());
        //打印结果
        for (Cell cell:result.listCells()){            
            //列名
            String qualifier = Bytes.toString(CellUtil.cloneQualifier(cell));
            //单元格的值
            String val = Bytes.toString(CellUtil.cloneValue(cell));
            System.out.println("RowKey:" + rowKey + "列：" + qualifier + ";值长度：" + CellUtil.cloneValue(cell).length + ";值：" + val);
        }      
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if (table != null) {
                table.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
6、 Result类

如上个Get代码实例中所示：使用Get读取数据返回的数据被封装在一个Result对象里，可以通过getRow()方法来获取RowKey，Result对象的listCells属性是查询结果中所有的单元格，可以借助于CellUtil类来获取每个单元格的列标签信息、单元格值信息。

7、 Get列表

类似于Put列表，Get列表是可以一次请求多行数据的。

private static void test2() {
    Configuration conf = HBaseConfiguration.create();
    Connection connection = null;
    Table table = null;
    try {
        connection = ConnectionFactory.createConnection(conf);
        table = connection.getTable(TableName.valueOf("DLR:ft_fact_data_month_quarter"));
        List<Get> list = new ArrayList<>();

        //实例化一个Get对象
        Get get = new Get(Bytes.toBytes("100003_00201612_500000"));
        //添加一个要Get的列标签
        get.addColumn(Bytes.toBytes("cf"), Bytes.toBytes("factory_id"));
        list.add(get);

        //实例化一个Get对象
        Get get1 = new Get(Bytes.toBytes("100004_00201612_500000"));
        //添加一个要Get的列标签
        get1.addColumn(Bytes.toBytes("cf"), Bytes.toBytes("factory_id"));
        list.add(get1);

        //实例化一个Get对象
        Get get2 = new Get(Bytes.toBytes("100005_00201612_500000"));
        //添加一个要Get的列标签
        get2.addColumn(Bytes.toBytes("cf"), Bytes.toBytes("factory_id"));
        list.add(get2);

        //去HBase服务器执行查询
        Result[] results = table.get(list);

        //打印结果
        for (Result result : results) {
            //结果行的RowKey
            String rowKey = Bytes.toString(result.getRow());
            for (Cell cell : result.listCells()) {
                //列名
                String qualifier = Bytes.toString(CellUtil.cloneQualifier(cell));
                //单元格的值
                String val = Bytes.toString(CellUtil.cloneValue(cell));
                System.out.println("RowKey:" + rowKey + "列：" + qualifier + ";值长度：" + CellUtil.cloneValue(cell).length + ";值：" + val);
            }
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if (table != null) {
                table.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
三、 删除数据
1、 单行Delete
private static void test1(){
    Configuration conf=HBaseConfiguration.create();
    Connection connection=null;
    Table table=null;
    try {
        connection= ConnectionFactory.createConnection(conf);
        table=connection.getTable(TableName.valueOf("DLR:ft_fact_data_month_quarter"));
        //创建一个Delete对象，指定Rowkey
        Delete delete=new Delete(Bytes.toBytes("100003_00201612_500000"));
        //指定删除某一个列，只删除最新版本
        delete.addColumn(Bytes.toBytes("cf"),Bytes.toBytes("factory_id"));
        //指定删除某一个列族
        delete.addFamily(Bytes.toBytes("cf"));
        //指定删除方法
        table.delete(delete);
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        try {
            if (table != null) {
                table.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
2、 Delete列表
private static void test2() {
    Configuration conf = HBaseConfiguration.create();
    Connection connection = null;
    Table table = null;
    try {
        connection = ConnectionFactory.createConnection(conf);
        table = connection.getTable(TableName.valueOf("DLR:ft_fact_data_month_quarter"));
        List<Delete> list = new ArrayList<>();

        //创建一个Delete对象，指定Rowkey
        Delete delete = new Delete(Bytes.toBytes("100004_00201612_500000"));
        //指定删除某一个列,只删除最新版本
        delete.addColumn(Bytes.toBytes("cf"), Bytes.toBytes("factory_id"));
        list.add(delete);

        Delete delete2 = new Delete(Bytes.toBytes("100006_00201612_500000"));
        //指定删除某一个列,删除所有版本
        delete2.addColumns(Bytes.toBytes("cf"), Bytes.toBytes("factory_id"));
        list.add(delete2);

//删除所有的列族、列、所有版本
Delete delete3 = new Delete(Bytes.toBytes("100005_00201612_500000"));
list.add(delete3);

        //指定删除方法
        table.delete(list);
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if (table != null) {
                table.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
四、 扫描表

HBase中的数据是按照RowKey顺序存储的，扫描表是根据RowKey进行扫描，可以指定扫描的开始rowkey和结束rowkey，但是扫描结果里，是包括开始rowkey的，但是并不包括结束rowkey，如果没有指定开始rowkey，就从表的开始位置扫描，如果没有指定结束rowkey，就扫描到表的末尾。
另外可以指定扫描哪个列族、哪个列、开始Rowkey、结束RowKey、过滤器等。

private static void test1() {
    Configuration conf = HBaseConfiguration.create();
    Connection connection = null;
    Table table = null;

    try {
        connection = ConnectionFactory.createConnection(conf);
        table = connection.getTable(TableName.valueOf("DLR:ft_fact_data_month_quarter"));
        Scan scan = new Scan();
        //指定开始rowkey
        scan.setStartRow(Bytes.toBytes("000003_00020164_000000"));
        //指定结束rowkey
        scan.setStopRow(Bytes.toBytes("000004_20161117_340000"));
        //指定扫描哪个列族
        scan.addFamily(Bytes.toBytes("cf"));
        //指定扫描哪个列
        scan.addColumn(Bytes.toBytes("cf"), Bytes.toBytes("factory_id"));
        //得到一个表扫描器
        ResultScanner resultScanner = table.getScanner(scan);
        //循环打印扫描结果
        for (Result result : resultScanner) {
            //打印rowkey
            System.out.println("RowKey:" + result.getRow());
            String columnsVal="";
            //循环一行中的各个单元格
            for(Cell cell:result.listCells()){
                //获取单元格所在的列族
                String family= Bytes.toString(CellUtil.cloneFamily(cell));
                //获取单元格所在的列
                String qualifier= Bytes.toString(CellUtil.cloneQualifier(cell));
                //获取单元格所在的值
                String val=Bytes.toString(CellUtil.cloneValue(cell));
                columnsVal+="列族："+family+",列："+qualifier+",值："+val+";";
            }
            System.out.println(columnsVal);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

第二部分： HBase管理功能API

五、 Table模式定义

使用HTableDescriptor对象进行对表的模式定义，实例如下：

private void test1()
{
    HTableDescriptor tableDesc=new HTableDescriptor(TableName.valueOf("Test:demo1"));
    HColumnDescriptor columnDesc=new HColumnDescriptor("cf");
    //添加列族
    tableDesc.addFamily(columnDesc);
    //设置region分割点大小
    tableDesc.setMaxFileSize(524288000);
    //设置表只读
    tableDesc.setReadOnly(true);
    //设置刷写大小
    tableDesc.setMemStoreFlushSize(33554432);
    //设置用户自定义参数
    tableDesc.setValue("mykey","myval");
    //获取自定义参数
    tableDesc.getValue("mykey");
    //移出自定义参数
    tableDesc.remove("mykey");
}

(1) 列族
HBase建表时要指定列族，之后可以添加列族、判断列族是否存在、获取列族列表、获取某一个列族的描述、删除列族等操作。使用HColumnDescriptor对象来对列族进行定义，后面会详细说明HColumnDescriptor。

(2) 文件大小限制
当一个region大小达到配置的大小的时候，HBase会拆分region，这个region进行拆分的分割点可以配置，HTableDescriptor对象的setMaxFileSize()方法来进行设置，当表的数据量特别大时候，可以适量地调高这个值。

(3) 表只读
默认的表是可写的，如果将一个表设置为只读，可以调用HTableDescriptor对象的setReadOnly方法来设置。

(4) 写缓冲区大小
HBase的内存中会预留一个写缓冲区，写入的数据会先存放在写缓冲区中，然后再存入文件中，可以用HTableDescriptor的setMemStoreFlushSize方法设置缓冲区的大小。

(5) 自定义参数
用户可以自定义一些键值对到HTable上。

六、 列族模式定义

列族的模式定义使用HColumnDescriptor类来封装

(1) 列族名称
每个列族都用名字，但是除了构造函数，没有其他重命名列族的途径。

(2) 最大版本数
列族中限制了每个值能保留的最大版本数量。

(3) 压缩
HBase支持插件式的压缩算法，可以用的压缩算法如下：

算法描述
NONE不压缩（HBase默认值）
GZ使用Java提供的或者本地库提供的GZIP
LZO需要独立安装LZO的类库
SNAPPY需要独立安装

通过HColumnDescriptor的setCompressionType来设置压缩算法，压缩类型是Compression.Algorithm枚举值。

(4) 块大小
HBase中存储的文件会被划分为很多小块，这些小块在get或者scan的时候会被加载到内存中，可以设置这个块的大小。
这个块不同于HDFS中的分块，HDFS中分块是为了分布式存储拆分的，并利于MapReduce的计算而划分的，比较大；这里的块用于HBase高效地在内存中加载和缓冲数据，只用于HBase内部，比较小。

(5) 是否开启读取缓存块
默认是是打开的，读取数据时把数据存入缓存并不一定能提高性能，如果只是对列族的get操作和顺序化地scan操作，没有必要启用读取缓存。当有对一个rowkey要进行连续反复访问时，适合将读取缓存打开。

(6) 生存期
值不但可以指定版本数，也可以设置保存的最大生命周期，如果超过设置的时间，数据就会被删除。单位是秒，默认是Integer.MAX_VALUE。

(7) 是否在内存
当设置为true的时候，列族的数据会被优先放入读取缓存。

(8) 布隆过滤器
布隆过滤器可以提高某些时候的查询时间，但是它会增加内存和存储的开销，默认布隆过滤器是被关闭的，可以通过setBloomFilterType设置布隆过滤器，值为BloomType类型的枚举。

类型描述
NONE不使用布隆过滤器
ROW在rowkey上使用布隆过滤器进行过滤
ROWCOL在列标识符级别使用布隆过滤器

七、 表操作

表操作需要创建一个HBaseAdmin实例来进行各种操作。
(1) 创建表

private void test1() {
    Configuration conf = HBaseConfiguration.create();
    Connection connection = null;
    try {
        connection = ConnectionFactory.createConnection(conf);
//创建HBaseAdmin实例
        HBaseAdmin admin = (HBaseAdmin) connection.getAdmin();
        HTableDescriptor tableDesc = new HTableDescriptor(TableName.valueOf("Test:demo1"));
        HColumnDescriptor columnDesc = new HColumnDescriptor("cf");

        //添加列族
        tableDesc.addFamily(columnDesc);
        //设置region分割点大小
        tableDesc.setMaxFileSize(524288000);
        //设置表只读
        tableDesc.setReadOnly(true);
        //设置刷写大小
        tableDesc.setMemStoreFlushSize(33554432);
        //设置用户自定义参数
        tableDesc.setValue("mykey", "myval");
        //获取自定义参数
        tableDesc.getValue("mykey");
        //移出自定义参数
        tableDesc.remove("mykey");

        //创建表
        admin.createTable(tableDesc);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

(2) 预分区建表
预分区创建表时将在创建表时划分出若干特定的Region。

private static void test2() {
    Configuration conf = HBaseConfiguration.create();
    Connection connection = null;
    try {
        connection = ConnectionFactory.createConnection(conf);
        HBaseAdmin admin = (HBaseAdmin) connection.getAdmin();
        HTableDescriptor tableDesc = new HTableDescriptor(TableName.valueOf("weibo:demo2"));
        HColumnDescriptor columnDesc = new HColumnDescriptor("cf");
        tableDesc.addFamily(columnDesc);

        //创建预分区表，指定rowkey边界和分区数
        admin.createTable(tableDesc, Bytes.toBytes(1L),Bytes.toBytes(100L),10);
    } catch (IOException e) {
        e.printStackTrace();
    }
}
private static void test3() {
    Configuration conf = HBaseConfiguration.create();
    Connection connection = null;
    try {
        connection = ConnectionFactory.createConnection(conf);
        HBaseAdmin admin = (HBaseAdmin) connection.getAdmin();
        if (!admin.tableExists(TableName.valueOf("weibo:demo3"))) {
            HTableDescriptor tableDesc = new HTableDescriptor(TableName.valueOf("weibo:demo3"));
            HColumnDescriptor columnDesc = new HColumnDescriptor("cf");
            tableDesc.addFamily(columnDesc);
            //指定划分region的边界值
            byte[][] regions = new byte[][]{
                    Bytes.toBytes("A"),
                    Bytes.toBytes("B"),
                    Bytes.toBytes("C"),
                    Bytes.toBytes("D"),
                    Bytes.toBytes("E")
            };
            //创建预分区表，指定rowkey边界和分区数
            admin.createTable(tableDesc, regions);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

(3) 获取表结构

private static void test4() {
    Configuration conf = HBaseConfiguration.create();
    Connection connection = null;
    try {
        connection = ConnectionFactory.createConnection(conf);
        HBaseAdmin admin = (HBaseAdmin) connection.getAdmin();
        if (admin.tableExists(TableName.valueOf("weibo:demo3"))) {
            HTableDescriptor desc = admin.getTableDescriptor(TableName.valueOf("weibo:demo3"));
            System.out.println(desc);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

(4) 删除表
在删除表之前要先将表禁用，禁用时会现将内存中未提交到磁盘数据刷写到磁盘，然后关闭所有region，并更新表的元数据，将所有的region标记为下线。删除表后，对应的数据也会被删除。

private static void test5() {
    Configuration conf = HBaseConfiguration.create();
    Connection connection = null;
    try {
        connection = ConnectionFactory.createConnection(conf);
        HBaseAdmin admin = (HBaseAdmin) connection.getAdmin();
        TableName tableName = TableName.valueOf("weibo:demo3");
        if (admin.tableExists(tableName)) {
            HTableDescriptor desc=admin.getTableDescriptor(tableName);
            System.out.println("禁用前表当前状态isTableAvailable："+admin.isTableAvailable(tableName));
            System.out.println("禁用前表isTableEnabled："+admin.isTableEnabled(tableName));
            admin.disableTable(tableName);
            System.out.println("禁用后表当前状态isTableAvailable："+admin.isTableAvailable(tableName));
            System.out.println("禁用后表isTableEnabled："+admin.isTableEnabled(tableName));
            admin.deleteTable(tableName);
            System.out.println("删除后表当前状态isTableAvailable："+admin.isTableAvailable(tableName));
            admin.createTable(desc);
            System.out.println("创建表后表当前状态isTableAvailable："+admin.isTableAvailable(tableName));
            System.out.println("创建表后表isTableEnabled："+admin.isTableEnabled(tableName));
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}
输出：
禁用前表当前状态isTableAvailable：true
禁用前表isTableEnabled：true
禁用后表当前状态isTableAvailable：true
禁用后表isTableEnabled：false
删除后表当前状态isTableAvailable：false
创建表后表当前状态isTableAvailable：true
创建表后表isTableEnabled：true

这一篇博文是【大数据技术●降龙十八掌】系列文章的其中一篇，点击查看目录：这里写图片描述大数据技术●降龙十八掌

鸣宇淳
关注
专栏目录
大数据HBase（五）：HBase的相关操作JavaAPI方式
Lansonli（蓝深李）的博客
06-28 2309
全网最详细的大数据HBase文章系列，强烈建议收藏加关注！ 新文章都已经列出历史文章目录，帮助大家回顾前面的知识重点。 目录 系列历史文章 前言 HBase的相关操作-JavaAPI方式 一、需求说明 二、准备工作 1、创建IDEA Maven 项目 2、导入相关pom依赖 3、创建包结构和类 系列历史文章 2021年大数据HBase（四）：HBase的相关操作-客户端命令式！【建议收藏】 2021年大数据HBase（三）：HBase数据模型 2021年大数据HBase（二）.
HBase搭建并使用Java调用HBaseAPI
追求卓越的攻城狮
09-22 4219
1、HBase的搭建1.1下载HBase0.94.141.2修改 conf/hbase-site.xml<configuration> <property> <name>hbase.rootdir</name> <value>file:///root/test/hbase</value> </property><property> <name>hbase.zookeepe
HBase-读写流程及JavaAPI
liberty12345678的专栏
01-09 767
1、读写流程 1.1、HBase 读数据流程 1) HRegionServer 保存着 meta 表以及表数据，要访问表数据，首先 Client 先去访问 zookeeper，从 zookeeper 里面获取 meta 表所在的位置信息，即找到这个 meta 表在哪个 HRegionServer 上保存着。 2) 接着 Client 通过刚才获取到的 HRegionServer 的 IP 来...
HBase的JavaAPI使用--基础篇
大数据梦想家
12-17 4291
        本篇博客小菌为大家带来的是关于HBase的JavaAPI使用。 创建项目,导入pom <repositories> <repository> <id>cloudera</id> <ur...
【十八掌●武功篇】第八掌：HBase之基本概念
鸣宇淳的专栏
12-01 652
第一部分： HBase概述
使用Java Api 对HBase进行简单操作
weixin_34342578的博客
12-06 132
/** * 功能：测试Hbase基本的增删改查操作 * Created by liuhuichao on 2016/12/5. */ public class HbaseCRUDTest { public static Configuration configuration; static{ configu...
HBase 5种写入数据方式(java API)
YiqiangXu的博客
11-30 7286
HBase 5种写入数据方式(java API):  点击打开链接
逐步掌握HBase的Java API常用操作
clonechen
05-08 2105
文章目录引入依赖连接工具类基础工具类基础工具类测试HBase过滤器使用综合案例 引入依赖 首先需要引入HBase相关依赖 <dependency> <groupId>org.apache.hbase</groupId> <artifactId>hbase-client</artifactId&...
HBase之Java API 操作
u010391342的博客
08-13 1012
HBase的管理Java API 中止服务器或客户端。 void abort(String why,Throwable e) 检查服务器或客户端是否已中止。 boolean isAborted() 返回此对象使用的连接。 Connection getConnection() 判断表述否已存在，不存在则创建表 boolean tableExists 列...
分布式存储系统：HBase：HBase基本操作与Shell命令.docx
最新发布
09-02
分布式存储系统：HBase：HBase基本操作与Shell命令.docx
java操作Hbase之从Hbase中读取数据写入hdfs中源码
01-17
java操作Hbase之从Hbase中读取数据写入hdfs中源码，附带全部所需jar包，欢迎下载学习。
HBase基本操作 Java代码
02-15
HBase基本操作 增删改查 java代码 要使用须导入对应的jar包
分布式存储系统：HBase：HBase数据读写API教程.docx
09-02
分布式存储系统：HBase：HBase数据读写API教程.docx
使用Java对Hbase进行操作总结
zp17834994071的博客
07-22 1795
前面已经给大家讲解过如何使用Hbase建表，以及基本的操作和一些常用shell命令，今天就给大家介绍下如何使用java对Hbase进行各种操作。 没印象的话可以再去浏览下： Hbase入门教程，shell命令大全讲解 Java操作Hbase主要方法： 1.Configuration 在使用Java API时，Client端需要知道HBase的配置环境，如存储地址，zookeeper等信息。 这些信息通过Configuration对象来封装，可通过如下代码构建该对象： Configuration config
HBase Java API(1.2.X)使用简介
cjf_wei的博客
08-12 1238
之前读《HBase权威指南》在实践时，发现API已经发生了一些变化，查阅官方文档，确任HBase的API在1.0版本后已经做了修改。本文介绍在新API下，使用Java访问HBase的方法。 HBase Client通过查询hbase:meta表来确定你所感兴趣的数据行所在的RegionServers。在定位到这些数据所在的region后，client会直接和这些region所在的RegionSe...
Hbase Java API
qq_38304320的博客
11-06 378
1.创建表 public static void createSchemaTables(Configuration configuration) throws IOException { Connection conn = ConnectionFactory.createConnection(configuration); Admin admin = conn.getAdmin(...
大数据电信项目之分区键和rowkey的设计
wenpan的博客
01-18 699
项目大体流程： 先由自己写好的生产者程序jar包不停的向call.log文件中生产通话日志，模拟用户通话 使用flume监控日志文件call.log，将该日志文件作为flume的source源，通过channel和sink 使用kafka创建topic，flume监控得到的数据作为kafka的producer，然后将数据写入到指定的topic中 启动一个消费者程序，将topic中的数据进行...
Flink DataStream常用算子
热门推荐
鸣宇淳的专栏
02-14 2万+
Flink中的算子是将一个或多个DataStream转换为新的DataStream，可以将多个转换组合成复杂的数据流拓扑。 在Flink中，有多种不同的DataStream类型，他们之间是使用各种算子进行的。如下图所示： 以下列举下常用的算子，用到的代码例子都是Flink监听9000端口做为数据源。以下方法可以启动一个9000的socket端口服务。 Linux平台上可以使用 bash nc -...
Java编程：HBase API操作详解
在Java代码中，获取`Configuration`对象是操作HBase的第一步。我们可以利用`HBaseConfiguration.create()`方法获取一个配置实例，并设置Zookeeper的集群地址（例如`192.168.9.102`）和客户端端口（如`2181`），这些...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值