kafka java producer consumer实践

最新推荐文章于 2022-05-06 16:58:21 发布
最新推荐文章于 2022-05-06 16:58:21 发布
阅读量85 收藏
点赞数
文章标签： 大数据 java
原文链接：http://www.cnblogs.com/huayu0815/p/5359722.html
版权

java提供了方便的API进行kafka消息处理。简单总结一下：

学习参考：http://www.itnose.net/st/6095038.html

POM配置（关于LOG4J的配置参看 http://www.cnblogs.com/huayu0815/p/5341712.html）

<dependencies>
      <dependency>
          <groupId>org.apache.kafka</groupId>
          <artifactId>kafka_2.10</artifactId>
          <version>0.8.2.0</version>
          <exclusions>
              <exclusion>
                  <groupId>log4j</groupId>
                  <artifactId>log4j</artifactId>
              </exclusion>
              <exclusion>
                  <groupId>org.slf4j</groupId>
                  <artifactId>slf4j-log4j12</artifactId>
              </exclusion>
          </exclusions>
      </dependency>
      <dependency>
          <groupId>ch.qos.logback</groupId>
          <artifactId>logback-core</artifactId>
          <version>1.1.2</version>
      </dependency>
      <dependency>
          <groupId>ch.qos.logback</groupId>
          <artifactId>logback-access</artifactId>
          <version>1.1.2</version>
      </dependency>
      <dependency>
          <groupId>ch.qos.logback</groupId>
          <artifactId>logback-classic</artifactId>
          <version>1.1.2</version>
      </dependency>
      <dependency>
          <groupId>org.slf4j</groupId>
          <artifactId>log4j-over-slf4j</artifactId>
          <version>1.7.7</version>
      </dependency>
  </dependencies>

　　

PRODUCER

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

import java.util.Properties;

public class KafkaProducer {

    Producer<String, String> producer ;


    /*#指定kafka节点列表，用于获取metadata，不必全部指定
    metadata.broker.list=192.168.2.105:9092,192.168.2.106:9092
            # 指定分区处理类。默认kafka.producer.DefaultPartitioner，表通过key哈希到对应分区
    #partitioner.class=com.meituan.mafka.client.producer.CustomizePartitioner

    # 是否压缩，默认0表示不压缩，1表示用gzip压缩，2表示用snappy压缩。压缩后消息中会有头来指明消息压缩类型，故在消费者端消息解压是透明的无需指定。
    compression.codec=none

    # 指定序列化处理类(mafka client API调用说明-->3.序列化约定wiki)，默认为kafka.serializer.DefaultEncoder,即byte[]
    serializer.class=com.meituan.mafka.client.codec.MafkaMessageEncoder
    # serializer.class=kafka.serializer.DefaultEncoder
    # serializer.class=kafka.serializer.StringEncoder
    # 如果要压缩消息，这里指定哪些topic要压缩消息，默认empty，表示不压缩。
            #compressed.topics=

            ########### request ack ###############
            # producer接收消息ack的时机.默认为0.
    # 0: producer不会等待broker发送ack
    # 1: 当leader接收到消息之后发送ack
    # 2: 当所有的follower都同步消息成功后发送ack.
            request.required.acks=0
            # 在向producer发送ack之前,broker允许等待的最大时间
    # 如果超时,broker将会向producer发送一个error ACK.意味着上一次消息因为某种
    # 原因未能成功(比如follower未能同步成功)
    request.timeout.ms=10000
            ########## end #####################


            # 同步还是异步发送消息，默认“sync”表同步，"async"表异步。异步可以提高发送吞吐量,
            # 也意味着消息将会在本地buffer中,并适时批量发送，但是也可能导致丢失未发送过去的消息
    producer.type=sync
    ############## 异步发送 (以下四个异步参数可选) ####################
            # 在async模式下,当message被缓存的时间超过此值后,将会批量发送给broker,默认为5000ms
    # 此值和batch.num.messages协同工作.
            queue.buffering.max.ms = 5000
            # 在async模式下,producer端允许buffer的最大消息量
    # 无论如何,producer都无法尽快的将消息发送给broker,从而导致消息在producer端大量沉积
    # 此时,如果消息的条数达到阀值,将会导致producer端阻塞或者消息被抛弃，默认为10000
    queue.buffering.max.messages=20000
            # 如果是异步，指定每次批量发送数据量，默认为200
    batch.num.messages=500
            # 当消息在producer端沉积的条数达到"queue.buffering.max.meesages"后
    # 阻塞一定时间后,队列仍然没有enqueue(producer仍然没有发送出任何消息)
    # 此时producer可以继续阻塞或者将消息抛弃,此timeout值用于控制"阻塞"的时间
    # -1: 无阻塞超时限制,消息不会被抛弃
    # 0:立即清空队列,消息被抛弃
    queue.enqueue.timeout.ms=-1
            ################ end ###############

            # 当producer接收到error ACK,或者没有接收到ACK时,允许消息重发的次数
    # 因为broker并没有完整的机制来避免消息重复,所以当网络异常时(比如ACK丢失)
    # 有可能导致broker接收到重复的消息,默认值为3.
            message.send.max.retries=3


            # producer刷新topic metada的时间间隔,producer需要知道partition leader的位置,以及当前topic的情况
    # 因此producer需要一个机制来获取最新的metadata,当producer遇到特定错误时,将会立即刷新
    # (比如topic失效,partition丢失,leader失效等),此外也可以通过此参数来配置额外的刷新机制，默认值600000
    topic.metadata.refresh.interval.ms=60000*/

