HBase BulkLoad Put

最新推荐文章于 2021-12-06 17:35:16 发布
最新推荐文章于 2021-12-06 17:35:16 发布
阅读量424 收藏 2
点赞数
文章标签： 大数据 java
原文链接：https://my.oschina.net/htzy/blog/1798604
版权

为什么80%的码农都做不了架构师？>>>   hot3.png

先不多说，先贴代码（代码中包含业务内容，选择性忽略），当前使用的Hadoop版本：2.7.3，HBase版本：1.2.6。

代码

// HFileCreate.java
package com.huangshihe.ecommerce.hbasesimulation;

import com.huangshihe.ecommerce.ecommercehbase.hbaseservice.constants.CommonConstant;
import org.apache.hadoop.hbase.KeyValue;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * HFile生成.
 * <p>
 * Create Date: 2018-04-12 21:00
 *
 * @author huangshihe
 */
public class HFileCreate {

    private static final Logger LOGGER = LoggerFactory.getLogger(HFileCreate.class);

    private static Simulation _simulation;

    private static List<String> _qualifiers;

    public static void buildSimulation(Simulation simulation) {
        _simulation = simulation;
        _qualifiers = simulation.getQualifierIndexs();
        LOGGER.debug("qualifiers:{}", _qualifiers);
    }

    private HFileCreate() {

    }


    public static class HFileImportMapper2 extends
            Mapper<LongWritable, Text, ImmutableBytesWritable, Put> {

        private static final String regEx = "\"?(\\[([0-9 ,-]*)\\])\"?";
        private final Pattern pattern = Pattern.compile(regEx);


        @Override
        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
            String line = value.toString();
            LOGGER.debug("line:{}", line);
            // "[0, 0, 0, 0, 0, 0][0, 0, 0, 0, 0, 0][0, 0, 31, 62, 70, 70]
            // [0, 0, 1, 98, -70, -107, -60, 0][0, 0, 0, 1, 70, 70]",
            //"[0, 0, 0, 3, 0, 0][0, 0, 0, 2][0, 0, 0, 4][-1, -1, -1, -48][0, 0, 0, 64][1][0]"
            String[] lines = line.split("\",\"");
            String rowkeyStr = lines[0];
            LOGGER.debug("rowkeyStr:{}", rowkeyStr);
            String qualifierStr = lines[1];
            LOGGER.debug("qualifierStr:{}", qualifierStr);
            Matcher matcher = pattern.matcher(rowkeyStr);
            byte[] rowkeyByte = new byte[0];
            while (matcher.find()) {
                String str = matcher.group(2);
                String[] strs = str.split(",");
                byte[] b = new byte[strs.length];
                for (int i = 0; i < strs.length; i++) {
                    b[i] = Byte.parseByte(strs[i].trim());
                }
                rowkeyByte = Bytes.add(rowkeyByte, b);
            }
            LOGGER.debug("rowkeyByte:{}", Arrays.toString(rowkeyByte));

            final ImmutableBytesWritable rowkey = new ImmutableBytesWritable(rowkeyByte);

            // 拆解qualifier
            matcher = pattern.matcher(qualifierStr);

            Put put = new Put(rowkeyByte);

            // 当前的qualifier坐标
            int qualifierIndex = 0;
            List<KeyValue> kvList = new ArrayList<>(_qualifiers.size());
            while (matcher.find()) {
                // 获取其中一个qualifier
                String str = matcher.group(2);  // 由逗号分隔的字节数组
                String[] strs = str.split(",");
                byte[] b = new byte[strs.length];
                for (int i = 0; i < strs.length; i++) {
                    // 将str中的字节还原为真实的字节，并放入数组中
                    b[i] = Byte.parseByte(strs[i].trim());
                }
                // 获取qualifier！
                String qualifier;
                if (_qualifiers.size() > qualifierIndex) {
                    qualifier = _qualifiers.get(qualifierIndex++);
                } else {
                    LOGGER.error("qualifiers不足！qualifiers:{}, qualifierIndex", _qualifiers, qualifierIndex);
                    throw new IllegalArgumentException("qualifiers不足！");
                }
                put.addColumn(Bytes.toBytes(CommonConstant.FAMILY_NAME), Bytes.toBytes(qualifier), b);
            }
            context.write(rowkey, put);

        }
    }

}

