【代码入门】kafka基础（4）：hello kafka：模拟kafka的生产、消费以及拓展

roman_日积跬步-终至千里

已于 2022-10-08 20:16:52 修改

阅读量715

点赞数

分类专栏： # kafka 文章标签： java kafka intellij-idea

于 2022-08-29 22:09:28 首次发布

本文链接：https://blog.csdn.net/hiliang521/article/details/126593517

版权

kafka 专栏收录该内容

6 篇文章 2 订阅

订阅专栏

文章目录

一. 依赖
- 1. kafka依赖
- 2. 日志系统
二. 生产者消费者代码
三. 生产消费拓展

实际工作中，有时需要将生产者和消费者的功能集成到已有的系统中，此时需要写代码实现生产者和消费者的逻辑。

一. 依赖

1. kafka依赖

        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <version>2.4.1</version>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-api</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.74</version>
        </dependency>

2. 日志系统

添加日志依赖

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.10</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.10</version>
</dependency>

将log4j.properties添加到resources目录中

log4j.rootLogger=info,stdout

log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} [%t] [%c] [%p] - %m%n

二. 生产者消费者代码

1.生产者代码

package com.gao.kafka;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;

/**
 * 需求：Java代码实现生产者代码
 */
public class ProducerDemo {
    private final static String TOPIC_NAME = "hello";//指定topic
    public static void main(String[] args) {
        //配置produce的参数
        Properties prop = new Properties();
        prop.put("bootstrap.servers", "hadoop01:9092,hadoop02:9092,hadopp03:9092"); //指定kafka的broker地址
        prop.put("key.serializer", StringSerializer.class.getName());  //指定key数据的序列化格式
        prop.put("value.serializer", StringSerializer.class.getName());  //指定value数据的序列化格式
        //创建kafka生产者
        KafkaProducer<String, String> producer = new KafkaProducer<String, String>(prop);
        producer.send(new ProducerRecord<String, String>(TOPIC_NAME, "hello kafka"));        //向topic中生产数据
        //关闭链接
        producer.close();
    }
}

2. 消费者代码

package com.gao.kafka;


import java.time.Duration;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Properties;

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.common.serialization.StringDeserializer;

/**
 * 需求：Java代码实现消费者代码
 */
public class ConsumerDemo {
    public static void main(String[] args) {
        //配置参数
        Properties prop = new Properties();
        prop.put("bootstrap.servers", "hadoop01:9092,hadoop02:9092,hadoop03:9092");  //指定kafka的broker地址
        prop.put("key.deserializer", StringDeserializer.class.getName());        //指定key-value的反序列化类型
        prop.put("value.deserializer", StringDeserializer.class.getName());
        prop.put("group.id", "con-1");        //指定消费者组
        //创建消费者
        KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(prop);
        Collection<String> topics = new ArrayList<String>();
        topics.add("hello");
        consumer.subscribe(topics); //订阅指定的topic
        //消费数据
        while (true) {
            ConsumerRecords<String, String> poll = consumer.poll(Duration.ofSeconds(1));//【注意：需要修改jdk编译级别为1.8，否则Duration.ofSeconds(1)会语法报错】
            for (ConsumerRecord<String, String> consumerRecord : poll) {
                System.out.println(consumerRecord);
            }
        }
    }
}

在执行代码之前需要注意：
1、因为本地要连接kafka服务器，所以需要关闭所有服务器的防火墙
2、需要修改本地的hosts文件，即各个kafka服务节点ip和hostname的映射关系。

3. 执行

先开启生产者，再开启消费者（莫名感觉有点像socket的感觉？）。

ConsumerRecord(topic = hello, partition = 0, leaderEpoch = 0, offset = 1, 
CreateTime = 1609129293073, serialized key size = -1, serialized value size = 11, 
headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = hello kafka)

三. 生产消费拓展

1. 生产者：生产格式更复杂的数据

package com.gao.kafka;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.StringSerializer;

import java.math.BigInteger;
import java.util.Calendar;
import java.util.Properties;

/**
 * 根据需求创建指定格式的event
 */
public class KafkaProducerRoman {
    public static void main(String[] args) throws InterruptedException {
        //参数配置：
        Properties props = new Properties();
        //server列表
        props.put("bootstrap.servers", "localhost:9092");
        //key，value支持序列化
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

        //创建生产者
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(props);
        String topic1 = "topic_gao-in";
        while (true) {
            //将对象转为json数据
            String jsonString = JSONObject.toJSONString(getObject(), SerializerFeature.WriteMapNullValue);


            //生成数据
            ProducerRecord<String, String> infos = new ProducerRecord<String, String>(topic1, jsonString);
            //发送数据
            kafkaProducer.send(infos);
            System.out.println(jsonString);
            Thread.sleep(1000);
        }
    }