    public Producer<String, String> getClient() {
        if (producer == null) {
            Properties props = new Properties() ;
            //此处配置的是kafka的端口
            props.put("metadata.broker.list", "xxx.xxx.xxx.xxx:9092");

            //配置value的序列化类
            props.put("serializer.class", "kafka.serializer.StringEncoder");
            props.put("producer.type", "async");
            //配置key的序列化类
            props.put("key.serializer.class", "kafka.serializer.StringEncoder");
            props.put("request.required.acks", "0");
            ProducerConfig config = new ProducerConfig(props) ;
            producer = new Producer<>(config) ;
        }
        return producer ;
    }

    public void shutdown(){
        if (producer != null) {
            producer.close();
        }
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        KafkaProducer kafkaProducer = new KafkaProducer() ;
        for (int i=0 ; i< 10; i ++) {
            kafkaProducer.getClient().send(new KeyedMessage<String, String>("topic1","topic1_" + i + "_测试"));
            kafkaProducer.getClient().send(new KeyedMessage<String, String>("topic2","topic2_" + i + "_测试"));
        }
        kafkaProducer.shutdown();
    }
}

　总结：

1、producer每次new的时候，会自动创建线程池

2、producer在调用send方法时候，才会真正建立socket连接。

　　连接过程如下：

　　1>、通过metadata.broker.list获取对应的brokers全量信息（metadata.broker.list给的broker的ip和端口只要保证一个是可用的即可，无需全部列出。不过开发过程中，一般全部列出）。

      2>、根据zookeeper的注册信息获取topic的分区信息

　　3>、建立client和broker的socket连接

3、send结束后，直接关闭socket连接。

4、每次send会重新建立连接

5、client会自动获取topic的分区信息，因此kafka rebalance的时候，是不受影响的

 

CONSUMER

consumer api官方有两种，一般称为：high-level Consumer API 和 SimpleConsumer API 。

第一种高度抽象的Consumer API，它使用起来简单、方便，但是对于某些特殊的需求我们可能要用到第二种更底层的API，先简单介绍下第二种API能够帮助我们做哪些事情
  • 一个消息读取多次
  • 在一个处理过程中只消费Partition其中的一部分消息
  • 添加事务管理机制以保证消息被处理且仅被处理一次

　　使用第二种的弊端：

  • 必须在程序中跟踪offset值
  • 必须找出指定Topic Partition中的lead broker
  • 必须处理broker的变动

