hive：创建udf函数将多个字段转为json并推给kafka

最新推荐文章于 2024-04-11 22:56:16 发布
最新推荐文章于 2024-04-11 22:56:16 发布
阅读量2k 收藏 8
点赞数 2
分类专栏： hive 文章标签： hive udf kafka
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38750084/article/details/86097369
版权

方式1：

代码：

package com.***;

import org.apache.hadoop.hive.ql.exec.Description;
import org.apache.hadoop.hive.ql.exec.UDFArgumentException;
import org.apache.hadoop.hive.ql.metadata.HiveException;
import org.apache.hadoop.hive.ql.udf.generic.GenericUDF;
import org.apache.hadoop.hive.serde2.objectinspector.*;
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector.Category;
import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory;
import org.apache.hadoop.io.IntWritable;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

@Description(name = "hive2kafka", value = "_FUNC_(brokerhost_and_port,topic, array<map<string,string>>) - Return ret ")
public class Hive2KakfaUDF extends GenericUDF {

    private String hostAndPort;
    private String topics;
    private StandardListObjectInspector paramsListInspector;
    private StandardMapObjectInspector paramsElementInspector;

    public ObjectInspector initialize(ObjectInspector[] arg0) throws UDFArgumentException {
        if (arg0.length != 3) {
            throw new UDFArgumentException(" Expecting   two  arguments:<brokerhost:port> <topic>  array<map<string,string>> ");
        }
        // 第一个参数验证
        if (arg0[0].getCategory() == Category.PRIMITIVE
                && ((PrimitiveObjectInspector) arg0[0]).getPrimitiveCategory() == PrimitiveObjectInspector.PrimitiveCategory.STRING) {
            if (!(arg0[0] instanceof ConstantObjectInspector)) {
                throw new UDFArgumentException("broker host:port  must be constant");
            }
            ConstantObjectInspector brokerhost_and_port = (ConstantObjectInspector) arg0[0];

            hostAndPort = brokerhost_and_port.getWritableConstantValue().toString();
        }

        // 第二个参数验证
        if (arg0[1].getCategory() == Category.PRIMITIVE
                && ((PrimitiveObjectInspector) arg0[1]).getPrimitiveCategory() == PrimitiveObjectInspector.PrimitiveCategory.STRING) {
            if (!(arg0[1] instanceof ConstantObjectInspector)) {
                throw new UDFArgumentException("kafka topic must be constant");
            }
            ConstantObjectInspector topicCOI = (ConstantObjectInspector) arg0[1];

            topics = topicCOI.getWritableConstantValue().toString();
        }


        // 第三个参数验证
        if (arg0[2].getCategory() != Category.LIST) {
            throw new UDFArgumentException(" Expecting an array<map<string,string>> field as third argument ");
        }
        ListObjectInspector third = (ListObjectInspector) arg0[2];
        if (third.getListElementObjectInspector().getCategory() != Category.MAP) {
            throw new UDFArgumentException(" Expecting an array<map<string,string>> field as third argument ");
        }
        paramsListInspector = ObjectInspectorFactory.getStandardListObjectInspector(third.getListElementObjectInspector());
        paramsElementInspector = (StandardMapObjectInspector) third.getListElementObjectInspector();
        System.out.println(paramsElementInspector.getMapKeyObjectInspector().getCategory());
        System.out.println(paramsElementInspector.getMapValueObjectInspector().getCategory());

        return PrimitiveObjectInspectorFactory.writableIntObjectInspector;

    }

    public Object evaluate(DeferredObject[] arg0) throws HiveException {
        Properties props = new Properties();
        props.put("bootstrap.servers", hostAndPort);
        props.put("acks", "all");
        props.put("retries", 0);
        props.put("batch.size", 16384);
        props.put("linger.ms", 1);
        props.put("buffer.memory", 33554432);
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

        // 创建kafka生产者
        Producer<String, String> producer = new KafkaProducer<String, String>(props);

        for (int i = 0; i < paramsListInspector.getListLength(arg0[2].get()); i++) {
            Object row = paramsListInspector.getListElement(arg0[2].get(), i);
            Map<?, ?> map = paramsElementInspector.getMap(row);
            // Object obj = ObjectInspectorUtils.copyToStandardJavaObject(row,paramsElementInspector);
            // 转成标准的java map，否则里面的key value字段为hadoop writable对象
            Map<String, String> data = new HashMap<String,String>();
            for (Map.Entry<?, ?> entry : map.entrySet()) {
                if (entry.getValue() != null && !"".equals(entry.getValue().toString())) {
                    data.put(entry.getKey().toString(), entry.getValue().toString());
                }
            }

            producer.send(new ProducerRecord<String, String>(topics, Integer.toString(i), data.toString()));

        }

        producer.close();

        return new IntWritable(1);
    }

