Kafka中利用自定义序列化器收发消息

最新推荐文章于 2023-12-18 14:15:28 发布
最新推荐文章于 2023-12-18 14:15:28 发布
阅读量357 收藏 1
点赞数
分类专栏： BigData
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jerseywwwwei/article/details/103672008
版权

Kafka中利用自定义序列化器收发消息

序列化器

  • Kafka中，自带的序列化器有 int、short、long、float、double、String 、byte[]等数据类型，但这种序列化器很难满足复杂数据的收发需求，如发送一个商户的数据，数据中包含user_id,age_range,gender,merchant_id,label等信息，数据如下所示，此时就需要自定义序列化器

    user_id,age_range,gender,merchant_id,label
163968,0,0,4378,-1
163968,0,0,2300,-1
163968,0,0,1551,-1
163968,0,0,4343,-1
163968,0,0,4911,-1
163968,0,0,4043,-1
163968,0,0,2138,-1

准备工作

  • 将对象序列化字节流的包我们选择fastjson，在pox.xml中添加fastjson和kafka依赖

    		<dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka_2.12</artifactId>
            <version>0.11.0.3</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.62</version>
        </dependency>

  • 创建Person类

    package streaming.kafka.bean;

/**
 * \* project: SparkStudy
 * \* package: streaming.kafka.bean
 * \* author: Willi Wei
 * \* date: 2019-12-23 15:11:49
 * \* description:
 * \
 */
public class Person {
    private String userId;
    private String ageRange;
    private String gender;
    private String merchantId;
    private String label;

    public Person() {
    }