我主要尝试了一下第一种也是大多数情况下使用的API。

使用high-level Consumer api，有两种用法：单个消费者和多个消费者

单消费者：

import kafka.consumer.ConsumerConfig;
import kafka.consumer.ConsumerIterator;
import kafka.consumer.KafkaStream;
import kafka.javaapi.consumer.ConsumerConnector;

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

public class KafkaSingleConsumer {

    /**
     * # zookeeper连接服务器地址，此处为线下测试环境配置(kafka消息服务-->kafka broker集群线上部署环境wiki)
     # 配置例子："127.0.0.1:3000,127.0.0.1:3001,127.0.0.1:3002"
     zookeeper.connect=192.168.2.225:2181,192.168.2.225:2182,192.168.2.225:2183/config/mobile/mq/mafka
     # zookeeper的session过期时间，默认5000ms，用于检测消费者是否挂掉，当消费者挂掉，其他消费者要等该指定时间才能检查到并且触发重新负载均衡
     zookeeper.session.timeout.ms=5000
     zookeeper.connection.timeout.ms=10000
     # 指定多久消费者更新offset到zookeeper中。注意offset更新时基于time而不是每次获得的消息。一旦在更新zookeeper发生异常并重启，将可能拿到已拿到过的消息
     zookeeper.sync.time.ms=2000

     #指定消费组
     group.id=xxx
     # 当consumer消费一定量的消息之后,将会自动向zookeeper提交offset信息
     # 注意offset信息并不是每消费一次消息就向zk提交一次,而是现在本地保存(内存),并定期提交,默认为true
     auto.commit.enable=true
     # 自动更新时间。默认60 * 1000
     auto.commit.interval.ms=1000

     # 当前consumer的标识,可以设定,也可以有系统生成,主要用来跟踪消息消费情况,便于观察
     conusmer.id=xxx

     # 消费者客户端编号，用于区分不同客户端，默认客户端程序自动产生
     client.id=xxxx
     # 最大取多少块缓存到消费者(默认10)
     queued.max.message.chunks=50
     # 当有新的consumer加入到group时,将会reblance,此后将会有partitions的消费端迁移到新
     # 的consumer上,如果一个consumer获得了某个partition的消费权限,那么它将会向zk注册
     # "Partition Owner registry"节点信息,但是有可能此时旧的consumer尚没有释放此节点,
     # 此值用于控制,注册节点的重试次数.
     rebalance.max.retries=5
     # 获取消息的最大尺寸,broker不会像consumer输出大于此值的消息chunk
     # 每次feth将得到多条消息,此值为总大小,提升此值,将会消耗更多的consumer端内存
     fetch.min.bytes=6553600
     # 当消息的尺寸不足时,server阻塞的时间,如果超时,消息将立即发送给consumer
     fetch.wait.max.ms=5000
     socket.receive.buffer.bytes=655360

     # 如果zookeeper没有offset值或offset值超出范围。那么就给个初始的offset。有smallest、largest、
     # anything可选，分别表示给当前最小的offset、当前最大的offset、抛异常。默认largest
     auto.offset.reset=smallest
     # 指定序列化处理类(mafka client API调用说明-->3.序列化约定wiki)，默认为kafka.serializer.DefaultDecoder,即byte[]
     derializer.class=com.meituan.mafka.client.codec.MafkaMessageDecoder
     */