    public String getDisplayString(String[] strings) {
        return "hive2kafka(brokerhost_and_port,topic, array<map<string,string>>)";
    }
}

pom：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.***</groupId>
  <artifactId>udf_hive2kafka</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
  <dependencies>
        <dependency>
            <groupId>org.apache.hive</groupId>
            <artifactId>hive-exec</artifactId>
            <version>1.1.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-common</artifactId>
            <version>2.6.0</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
		    <groupId>jdk.tools</groupId>
		    <artifactId>jdk.tools</artifactId>
		    <version>1.8</version>
		    <scope>system</scope>
		    <systemPath>${JAVA_HOME}/lib/tools.jar</systemPath>
		</dependency>
		<dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <dependency>  
        <groupId>org.apache.kafka</groupId>  
        <artifactId>kafka_2.10</artifactId>  
        <version>0.8.2.0</version>  
    </dependency>
    </dependencies>
  <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.2</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <filters>
                                <filter>
                                    <artifact>*:*</artifact>
                                    <excludes>
                                        <exclude>META-INF/*.SF</exclude>
                                        <exclude>META-INF/*.DSA</exclude>
                                        <exclude>META-INF/*.RSA</exclude>
                                    </excludes>
                                </filter>
                            </filters>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
  
</project>

 注册udf：

add jar /var/lib/hadoop-hdfs/spride_sqoop_beijing/udf_jar/udf_hive2kafka-0.0.1-SNAPSHOT.jar;
create temporary function udf_hive2kafka as 'cn.***.Hive2KakfaUDF';

执行sql即可导入kafka：

SELECT
    udf_hive2kafka( 'localhostname:9092', 'topicname', 
    collect_list(map(
    'p_name',p_name,
    'request_url', request_url,
    'com_fullname',com_fullname,
    'edu_require',edu_require,
    'exp_require',exp_require,
    'city',city,
    'source',source,
    'release_time',release_time,
    'update_time',update_time,
    'salary_month',salary_month,
    'salary_max',salary_max,
    'salary_min',salary_min,
    'statement',statement,
    'bo_id',bo_id,
    'insert_time',insert_time,
    'com_id',com_id,
    'com_simplename',com_simplename,
    'position_id',position_id,
    'jobnature',jobnature,
    'recruits_number',recruits_number,
    'address',address,
    'welfare',welfare,
    'status',status
    
    )) ) AS result
FROM
     (
        SELECT
           *
        FROM
            dws_bo_final_spider_position001 limit 10
        ) a;   

 

有的hive版本不支持collect_list()函数，则可以使以下方式推送kafka：

方式2：

package test;

import com.alibaba.fastjson.JSON;
import org.apache.hadoop.hive.ql.exec.UDF;
import com.alibaba.fastjson.JSONObject;

import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

import kafka.javaapi.producer.Producer;
import kafka.producer.KeyedMessage;
import kafka.producer.ProducerConfig;
import kafka.serializer.StringEncoder;

/**
 * Created by tang on 2019/01/07
 *
 * 创建临时udf函数：
 * add jar /usr/local/udf_hive2kafka-0.0.1-SNAPSHOT.jar;
 * create temporary function udf_hive2kafka1 as 'test.HiveToKakfaUDF';
 * 创建永久udf函数：
 * CREATE FUNCTION udf_hive2kafka  AS 'com.tzb.Hive2KakfaUDF'
 *  USING JAR 'hdfs:///user/hive/warehouse/ods.db/udf_jar/udf_hive2kafka-0.0.1-SNAPSHOT.jar';
 * 传hdfs：
 *  hadoop fs -put /var/lib/hadoop-hdfs/spride_sqoop_beijing/udf_jar/udf_hive2kafka-0.0.1-SNAPSHOT.jar /user/hive/warehouse/ods.db/udf_jar/udf_hive2kafka-0.0.1-SNAPSHOT.jar
 *
 *
 * 执行语句：
 * select udf_hive2kafka1('10.21.0.210:2181','10.21.0.210:9092','sparkkafka',map('full_name', full_name,'mobile_phone',mobile_phone,'email',email))  from dws.dws_bo_final_spider_contact limit 10;
 */
public class HiveToKakfaUDF extends UDF {


    public String evaluate(String zklis, String brokerlis, String topic,Map<String,String> map) {
        Producer producer = createProducer(zklis, brokerlis);
        String jsonData = JSON.toJSONString(map);
        producer.send(new KeyedMessage<Integer, String>(topic,jsonData));
        return jsonData;
    }