    public Person(String userId, String ageRange, String gender, String merchantId, String label) {
        this.userId = userId;
        this.ageRange = ageRange;
        this.gender = gender;
        this.merchantId = merchantId;
        this.label = label;
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public String getAgeRange() {
        return ageRange;
    }

    public void setAgeRange(String ageRange) {
        this.ageRange = ageRange;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getMerchantId() {
        return merchantId;
    }

    public void setMerchantId(String merchantId) {
        this.merchantId = merchantId;
    }

    public String getLabel() {
        return label;
    }

    public void setLabel(String label) {
        this.label = label;
    }

    @Override
    public String toString() {
        return "Person{" +
                "userId='" + userId + '\'' +
                ", ageRange='" + ageRange + '\'' +
                ", gender='" + gender + '\'' +
                ", merchantId='" + merchantId + '\'' +
                ", label='" + label + '\'' +
                '}';
    }
}

  • 创建序列化器和反序列化器

    package streaming.kafka.bean;

import com.alibaba.fastjson.JSON;
import org.apache.kafka.common.serialization.Serializer;

import java.util.Map;

/**
 * \* project: SparkStudy
 * \* package: streaming.kafka.bean
 * \* author: Willi Wei
 * \* date: 2019-12-23 15:22:43
 * \* description:
 * \
 */
public class PersonSerializer implements Serializer<Person> {
    public void configure(Map map, boolean b) {

    }

    public byte[] serialize(String topic, Person person) {
        return JSON.toJSONBytes(person);
    }

    public void close() {

    }
}

    package streaming.kafka.bean;
import com.alibaba.fastjson.JSON;
import org.apache.kafka.common.serialization.Deserializer;


import java.util.Map;

/**
 * \* project: SparkStudy
 * \* package: streaming.kafka.bean
 * \* author: Willi Wei
 * \* date: 2019-12-23 15:13:53
 * \* description:
 * \
 */
public class PersonDeserializer implements Deserializer<Person> {
    public void configure(Map<String, ?> map, boolean b) {

    }

    public Person deserialize(String topic, byte[] data) {
        return JSON.parseObject(data, Person.class);
    }

    public void close() {

    }
}

创建生产者和消费者

  • 创建生产者，生产者读取本地csv文件

    package streaming.kafka;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import streaming.kafka.bean.Person;

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.Properties;
import java.util.concurrent.TimeUnit;

/**
 * \* project: SparkStudy
 * \* package: streaming.kafka
 * \* author: Willi Wei
 * \* date: 2019-12-22 20:15:26
 * \* description:测试发送序列化的person数据
 * \
 */
public class JavaKafkaProducer {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers", "node02:9092,node03:9092,node04:9092");
        props.put("acks", "all");
        props.put("retries", 0);
        props.put("batch.size", 16384);
        props.put("linger.ms", 0);
        props.put("buffer.memory", 33554432);
        // key的序列化方式
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        // value的序列化方式
        props.put("value.serializer", "streaming.kafka.bean.PersonSerializer");
        KafkaProducer<String, Person> producer = new KafkaProducer<String, Person>(props);
        try {
            BufferedReader reader = new BufferedReader(new FileReader("data/test2000.csv"));
            reader.readLine();
            String line = null;
            while((line=reader.readLine())!=null){
                //CSV格式文件为逗号分隔符文件，这里根据逗号切分
                String items[] = line.split(",");
                Person person = new Person();
                person.setUserId(items[0]);
                person.setAgeRange(items[1]);
                person.setGender(items[2]);
                person.setMerchantId(items[3]);
                if (items.length == 4)
                {
                    person.setLabel("null");
                }else {
                    person.setLabel(items[4]);
                }
                producer.send(new ProducerRecord<String, Person>("topic1223",person.getUserId(), person));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        producer.close();
    }
}

  • 创建消费者

    package streaming.kafka;

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.spark.streaming.Durations;
import streaming.kafka.bean.Person;

import java.util.Arrays;
import java.util.Iterator;
import java.util.Properties;

/**
 * \* project: SparkStudy
 * \* package: streaming.kafka
 * \* author: Willi Wei
 * \* date: 2019-12-23 15:51:37
 * \* description:
 * \
 */
public class JavaKafkaConsumer {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers", "node02:9092,node03:9092,node04:9092");
        props.put("group.id", "group01");
        props.put("enable.auto.commit", "false");
        props.put("auto.offset.reset", "earliest");
        props.put("auto.commit.interval.ms", "1000");
        // key的序列化方式
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        // value的序列化方式
        props.put("value.deserializer", "streaming.kafka.bean.PersonDeserializer");
        KafkaConsumer<String, Person> consumer = new KafkaConsumer<String, Person>(props);
        consumer.subscribe(Arrays.asList("topic1223"));
        try {
            while(true){
                ConsumerRecords<String, Person> records = consumer.poll(5000);
                System.out.println("接收到的信息总数为：" + records.count());
                for (ConsumerRecord<String, Person> record : records) {
                    System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value().toString());
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

    输出为

    offset = 14107, key = 372096, value = Person{userId='372096', ageRange='0', gender='0', merchantId='4898', label='-1'}
offset = 14108, key = 372096, value = Person{userId='372096', ageRange='0', gender='0', merchantId='1405', label='-1'}
offset = 14109, key = 372096, value = Person{userId='372096', ageRange='0', gender='0', merchantId='4760', label='-1'}
offset = 14110, key = 372096, value = Person{userId='372096', ageRange='0', gender='0', merchantId='1953', label='-1'}
offset = 14111, key = 372096, value = Person{userId='372096', ageRange='0', gender='0', merchantId='1036', label='-1'}
offset = 14112, key = 372096, value = Person{userId='372096', ageRange='0', gender='0', merchantId='567', label='-1'}
offset = 14113, key = 372096, value = Person{userId='372096', ageRange='0', gender='0', merchantId='4676', label='-1'}
offset = 14114, key = 372096, value = Person{userId='372096', ageRange='0', gender='0', merchantId='1862', label='-1'}
offset = 14115, key = 372096, value = Person{userId='372096', ageRange='0', gender='0', merchantId='2674', label='-1'}
offset = 14116, key = 372096, value = Person{userId='372096', ageRange='0', gender='0', merchantId='4920', label='-1'}
offset = 14117, key = 372096, value = Person{userId='372096', ageRange='0', gender='0', merchantId='517', label='-1'}
瓜不田
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【kafka专栏】生产者客户端自定义序列化器
字母哥博客
07-01 645
kafka生产者的数据生产流程中，有三个环节是我们可以自定义的，如下图所示。本文为大家介绍如何自定义kafka生产者序列化器。
kafka - 自定义序列化器
用时间去蜕变
04-19 1857
kafka - 自定义序列化器 在 kafka 中提供了以下的序列化器： ByteArraySerializer StringSerializer IntegerSerializer 但是内置提供的序列化器并不能满足大部分场景的需求，因此我们需要自定义序列化器 一、自定义序列化器 1.1 客户 我们首先创建一个简单的类用于表示客户： public class ...
自定义kafka消息序列化
neweastsun的专栏
10-08 1609
但也提供了自定义序列化能力。为了序列化对象，需要实现org.apache.kafka.common.serialization包下的Serializer接口，类似的反序列化实现接口为Deserializer。两个接口有三个方法需要重写：configure: 用于实现配置方面的细节serialize/deserialize: 包括实际序列化和反序列化实现逻辑close: 用于关闭Kafka session本文展示了Kafka生产者如何使用序列化类通过网络发送和消费消息。
kafka5--java-自定义序列化及反序列化
二老付的博客
06-28 411
完成对序列化接口的自定义 一般在我们开发过程中我们传输的可能是一个对象，不再是单纯的String，这就要求我们能够对一个对象直接进行序列化完成传输 1.创建实体类 //必须实现Serializable接口 public class User implements Serializable { private Integer id; private String name; private Date birthDay; public User() { }
Kafka学习笔记(四)：自定义序列化器、反序列化器、分区器以及分区再均衡策略
IT-CRUD
03-12 1770
序列化器、反序列化器以及分区器都有所了解，Kafka客户端提供默认的7种方式基本够用了，但是对于一个大型复杂的项目群里面，总是会有特殊的要求，这个时候就需要自己去定义相关的序列化器和反序列化器。另外就是自定义分区器，这个应用的可能会多一点，根据实际业务将消息发送到指定的分区中。 自定义序列化器 自定的序列化器并不难，只要遵循序列化器的规矩就可以。实现Kafka提供的Serializer序列化接口，在serialize方法中写入具体序列化的实现代码即可。如下代码： //实现Serializer<T&gt
Java kafka如何实现自定义分区类和拦截器
08-19
Java Kafka 提供了强大的消息队列功能，但是在实际应用中，我们需要根据业务需求实现自定义的分区类和拦截器。本文将详细介绍如何实现自定义分区类和拦截器，并提供了详细的示例代码。 自定义分区类 在 Kafka 中，...
kafkatool消息队列可视化工具64位
06-28
**KafkaTool：一款强大的Kafka消息队列可视化工具** KafkaTool是一款专为Apache Kafka设计的64位可视化管理工具，它提供了丰富的功能，帮助用户便捷地管理和监控Kafka集群。这款工具对于理解、调试和优化Kafka消息...
kafka消息可视化查看工具
04-11
1.可用于查看kafka内的消息数据，消息的偏移量，消费分组数等信息。 2.主要用于开发调试，勿过于依赖辅助工具，命令使用才是根本。
flink-kafka 反序列化例子
最新发布
04-11
flink 的版本为 1.14.6； kafka 的版本为 kafka_2.12-2.6.3； 作为案例，介绍如何序列化 并进行相关条件判定。
kafka消息管理可视化运行软件
06-21
Kafka消息管理可视化运行软件是一种基于Java开发的工具，它为Apache Kafka提供了用户友好的图形化界面，使得管理和监控Kafka集群变得更加直观和便捷。Kafka是一个分布式流处理平台，常用于实时数据处理和大数据传输...
kafka自定义序列化器
LINBE_blazers的博客
01-22 756
在Kafka的生产者与消费者API中，生产者需要用序列化器（Serializer）把对象转换成字节数组才能通过网络发送给kafka，同时消费者也需要用反序列化器（Deserializer）把从Kafka中收到的字节数组转换转换成相应的对象。为使开发者方便地使用序列化器，Kafka自身已经封装了一个序列化器org.apache.kafka.common.serialization.StringSer...
kafka自定义序列化与反序列化
wangmate的博客
12-13 339
kafka自定义序列化与反序列化序列化对象序列化实现类producer生产者反序列化实现类consumer消费者效果图 github 地址 序列化对象 package com.oldwang.custom_serializer; import java.io.Serializable; /** * @author oldwang */ public class User implements Serializable { private int id; private String
Kafka中如何使用序列化器？
金木编程
04-09 338
对于旧程序，可以用getFaxNumber()方法获取旧值，对于新程序，可以用getEmail()方法获取新值，这样也就避免了异常或者阻断性错误，也不需要对现有数据进行大幅更新。通常不建议使用自定义序列化器，因为使用不同版本的序列化器和反序列化器会出现新旧消息的兼容性问题，特别是当消息记录中有修改字段的情况。Avro有个很好的特性，就是当负责写消息的应用程序使用了新的 schema，负责读消息的应用程序可以继续处理消息而无需做任何改动。在Kafka中，创建一个生产者对象必须指定序列化器。
kafka复习：（3）自定义序列化器和反序列化器
amadeus_liu2的博客
08-23 1225
二、自定义序列化器和反序列化器。三、定义生产者和消费者。
kafka 序列化器，分区器，拦截器，消息累加器
weixin_40954192的博客
07-13 1015
目录 拦截器 生产者拦截器 自定义生产者拦截器 序列化器 反序列化器 分区器 消息累加器 前提了解： 整个kafka生产者客户端由两条线程协调运行。 这两条线程分别为主线程和sender线程（发送线程） 主线程的作用就是：由KafkaProducer创建消息，然后通过可能的拦截器，序列化器，分区器的作用之后缓存到消息累加器 send线程的作用就是：负责将消息累加器中的消息发送到kafka中。 拦截器 拦截器是在kafka0.10.0.0版本中就已经引...
Kafka系列 - 05 Kafka生产者|消息发送方式|序列化器|分区器|拦截器|生产者配置参数
你今天真好看呀
11-26 798
不过生产者并不一定都会等到批次被填满才发送，半满的批次，甚至只包含一个消息的批次也可能被发送。所以就算把 batch.size 设置的很大，也不会造成延迟，只会占用更多的内存而已，如果设置的太小，生产者会因为频繁发送消息而增加一些额外的开销。该参数用于控制生产者发送的请求大小，它可以指定能发送的单个消息的最大值，也可以指单个请求里所有消息的总大小。broker 对可接收的消息最大值也有自己的限制（ message.max.size ），所以两边的配置最好匹配，避免生产者发送的消息被 broker 拒绝。
Kafka系列——生产者的分区，序列化，自定义拦截器以及头部信息
zekser的博客
03-18 1063
kafka的分区，序列化，自定义序列化源码示例；自定义拦截器，头部信息的作用
解析kafka topic中的数据，序列化成传输对象
java技术专家全栈成长之路
09-15 1063
/** * * * @param consumerRecordList kafka消息内容 * @return 传输对象列表 */ private List<NewsEventDTO> parse(List<ConsumerRecord<String, String>> consumerRecordList) { return consumerRecordList.stream().map(record -> JSONObject.parseO.
Kafka基础—2、Kafka 生产者API
风不归的乐园
12-18 1237
Kafka 生产者API：发送消息，消息压缩，生产者配置，分区器（Partitioner），序列化（Serializer）
kafka springboot 消费者 序列化配置
06-10
在 Spring Boot 中使用 Kafka 消费者时，需要对消息进行反序列化，将其转换为 Java 对象。Spring Boot 使用的默认序列化器是 ByteArraySerializer，如果你需要使用其他的序列化器，可以通过配置来实现。以下是使用 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值