    public static void main(String args[]) {
        String topic = "topic1" ;
        Properties props = new Properties();
        props.put("zookeeper.connect", "xxx.xxx.xxx:2181");
        props.put("group.id", "testgroup");
        props.put("zookeeper.session.timeout.ms", "500");
        props.put("zookeeper.sync.time.ms", "250");
        props.put("auto.commit.interval.ms", "1000");
        ConsumerConfig config = new ConsumerConfig(props);
        ConsumerConnector consumer = kafka.consumer.Consumer.createJavaConsumerConnector(config) ;

        Map<String, Integer> topicMap = new HashMap<>();
        // Define single thread for topic
        topicMap.put(topic, new Integer(1));
        Map<String, List<KafkaStream<byte[], byte[]>>> consumerStreamsMap = consumer.createMessageStreams(topicMap);
        List<KafkaStream<byte[], byte[]>> streamList = consumerStreamsMap.get(topic);
        for (KafkaStream<byte[], byte[]> stream : streamList) {
            ConsumerIterator<byte[], byte[]> consumerIte = stream.iterator();
            while (consumerIte.hasNext())
                System.out.println("Message from Single Topic :: "     + new String(consumerIte.next().message()));
        }
        if (consumer != null)
            consumer.shutdown();
    }
}

多消费者

import kafka.consumer.ConsumerConfig;
import kafka.consumer.ConsumerIterator;
import kafka.consumer.KafkaStream;
import kafka.javaapi.consumer.ConsumerConnector;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class KafkaMultiConsumer {

    /**
     * # zookeeper连接服务器地址，此处为线下测试环境配置(kafka消息服务-->kafka broker集群线上部署环境wiki)
     # 配置例子："127.0.0.1:3000,127.0.0.1:3001,127.0.0.1:3002"
     zookeeper.connect=192.168.2.225:2181,192.168.2.225:2182,192.168.2.225:2183/config/mobile/mq/mafka
     # zookeeper的session过期时间，默认5000ms，用于检测消费者是否挂掉，当消费者挂掉，其他消费者要等该指定时间才能检查到并且触发重新负载均衡
     zookeeper.session.timeout.ms=5000
     zookeeper.connection.timeout.ms=10000
     # 指定多久消费者更新offset到zookeeper中。注意offset更新时基于time而不是每次获得的消息。一旦在更新zookeeper发生异常并重启，将可能拿到已拿到过的消息
     zookeeper.sync.time.ms=2000

     #指定消费组
     group.id=xxx
     # 当consumer消费一定量的消息之后,将会自动向zookeeper提交offset信息
     # 注意offset信息并不是每消费一次消息就向zk提交一次,而是现在本地保存(内存),并定期提交,默认为true
     auto.commit.enable=true
     # 自动更新时间。默认60 * 1000
     auto.commit.interval.ms=1000

     # 当前consumer的标识,可以设定,也可以有系统生成,主要用来跟踪消息消费情况,便于观察
     conusmer.id=xxx

     # 消费者客户端编号，用于区分不同客户端，默认客户端程序自动产生
     client.id=xxxx
     # 最大取多少块缓存到消费者(默认10)
     queued.max.message.chunks=50
     # 当有新的consumer加入到group时,将会reblance,此后将会有partitions的消费端迁移到新
     # 的consumer上,如果一个consumer获得了某个partition的消费权限,那么它将会向zk注册
     # "Partition Owner registry"节点信息,但是有可能此时旧的consumer尚没有释放此节点,
     # 此值用于控制,注册节点的重试次数.
     rebalance.max.retries=5
     # 获取消息的最大尺寸,broker不会像consumer输出大于此值的消息chunk
     # 每次feth将得到多条消息,此值为总大小,提升此值,将会消耗更多的consumer端内存
     fetch.min.bytes=6553600
     # 当消息的尺寸不足时,server阻塞的时间,如果超时,消息将立即发送给consumer
     fetch.wait.max.ms=5000
     socket.receive.buffer.bytes=655360

     # 如果zookeeper没有offset值或offset值超出范围。那么就给个初始的offset。有smallest、largest、
     # anything可选，分别表示给当前最小的offset、当前最大的offset、抛异常。默认largest
     auto.offset.reset=smallest
     # 指定序列化处理类(mafka client API调用说明-->3.序列化约定wiki)，默认为kafka.serializer.DefaultDecoder,即byte[]
     derializer.class=com.meituan.mafka.client.codec.MafkaMessageDecoder
     */

    public static void main(String args[]) {
        String topic = "topic1" ;
        int threadCount = 3;
        Properties props = new Properties();
        props.put("zookeeper.connect", "xxx.xxx.xxx.xxx:2181");
        props.put("group.id", "testgroup");
        props.put("zookeeper.session.timeout.ms", "500");
        props.put("zookeeper.sync.time.ms", "250");
        props.put("auto.commit.interval.ms", "1000");
        ConsumerConfig config = new ConsumerConfig(props);
        ConsumerConnector consumer = kafka.consumer.Consumer.createJavaConsumerConnector(config) ;

        Map<String, Integer> topicMap = new HashMap<>();
        // Define single thread for topic
        topicMap.put(topic, 3);
        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
        Map<String, List<KafkaStream<byte[], byte[]>>> consumerStreamsMap = consumer.createMessageStreams(topicMap);
        List<KafkaStream<byte[], byte[]>> streamList = consumerStreamsMap.get(topic);
        int count = 0;
        for (final KafkaStream<byte[], byte[]> stream : streamList) {
            final String threadNumber = "Thread" + count ;
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    ConsumerIterator<byte[], byte[]> consumerIte = stream.iterator();
                    while (consumerIte.hasNext()) {
                        System.out.println("Thread Number " + threadNumber + ": " + new String(consumerIte.next().message()));
                    }
                }
            });
            count++ ;
        }
    }


}