    private static Producer createProducer(String zklis, String brokerlis) {
        Properties properties = new Properties();
        properties.put("zookeeper.connect", zklis);//声明zk  多个ip逗号分隔
        properties.put("serializer.class", StringEncoder.class.getName());
        properties.put("metadata.broker.list", brokerlis);// 声明kafka broker
        return new Producer<Integer, String>(new ProducerConfig(properties));
    }
}

pom：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.huayong</groupId>
  <artifactId>udf_hive2kafka</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
  <dependencies>
        <dependency>
            <groupId>org.apache.hive</groupId>
            <artifactId>hive-exec</artifactId>
            <version>1.1.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-common</artifactId>
            <version>2.6.0</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
		    <groupId>jdk.tools</groupId>
		    <artifactId>jdk.tools</artifactId>
		    <version>1.8</version>
		    <scope>system</scope>
		    <systemPath>${JAVA_HOME}/lib/tools.jar</systemPath>
		</dependency>
		<dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <dependency>  
        <groupId>org.apache.kafka</groupId>  
        <artifactId>kafka_2.10</artifactId>  
        <version>0.8.2.0</version>  
    </dependency>
    <dependency>
          <groupId>com.alibaba</groupId>
          <artifactId>fastjson</artifactId>
          <version>1.2.46</version>
      </dependency>
      <dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <version>20160212</version>