// Controller.java
/*
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.mapreduce.HFileOutputFormat2;
import org.apache.hadoop.hbase.mapreduce.PutSortReducer;
import org.apache.hadoop.hbase.util.Pair;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
*/
Thread thread = new Thread(() -> {
            LOGGER.debug("begin create HFiles...");
            // 连接HBase
            Configuration conf = HBaseConnectionManager.getInstance().getNewConfiguration();
            /
            IHBaseDao hbaseDao = new HBaseDaoImpl();
            /

            // 获取所有需要保存到HFile为文件
            for (File datFile : FileKit.getAllFiles(Constants.SIMULATION_HBASE_DIR, "(.*)\\.dat")) {
                // tableName，表名：表名前缀+文件名（去后缀）
                String tableName = OriginalConstant.TABLE_NAME_PRE + FileKit.getFileNameStr(datFile);
                String datFilePath = datFile.getAbsolutePath();
                // 运行前，删除已存在的中间输出目录
                try {
                    LOGGER.debug("simulation file dir:{}", Constants.SIMULATION_HFILE_DIR);
                    FileSystem fs = FileSystem.get(URI.create(Constants.SIMULATION_HFILE_DIR), conf);

                    fs.delete(new Path(Constants.SIMULATION_HFILE_DIR), true);
                    fs.close();
                } catch (IOException e) {
                    LOGGER.error("io exception... detail:{}", e);
                    throw new IllegalArgumentException(e);
                }

                // 如果表不存在，创建表
                if (!hbaseDao.isExists(tableName)) {
                    hbaseDao.createTable(tableName, CommonConstant.FAMILY_NAME, OriginalConstant.TTL);
                }
                // 获取表
                Table table = hbaseDao.getTable(tableName);


                // 生成Job，注意以下的包别导错！
                try {

                    ///
                    // 通过调试，发现默认添加的序列器只有三个，这里手动添加其他的
                    // 其中Put.class用的是org.apache.hadoop.hbase.mapreduce.MutationSerialization，否则将报空指针
                    conf.set("io.serializations","org.apache.hadoop.io.serializer.JavaSerialization,"
                            + "org.apache.hadoop.io.serializer.WritableSerialization,"
                            + "org.apache.hadoop.hbase.mapreduce.KeyValueSerialization,"
                            + "org.apache.hadoop.hbase.mapreduce.MutationSerialization,"
                            + "org.apache.hadoop.hbase.mapreduce.ResultSerialization"
                    );
                    ///

                    Job job = Job.getInstance(conf, "create HFile");
                    job.setJarByClass(Controller.class);

                    // in/out format
                    job.setInputFormatClass(TextInputFormat.class);
                    job.setOutputFormatClass(HFileOutputFormat2.class);

                    // 设置mapper类
                    job.setMapperClass(HFileCreate.HFileImportMapper2.class);
                    // HFileOutputFormat2.configureIncrementalLoadMap 没有指定Put默认为PutSortReducer，所以这里手动指定
                    job.setReducerClass(PutSortReducer.class);


                    // 设置输出的key和value类
                    job.setMapOutputKeyClass(ImmutableBytesWritable.class);
                    job.setMapOutputValueClass(Put.class);
//                    job.setMapOutputValueClass(KeyValue.class);

                    // speculation
                    job.setSpeculativeExecution(false);
                    job.setReduceSpeculativeExecution(false);

                    // 设置输入/输出路径
                    FileInputFormat.setInputPaths(job, datFilePath);
                    FileOutputFormat.setOutputPath(job, new Path(Constants.SIMULATION_HFILE_DIR));

//                    HFileOutputFormat2.configureIncrementalLoad(job, table, hbaseDao.getRegionLocator(table));
                    HFileOutputFormat2.configureIncrementalLoadMap(job, table);
                    // 设置等待
                    job.waitForCompletion(true);
                } catch (IOException e) {
                    LOGGER.error("io exception... detail:{}", e);
                    throw new IllegalArgumentException(e);
                } catch (InterruptedException e) {
                    LOGGER.error("interrupted exception... detail:{}", e);
                    throw new IllegalArgumentException(e);
                } catch (ClassNotFoundException e) {
                    LOGGER.error("class not found! detail:{}", e);
                    throw new IllegalArgumentException(e);
                } catch (Exception e) {
                    LOGGER.error("unknown error, detail:{}", e);
                    throw new IllegalArgumentException(e);
                } finally {
                    try {
                        if (table != null) {
                            table.close();
                        }
                    } catch (IOException e) {
                        LOGGER.error("close table error!");
                    }
                }

            }

注意点

有几个需要注意的点：

  1. 这里使用的是HFileOutputFormat2.configureIncrementalLoadMap(job, table);而不是configureIncrementalLoad方法。在configureIncrementalLoad方法中指定了Put和KeyValue的reducer类，而configureIncrementalLoadMap方法没有，所以在生成job时需要手动指定。另外在使用configureIncrementalLoad方法过程中遇到了环境变量等问题，这里暂时没有解决，直接使用configureIncrementalLoadMap方法了。

  2. 在使用configureIncrementalLoadMap方法，序列化类会缺少，所以这里也手动添加： conf.set("io.serializations", "org.apache.hadoop.io.serializer.JavaSerialization," + "org.apache.hadoop.io.serializer.WritableSerialization," + "org.apache.hadoop.hbase.mapreduce.KeyValueSerialization," + "org.apache.hadoop.hbase.mapreduce.MutationSerialization," + "org.apache.hadoop.hbase.mapreduce.ResultSerialization" );

  3. 代码完整地址：（分支可能会变化） https://github.com/htzy/e-commerce/tree/b_0_0_1/tools/hbase-simulation

乱七八糟（以下为追加模式）

1. 问题：org.apache.hadoop.hbase.client.Put cannot be cast to org.apache.hadoop.hbase.Cell

解决过程：

以下内容中的： https://www.2cto.com/net/201710/692437.html 第4点报错类似 输入图片说明

换成KeyValue之后，报错： http://mail-archives.apache.org/mod_mbox/hbase-user/201405.mbox/%3CCAAMYKhq1gP8O2FJREEUZZpTxeGPO9w7Eu94RmKYMkxopOFekbw@mail.gmail.com%3E  尝试解决： https://stackoverflow.com/questions/37047145/why-hbase-keyvaluesortreducer-need-to-sort-all-keyvalue https://www.2cto.com/net/201710/692437.html

报错： Added a key not lexically larger than previous \x00\x00\x06\x1F\x00\x00\x00\x00\x06C\x00\x00\x00\x00\x0A\x1CFF\x00\x00\x01b\xD9{\xEC\x00\x00\x00\x00\x00FF/t:6/1524154091347/Put/vlen=1/seqid=0,

lastCell = \x00\x00\x06\x1F\x00\x00\x00\x00\x06C\x00\x00\x00\x00\x0A\x1CFF\x00\x00\x01b\xD9{\xEC\x00\x00\x00\x00\x00FF/t:7/1524154091347/Put/vlen=1/seqid=0

Current cell = \x00\x00\x06\x1F\x00\x00\x00\x00\x06>\x00\x00\x00\x00"\xF0FF\x00\x00\x01b\xD9{\xEC\x00\x00\x00\x00\x00FF/t:1/1524154499615/Put/vlen=6/seqid=0,

lastCell = \x00\x00\x06\x1F\x00\x00\x00\x00\x06>\x00\x00\x00\x00"\xF0FF\x00\x00\x01b\xD9{\xEC\x00\x00\x00\x00\x00FF/t:5/1524154499615/Put/vlen=4/seqid=0

手动排序后，只写入一条，则可以成功！如果rowkey一样，则无法写入！

kvList.sort((o1, o2) -> Bytes.compareTo(o2.getRowArray(), o1.getRowArray()));

如果同一个rowkey，只写入一个keyValue，那么不管多少条rowkey都可以成功！fuck 

手动指定reducer类为：job.setReducerClass(PutSortReducer.class);即可以使用Put了！

2. 问题获取Put序列化器失败

解决过程： 参考：https://blog.csdn.net/opensure/article/details/47054861 （Bulk Load－HBase数据导入最佳实践） 在使用BulkLoad生成HFile文件过程中报错： 具体的错误类似于： http://mail-archives.apache.org/mod_mbox/hbase-user/201504.mbox/raw/%3CCAPQV63WOjomoddv0X+VKbnMzguf6ViHuNnJPSyNE_7hsZjOzvw@mail.gmail.com%3E

输入图片说明 

获取Put.class的序列化器失败！

调试：

输入图片说明

发现SerializationFactory中的获取序列化器，在接受Put.class一直失败

输入图片说明

而目前发现实现了该序列化接口的只有： 输入图片说明

输入图片说明 

所以，索性：tmd在生成job时直接添加：

输入图片说明

 

转载于:https://my.oschina.net/htzy/blog/1798604

weixin_33924220
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Hbase——Bulkload
weixin_38244018的博客
08-03 281
Bulkload HBase 有好几种方法将数据装载到表。最直接的方式即可以通过MapReduce任务，也可以通过普通客户端API。但是这都不是高效方法。 批量装载特性采用 MapReduce 任务，将表数据输出为HBase的内部数据格式，然后可以将产生的存储文件直接装载到运行的集群中。批量装载比简单使用 HBase API 消耗更少的CPU和网络资源。 批量装载架构 HBase 批量装载过程包含...
HBase工具之BulkLoad
xiao的博客
09-19 2498
使用BulkLoad是由于实际业务的需要，每个月底都需要向HBase插入大约200G的数据，接近10亿条记录。在插入过程中需要占用大量的IO资源，极大影响了现有的实时数据入库业务的效率。因此需要寻找一种替代的方案来在不影响现有业务的基础上，不占用大量集群资源，快速高效的插入大量的数据。本文主要介绍了BulkLoad的工作机制和应用，以及在使用过程中遇到的问题，最后简要分析了BulkLoad的源码步骤
Parquet-Hbase-bulkload-Put-Buffered-example:通过使用 WAL 和缓冲的 Put 从 Hdfs 文件中摄取 HBase 记录
06-29
通过使用 WAL 和缓冲的 Put 从 Hdfs 文件中摄取 HBase 记录 通过 WAL（使用 Put）将具有 PARQUET 格式的 hdfs 文件加载到 Hbase 的包。 该包基于仅使用 Mapper 加载表。 很快我将添加如何使用 reducer 以及使用 MR 驱动程序自动刷新所有放置的另一个版本，而无需使用 TAblemapper 类进行缓冲控制。 另一个例子： : 在添加的这个示例中，性能明显提高，将更多的缓冲项从 1 增加到 1000，基于 14 个节点的集群将时间从 25 分钟减少到 50 秒。 但是，将缓冲增加到 10K，响应不如超时开始播放。 这个过程很简单。 首先配置作业添加 Hbase 所需的所有资源。 请注意，有时需要 addDependencyJars，以便映射器运行的节点获取处理 Hbase 所需的 jar。 在映射器中，连接是在 SetUP
HBase的BulkLoad
淡定一生2333的博客
11-19 2369
在网上看到了一篇文章说到了HBase的BulkLoad机制，从文章中看出BulkLoad是不走HBase的服务端的，直接和Hadoop打交道将数据直接生成HFile，然后将文件直接移到Region下面。如下图所示： 相比较于直接写HBase，BulkLoad主要是绕过了写WAL日志这一步，还有写Memstore和Flush到磁盘，从理论上来分析性能会比Put快！ ...
Java 向Hbase表插入数据异常org.apache.hadoop.hbase.client.HTablePool$PooledHTable cannot be cast to org.apach...
weixin_33840661的博客
04-13 137
出错代码如下:      //1.create HTablePool HTablePool hp=new HTablePool(con, 1000); //2.get HTable from HTablepool HTable ht=(HTable)hp.getTable(tName); 出错原因,主要是版本更新了,所以旧的调用方式会报错:如今应用的api版本中pool.ge...
ClassCastException:org.apache.hadoop.mapreduce.lib.input.FileSplit cannot be cast to org.apache.had
厚积薄发
09-06 1558
java.lang.Exception: java.lang.ClassCastException: org.apache.hadoop.mapreduce.lib.input.FileSplit cannot be cast to org.apache.hadoop.mapred.FileSplit at org.apache.hadoop.mapred.LocalJobRunner$Job...
HBase客户端说明1
08-08
a) **导入**：可以从文件或目录导入数据，通常使用HBase的批处理工具如`hbase bulk load`。 b) **批量命令执行**：通过`put`命令批量写入数据，提高效率。 c) **导出**：可以导出表的所有数据或者选择性地导出...
hbase导入测试数据集
07-03
如果数据量很大，推荐使用 bulk load 功能，它可以显著提高导入速度。 ```bash hbase(main):002:0> put 'ORDER_INFO', 'row_key', 'ORDER_DETAILS:ORDER_ID', 'order_id_value' hbase(main):003:0> put 'ORDER_...
Hbase的安装与简单操作
最新发布
10-13
5. **Bulk Load**：通过HFile格式，可以批量加载大量数据到HBase，提高数据导入效率。 6. **Cell Versioning**：HBase支持每个单元格的多版本，可以按需控制保留的历史版本数量。 7. **Filter和Scanner**：HBase...
Hbase调用JavaAPI实现批量导入操作
08-06
`HBaseConfiguration`用于配置HBase连接参数，`HTable`代表一个HBase表，`Put`用于添加新行，而`BatchOperation`则用于执行批量操作。 3. **批量导入原理**： 批量导入通常使用`HTable`的`put`方法或者`batch`方法...
使用bulkload的方式将数据直接生成HFile格式时报错异常问题
kamisamak的博客
12-19 425
HBase与MapReduce的集成中使用bulkload的方式将数据直接生成HFile格式时报错 报错时代码 BulkLoadMap package com.kami.demo10; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.conf.Configured;...
hive导入hbase批量入库----单条put 、批量put 、Mapreduce、 bluckload
.
08-05 1738
https://blog.csdn.net/whdxjbw/article/details/81145672 https://www.jianshu.com/p/61afd6031887 1 每天百亿数据存入HBase，如何保证数据的存储正确和在规定的时间里全部录入完毕，不残留数据 1）数据量百亿条，什么概念呢？假设一整天60x60x24 = 86400秒都在写入数据，那么每秒的写入条数高达...
HBase骚操作之数据加载方式BulkLoad
石榴姐yyds
03-17 6579
本文研究了一种HBase BulkLoad的入库方式，该方式利用HBase的数据信息按照特定格式存储在hdfs内这一原理，直接在HDFS中生成持久化的HFile数据格式文件，然后上传至合适位置，即完成巨量数据快速入库的办法。该方式配合MapReduce完成，高效便捷，而且不占用Region资源，增添负载，在大数据量写入时能极大的提高写入效率，并降低对Hbase节点的写入压力。HBase BulkLoad对于异构数据源的合并及大量数据一次性导入具有重要指导意义，相比HBase Put操作在性能上具有较高的优势
HBase数据写入方式 与 BulkLoad
ThreeAspects的博客
08-07 1424
cookie和session都是用来跟踪浏览器用户身份的会话方式。SessionCookieSession与Cookie区别 Session   session机制是一种服务器端的机制，服务器使用一种类似于散列表的结构（也可能就是使用散列表）来保存信息。当程序需要为某个客户端的请求创建一个session时，服务器首先检查这个客户端的请求里是否已包含了一个session标识（称为session id...
spark 的createDstream和createDirectStream区别
ChengYanan的博客
04-23 536
spark读取kafka数据流提供了两种方式createDstream和createDirectStream。 两者区别如下： 1、KafkaUtils.createDstream 构造函数为KafkaUtils.createDstream(ssc, [zk], [consumer group id], [per-topic,partitions] ) 使用了receivers来接收数据，利用的是...
HBase学习笔记：使用BulkLoad特性快速导入海量数据
热门推荐
lrxcmwy2的博客
08-12 2万+
概述        HBase包含几种将数据加载到表中的方法，最直接的方法是HBase Shell、使用MapReduce作业中的TableOutputFormat类，或者使用普通的客户端api，然而，这些并不总是最有效的方法。BulkLoad特性使用MapReduce作业以HBase的内部数据格式输出表数据，然后直接将生成的存储文件加载到一个正在运行的集群中。使用批量加载将比简单地使用HBas...
HBase BulkLoad原理以及流程
xiaohu的博客
04-09 2452
Bulkload的原理和流程 HBase底层存储是以HFile文件存储在磁盘上 1、根据HDFS的数据或者外部的数据生成HBase底层的数据格式HFile文件 2、根据生成目标HFile，利用HBase提供的Bulkload工具将HFile移动（或加载）到HBase目录下 bulkLoad主要是将数据编写成HFile的形式，批量加载到HBase中，具有优于其他数据提取机制的优点，此操作完全绕过写入路径 优缺点： ① 数据可以立即呗hbase使用，但是会对集群造成额外的负载和延迟 ② BulkLoad操作不
Hbase批量装载--bulk load
胜利的曙光的博客
12-06 1101
HBase BulkLoad批量装载数据。
HBase BulkLoad批量写入数据
03-29
HBase的BulkLoad（批量加载）是一种高效的方式，可以将大量数据快速地导入到HBase表中。相比于逐条写入数据，BulkLoad可以减少网络传输、HBase服务端处理和数据文件写入的开销，从而提高数据导入的速度。 BulkLoad的实现方式是将数据先写入到一个HFile文件中，然后再将HFile文件上传到HDFS中，最后使用HBase的BulkLoad API将数据加载到HBase表中。这个过程需要以下步骤： 1. 创建HFile文件：使用HBase的HFileOutputFormat工具类可以创建一个HFile文件，将数据写入到该文件中。 2. 将HFile文件上传到HDFS：使用Hadoop的hdfs命令或者Java API将HFile文件上传到HDFS中。 3. 加载HFile文件到HBase表中：使用HBase的BulkLoad API将HFile文件加载到HBase表中。 BulkLoad的优点是可以快速地导入大量数据，但是需要注意以下几点： 1. BulkLoad需要手动编写代码实现，需要一定的编程技能。 2. BulkLoad需要将数据写入到HFile文件中，如果数据量太大可能会导致HFile文件过大，需要考虑分片等优化策略。 3. BulkLoad需要将HFile文件上传到HDFS中，如果网络传输较慢可能会影响导入速度。 总之，BulkLoad是一种高效的数据导入方式，可以加快大量数据的导入速度，但需要注意数据量、网络传输等因素对导入速度的影响。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值