总结：

1、KAFKA允许多个consumer group，每个group允许多个consumer。不同group之间共享信息（类似发布-订阅模式），同一个group之间的多个consumer只会消费消息一次（类似生产-消费者模式）。

2、对同一个topic启动多个java consumer线程，在zookeeper上可以看到多个信息：　　

[zk:xxx.xxx.xxx.xxx:2181(CONNECTED) 120] ls /consumers/testgroup/ids             
[testgroup_xxx-1459926903849-fea50e90, testgroup_xxx-1459926619712-8d1caf90]

3、如果多线程方式启动consumer，可以看到不同的consumer绑定到不同的topic patition上

[zk: xxx.xxx.xxx.xxx:2181(CONNECTED) 121] get /consumers/testgroup/owners/topic1/1
testgroup_xxx-1459926619712-8d1caf90-1
cZxid = 0x2000006e2
ctime = Wed Apr 06 03:15:04 EDT 2016
mZxid = 0x2000006e2
mtime = Wed Apr 06 03:15:04 EDT 2016
pZxid = 0x2000006e2
cversion = 0
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x153413bc26e007e
dataLength = 44
numChildren = 0
[zk: xxx.xxx.xxx.xxx:2181(CONNECTED) 122] get /consumers/testgroup/owners/topic1/0
testgroup_xxx-1459926619712-8d1caf90-0
cZxid = 0x2000006e3
ctime = Wed Apr 06 03:15:04 EDT 2016
mZxid = 0x2000006e3
mtime = Wed Apr 06 03:15:04 EDT 2016
pZxid = 0x2000006e3
cversion = 0
dataVersion = 0
aclVersion = 0
ephemeralOwner = 0x153413bc26e007e
dataLength = 44
numChildren = 0

4、对于启动多个consumer进程或是以多线程方式启动单个consumer进程，区别仅仅在与zookeeper上注册的consumer信息是多个或是一个“ls /consumers/testgroup/ids ”，但是对于消息的消费而言，都遵守消费只消费一次，同一个分区只会绑定一个consumer信息。

5、如果某个消费者挂掉的话，consumer和partition的绑定信息会重新分配，尽可能的保证负载平衡

6、如果consumer的数量大于分区数量，会造成多余的那部分线程无法获取消息，不断 Got ping response for sessionid: 0x153413bc26e0082 after 2ms。是一种资源的浪费

如果多台服务器都启动consumer进程，最好根据分区数合理分配consumer进程中，消费线程的数量

 

更底层的细节问题，后期遇到再继续调研，先会用，明白大致原理！

 

 