</dependency>
<dependency>
         <groupId>org.apache.poi</groupId>
         <artifactId>poi</artifactId>
        <version>3.10-FINAL</version>
    </dependency>
    <dependency>
         <groupId>org.apache.poi</groupId>
        <artifactId>poi-ooxml</artifactId>
        <version>3.10-FINAL</version>
    </dependency>
    </dependencies>
  <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.2</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <filters>
                                <filter>
                                    <artifact>*:*</artifact>
                                    <excludes>
                                        <exclude>META-INF/*.SF</exclude>
                                        <exclude>META-INF/*.DSA</exclude>
                                        <exclude>META-INF/*.RSA</exclude>
                                    </excludes>
                                </filter>
                            </filters>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
  
</project>

 

花和尚也有春天
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
数仓工具—Hive实战之UDF 复杂JSON 处理(21)
04-03 3万+
UDF 复杂JSON 处理 这个的背景和我们前面的复杂JSON 处理是一样的，起源于我们将数据推送到ES ,不然的话我们直接存储字符串，然后使用hive 提供的json 解析函数处理就好了。 阅读之前建议你阅读： [ Hive语法之json 解析](https://blog.csdn.net/king14bhhb/article/details/111999201) ​ Hive语法之复杂json解析处理 ​ Hive集成篇之ES 方便你了解这个背景，以及我们为什么要这么做，我们在复杂js
Hive自定义函数实现Json数据解析UDF开发（作业）
黄道婆的专栏
10-04 812
参考文章：https://www.pianshen.com/article/931082274/ 我做的工作：完全照猫画虎，一步步操作下来，写出完整的代码。 Json数据解析UDF开发（作业） 作业： 有原始json数据如下： {"movie":"1193","rate":"5","timeStamp":"978300760","uid":"1"} {"movie":"661","rate":"3","timeStamp":"978302109","uid":"1"} ...
使用hive UDF格式化Linux字符串成json对象
如果能思维清晰，从上往下，不断深入，就好了~~~
12-24 651
回顾项目中一个小部分，通过表字段名与字段值生成json对象，这个json对象通过表中的另一个字段查询 package com.tl.g3.hive.udf; import org.apache.hadoop.hive.ql.exec.UDF; import com.alibaba.fastjson.JSONObject; public class JsonFormatUDF extends...
自定义UDF函数将字段值转为json格式
weixin_42258633的博客
05-16 335
创建一个UDF函数 功能：把表中的前5个字段名称和字段值拼接成一个json字符串输出
hive解析json_hive json解析函数
2401_84182073的博客
04-11 1085
发知识点，真正体系化！**
通过Flume简单实现Kafka与Hive对接（Json格式）
栗筝i的博客
06-29 2945
将以下存储在kafka的topic中的JSON格式字符串，对接存储到Hive的表中 {"id":1,"name":"小李"} {"id":2,"name":"小张"} {"id":3,"name":"小刘"} {"id":4,"name":"小王"} 1、在hive/conf/hive-site.xml中添加或修改如下内容： <property> <name>hive.txn.manager</name> <value>org.a
HiveUDF:Apache Hive UDF（用户定义函数）
07-01
Hive UDF UDF 聚合 UDF Finds MIN, MAX and SUM from array of Struct Objects based on a field. 排序 UDF Returns sorted array of Struct objects for an array of Struct Objects based on a field. 日期 ...
编译hive源码-UDF函数
01-20
文章目录hive源码下载地址解压源码包配置pom文件编辑源码编辑UDF函数注册UDF函数编译hive部署编译后的hive包1. 重新部署hive2. 修改原hive hive源码下载地址 hive版本：hive-1.1.0-cdh5.7.0 百度网盘：链接：...
HIVE自定义UDF函数
最新发布
05-11
而自定义用户定义函数（UDF）是 Hive 中的一个重要功能，允许用户根据自己的需求编写自定义函数，以便在 Hive 查询中使用。 如何在 Hive 中创建自定义 UDF 函数： 步骤一：编写 Java 程序 首先，您需要编写一个 ...
hive-udf:hive自定义函数
05-18
hive-udfhive自定义函数主要实现hive3种自定义函数1，udf函数，主要用于处理一对一数据处理2，udtf函数，主要用于处理一对多数据处理2，udaf函数，主要用与处理多对一数据聚合处理
hive自定义UDF编写函数.docx
01-26
hive的udf函数实现
HiveKa:Kafka 作为 Hive 存储
07-13
Kafka 的 Hive 存储处理程序 HiveKa 是 Apache Hive 的存储处理程序，它在 Apache Hive 中添加了从 Apache Kafka 查询数据的支持。 这为 Kafka 用户提供了一个机会来检查 Kafka 摄取的数据，而无需编写复杂的 Kafka 消费者。 Hive 使跨各种数据源（如 HDFS、Solr、Hbase 等）运行复杂的分析查询成为可能。HiveKa 将此支持扩展到 Kafka。 访问我们的。 要在 Hive 中创建 Kafka 表，请运行： create external table test_kafka (a int, b string) stored by 'org.apache.hadoop.hive.kafka.KafkaStorageHandler' tblproperties('kafka.service.uri'='hi
Hive 处理 json 数据
程序员小陶的大数据分享
04-21 349
两种方式 1、将json以字符串的方式整个入Hive表，然后通过使用UDF函数解析已经导入到hive中的数据，比如使用LATERAL VIEW json_tuple的方法，获取所需要的列名。 2、在导入之前将json拆成各个字段，导入Hive表的数据是已经解析过得。这将需要使用第三方的SerDe。 测试数据 测试数据为新浪微博的评论数据，格式如下： { "appCode": "weibo", ...
hive-udf正常数据转化为json形式(二)
huobumingbai1234的博客
10-08 1856
之前都是手动拼字符串写的，优点是灵活，缺点也很明显，容易出错。 下面提供一种udf的形式： package udf; import com.aliyun.odps.udf.UDF; public class TableBulidJson extends UDF { public String evaluate(String ... params) { if (params == null || params.length == 0 || params.length % 2
Kafka JSON格式转换
weixin_45922185的博客
11-30 2344
源数据格式： { "funcName": "test", "data": { "snapshots": [{ "content_type": "application/x-gzip-compressed-jpeg", "url": "https://blog.csdn.net/xianpanjia4616" }], "audio": [{ "content_type": "audio/wav", "url": " https:/
Hive 自定义函数 UDF UDAF UDTF
starzy
02-21 354
Hive 自定义函数 UDF UDTF UDAF UDF函数 UDF：用户定义（普通）函数，只对单行数值产生作用；UDF只能实现一进一出的操作。UDF函数自定义实现步骤如下： 定义UDF函数，如计算两个数之和 package com.starzy.udf; import org.apache.hadoop.hive.ql.exec.UDF; public class UDFDemo extends UDF { // 自定义函数实现逻辑，重载evaluate public String
flume接kafka数据入hive（亲测好用）
song_quan_的博客
12-17 1828
0x01 需求背景 将Kafka中的JSON数据持久化存储到Hive表中，以供后期有查找的需求。 （看了很多讲解的博文，出了各种bug！饶了很多弯路！总结出来的经验就是一定要仔细看Flume的官方文档！！！！！！） Kafka中的数据示例： >{"id":1,"name":"snowty","age":25} Hive表示例： hive> desc hivetable; OK id int ...
hive-udf-kafka批量数据导入kafka
qq_43048011的博客
01-14 2343
背景:数据存在hive中,现在需要将数据导入kafka中,为了减少中间环节,使用自定义UDF将hive数据导入到kafka中 问题:UDF时对一行的处理,批量导入就会涉及多行的问题,怎么将多行数据放到一个udf中? 解决思路:用collect_list函数将多行转成集合,在udf中循环遍历,发送到kafka 代码 package cn.kobold; import org.apache...
hive创建udf自定义函数
08-04
在Hive中创建UDF自定义函数有两种方式：创建临时函数和创建永久函数。 1. 创建临时函数：使用CREATE TEMPORARY FUNCTION语句来创建临时函数。例如，创建一个名为myudf的临时函数，指定函数的实现类为...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值