    //自己手写格式
    static String getPipelineString() {
        return "{\n" +
                "  \"_cw_kafka_offset\": 2942767974,\n" +
                "  \"_cw_kafka_partition\": 0,\n" +
                "  \"log_time\": \"05-30 15:53:01\",\n" +
                "  \"logFlag\": \"#*#xtraceBiz\",\n" +
                "  \"trace_id\": \"000000\",\n" +
                "  \"span_id\": \"000000.i\",\n" +
                "  \"parent_span_id\": \"000000\",\n" +
                "  \"service_id\": \"CBS\",\n" +
                "  \"service_instance_id\": \"10.0.243.240\",\n" +
                "  \"endpoint_id\": \"clCNAPWZ\",\n" +
                "  \"tags\": {\n" +
                "    \"exceptionType\": \"\",\n" +
                "    \"localProcess\": \"56689446\",\n" +
                "    \"traceState\": \"\",\n" +
                "    \"traceNameID\": \"\",\n" +
                "    \"result_code\": \"999998\",\n" +
                "    \"bizID\": \"aSsJYYPIncO#I51sKD5fwdo\",\n" +
                "    \"localServiceName\": \"clCNAPWZ\",\n" +
                "    \"message\": \"\"\n" +
                "  },\n" +
                "  \"logs\": \"\",\n" +
                "  \"trace_group\": \"\",\n" +
                "  \"start_time\": 1653897181142,\n" +
                "  \"end_time\": 1653897181166,\n" +
                "  \"duration\": 24.0\n" +
                "}";
    }


    /**
     * 简单的数据
     *
     * @return
     */
    public static JSONObject getObject() {
        JSONObject stuff = new JSONObject();
//        int age = (int) (Math.random() * 10) + 5;
        String age = "12345678910";
        stuff.put("id", age);

        return stuff;
    }


    /**
     * 嵌套格式的对象json
     */
    public static JSONObject getObjectJson() {
        //JSONObject jsonObjectResult = new JSONObject();//用于存储数据
        long timeInMillis = Calendar.getInstance().getTimeInMillis();

        JSONObject stuff = new JSONObject();
        //int i = new Random().nextInt();
        stuff.put("id", 1);
        stuff.put("name", "张三");
        JSONObject depart = new JSONObject();
        depart.put("d_id", timeInMillis);
        depart.put("d_name", "技术一部");
        stuff.put("department", depart);
        //jsonObjectResult.put("data", stuff);

        //row.array
        JSONObject messageObject = new JSONObject();
        JSONArray message = new JSONArray();

        message.add(timeInMillis);
        message.add(timeInMillis + 1);
        message.add(timeInMillis + 2);
        messageObject.put("message", message);
        stuff.put("messageObject", messageObject);

        //array
        JSONArray personalMessage = new JSONArray();
        personalMessage.add(timeInMillis);
        stuff.put("personalMessage", personalMessage);

        return stuff;
    }
}

2. 消费者拓展

2.1. 三种消费逻辑

kafka消费数据的流程是这样的

先根据group.id指定的消费者组到kafka中查找"之前"保存的offset信息

如果查找到了，说明之前使用这个消费者组消费过数据，则根据之前保存的offset继续进行消费
如果没查找到(说明第一次消费)，或者查找到了，但是查找到的那个offset对应的数据已经不存在了

这个时候消费者该如何消费数据？

会根据auto.offset.reset的值执行不同的消费逻辑

earliest：表示从最早的数据开始消费(从头消费)
latest【默认】：表示从最新的数据开始消费
none：如果根据指定的group.id没有找到之前消费的offset信息，就会抛异常

设置
从最新消费

//开启自动提交offset功能，默认就是开启的
prop.put("enable.auto.commit","true");
//自动提交offset的时间间隔，单位是毫秒
prop.put("auto.commit.interval.ms","5000");
这个参数只有在消费者第一次消费数据，或者之前保存的offset信息已过期的情况下才会生效
prop.put("auto.offset.reset","latest");

从最早消费

prop.put("group.id", "con-2");//修改值，相当于一个新的消费者。
prop.put("auto.offset.reset","earliest");//从最早的数据开始消费

2.2. 三种消费语义

分区与乱序现象：

当一个消费者消费一个partition时，消费数据的顺序和此分区数据的生产顺序是一致的
当一个消费者消费多个partition时，消费者按照partition的顺序，首先消费一个partition，当消费完一个分区最新的数据之后再消费其他分区的数据。但只能保证消费的数据顺序在一个分区内是有序的。也就是说，分区之间的数据是无序的。

三种语义：

至少一次：at-least-once

可能会对数据重复处理

//禁止自动提交offset
enable.auto.commit=false
//消息处理完之后手动调用，提交offset
consumer.commitSync()

处理多次的场景是：

消费者的消息处理完，但是offset还没有提交，这个时候消费者挂掉了（还没执行异步提交），在重启的时候会重新消费消息。

至多一次：at-most-once

可能会丢失数据，kafka消费者的默认实现。
配置：

enable.auto.commit=true
//kafka会有一个独立的线程负责按照指定间隔提交offset
auto.commit.interval.ms="较低的时间范围"

丢数据场景

消费者的offset已经提交，但是消息还在处理中，这个时候程序挂了，导致数据没有处理成功，在重启的时候会从上次提交的offset处消费，导致上次没有被成功处理的消息就丢失了。

仅一次：exactly-once

保证数据只被消费一次
实现：处理消息时，同时保存每个消息的offset。以原子事务的方式保存offset和处理的消息结果。

enable.auto.commit=false
##来指定offset
consumer.seek(topicPartition,offset)

相当于自己保存offset信息，把offset和具体的数据绑定到一块，数据真正处理成功的时候才会保存offset消息。
这样数据就保证置被消费一次。