转载于:https://www.cnblogs.com/huayu0815/p/5359722.html

weixin_30376509
关注
flink kafka producer与consumer中的知识点，kafkasource实例
Direction_Wind的博客
06-07 406
KakfaConsumerThread 线程不断从Kafka 中消费数据消费的数据存储handover 中kafkaFetch 不断从handover 获取数据进行处理其他流程。
kafka的javaAPl实现Producer和Consumer（生产与消费）
山海
12-02 191
kafka的javaAPl实现Producer和Consumer（生产与消费） 创建maven项目，并编写pom文件 <dependencies> <!-- https://mvnrepository.com/artifact/org.apache.kafka/kafka --> <dependency> <groupId>org.apache.kafka</groupId> <artifactId>kafka
Kafka的Producer和Consumer源码学习
jsky_studio的专栏
01-26 1882
本文记录自己的一些理解，盼路过高手指正。 先解释下两个概念： high watermark (HW)         它表示已经被commited的最后一个message offset(所谓commited, 应该是ISR中所有replica都已写入)，HW以下的消息都已被ISR中各个replica同步，从而保持一致。HW以上的消息可能是脏数据：部分replica写成功，但最终失败了。
KafkaProducer Sender 线程详解（含详细的执行流程图）
中间件兴趣圈
11-17 4396
温馨提示：本文基于 Kafka 2.2.1 版本。 上文 《源码分析 Kafka 消息发送流程》 已经详细介绍了 KafkaProducer send 方法的流程，该方法只是将消息追加到 KafKaProducer 的缓存中，并未真正的向 broker 发送消息，本文将来探讨 Kafka 的 Sender 线程。 本节目录1、Sender 线程详解1.1 类图1.2 run 方法详解1.2.1...
【Spring常见错误】No qualifying bean of type
专注Spring、SSM、数据结构与算法、蓝桥杯领域创作者
05-02 8万+
报错信息： org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'com.ssmpdemo.ServiceTest': Unsatisfied dependency expressed through field 'userService'; nested exception is org.springframework.beans.factory.NoSuchBe
Kafka使用Java进行Producer和Consumer编程
小强签名设计 的博客
10-30 1万+
比较旧的kafka_2.10-0.8.2.0版本：（参考自http://chengjianxiaoxue.iteye.com/blog/2190488）生产者代码：import java.util.Properties; import java.util.concurrent.TimeUnit; import kafka.javaapi.producer.Producer; im...
kafka consumer java_Kafka从上手到实践-实践真知：Kafka Java Consumer
weixin_30046591的博客
02-12 691
这一节来看看如何使用Java编写Kafka Consumer。Java Consumer首先创建Consumer需要的配置信息，最基本的有五个信息：Kafka集群的地址。发送的Message中Key的序列化方式。发送的Message中Value的序列化方式。指定Consumer Group。指定拉取Message范围的策略。Properties properties = new Propertie...
Springboot集成Kafka实现producer和consumer的示例代码
08-27
1. **生产者（Producer）**: 生产者是向 Kafka 集群发布消息的应用程序。在 Spring Boot 中，可以通过 `KafkaTemplate` 或自定义配置来发送消息。 2. **消费者（Consumer）**: 消费者从 Kafka 集群中读取消息并处理...
使用java创建kafka的consumer和producer
oTianShiZaiChangGe1的博客
04-09 537
11
Kafka producer consumer connect stream 监控指标获取
lengchanguo的专栏
09-25 494
1、kafkaproducer consumer connect stream 监控 kafka 提供对producer consumer connect stream的指标监控 kafka monitoring官方文档 producer consumer connect stream 的监控是在各自的实例上，即在kafka集群上是获取不到这些监控指标的，所以要在各自的实例上开启JMX端口以供调用。 2、开启JMX端口 网上的资料很多，简单...
Kafka客户端API----简单消费者和生产者测试
oneslide
01-29 1121
Prerequisites 搭建一台Kafka的服务器，我的搭建在Liunx上。使用Kafka Client API进行生产者和消费者的简单测试。这里使用Spring Boot的框架但没有使用Spring boot for Kafka，而是使用普通的Java API. 项目构建 Maven文件是不加任何依赖的Spring Boot的应用，加上一个Kafka Client 依赖。 &lt;!-- ...
kafka模拟客户端发送、接受消息
weixin_33970449的博客
11-14 1088
producer   消息的生成者，即发布消息 consumer   消息的消费者，即订阅消息 broker     Kafka以集群的方式运行，可以由一个或多个服务组成，服务即broker zookeeper  协调转发    一、创建topic ./kafka-topics.sh --create --zookeeper localhost:2181 \ --replic...
java连接kafka
weixin_43315211的博客
03-12 7539
pom.xml配置： &lt;dependency&gt; &lt;groupId&gt;org.apache.kafka&lt;/groupId&gt; &lt;artifactId&gt;kafka-clients&lt;/artifactId&gt; &lt;version&gt;0.11.0.0&lt;/versi...
Kafka 配置说明 含0.8.1版server.properties
liyonghui123的专栏
12-06 404
   server.properties配置：   server.properties中所有配置参数说明(解释)如下列表：     参数 说明(解释) broker.id =0 每一个broker在集群中的唯一表示， 要求是正数。当该服务器的IP地址 发生改变时，broker.id没有变化， 则不会影响consumers的消息情况 ...
linux上kafka模拟客户端发送、接受消息
aiduo4911的博客
11-22 1684
producer 消息的生成者，即发布消息 consumer 消息的消费者，即订阅消息 broker Kafka以集群的方式运行，可以由一个或多个服务组成，服务即broker zookeeper协调转发 打开两个终端 一个终端发送消息 一个终端接收消息： producer，指定的Socket(localhost+9092),说明生产者的消息要发往kaf...
Kafka - a simple consumer demo - c++
ShiShc
11-29 2294
Kafka 如果有 kafka 基础的同学可以不用看前面的废话，可以从第五条 [配置] 开始看起～ 代码在第七条 前言：官网比我这标准多了～ 官网跳转，大家可以先完成quickStart部分kafka单机生产消费 一、概念简介 Kafka 是一个分布式流处理平台，常被用作消息队列中间件。具有横向扩展，容错，高速等优点。 Kafka中的概念 record: 由 key , value , timestamp 组成，Kafka 集群会保持所有的消息，直到它们过期，无论消息是否被消费。Kafka 的
No qualifying bean of type问题解决
蜀道难，难于上青天。
05-06 6万+
No qualifying bean of type问题解决 前言 No qualifying bean of type ‘xxx.xxx.xxx’ available: expected single matching bean but found 2:xxx.xxx.xxx 对于一个java开发新手来说， 应该经常会遇到这个问题，而且还不好意思询问周围同事，不要怕，今天就让我们解决掉它。 问题及解决方案 问题1 包扫描不正确或未扫描 默认情况下，如果使用了springboot,他会默认扫描启动类（
Flink面试题大全(建议收藏)
a934079371的博客
08-26 3万+
概述2019 年是大数据实时计算领域最不平凡的一年，2019 年 1 月阿里巴巴 Blink （内部的 Flink 分支版本）开源，大数据领域一夜间从 Spark 独步天下走向了两强争霸...
解决 No qualifying bean of type 问题
热门推荐
sh_c1314
08-25 32万+
解决 No qualifying bean of type 问题 思路: 1 检查是否添加了对应注解 2 检查配置是否正确,扫描包名, 类名及id是否正确 一. 传统SSM项目 ssm项目，出现“No qualifying bean of type found for dependency ***”错误，最后定位到该bean，仔细检查， 1 首先检查是否在类上添加了...
请给出kafka的producer和consumer代码
最新发布
04-23
好的，以下是Kafka的Producer和Consumer代码示例（使用Java语言）： Producer代码示例： ```java import org.apache.kafka.clients.producer.*; import java.util.Properties; public class ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值