【Java客户端访问Kafka】

package com.sky.kafka.kafkaDemo;

import com.alibaba.fastjson.JSON;

import org.apache.kafka.clients.producer.*;

import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.TimeUnit;

public class MsgProducer {

private final static String TOPIC_NAME = “my-replicated-topic”;

public static void main(String[] args) throws InterruptedException, ExecutionException {

Properties props = new Properties();

props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, “192.168.65.60:9092,192.168.65.60:9093,192.168.65.60:9094”);

/*

发出消息持久化机制参数

（1）acks=0： 表示producer不需要等待任何broker确认收到消息的回复，就可以继续发送下一条消息。性能最高，但是最容易丢消息。

（2）acks=1： 至少要等待leader已经成功将数据写入本地log，但是不需要等待所有follower是否成功写入。就可以继续发送下一

条消息。这种情况下，如果follower没有成功备份数据，而此时leader又挂掉，则消息会丢失。

（3）acks=-1或all： 需要等待 min.insync.replicas(默认为1，推荐配置大于等于2) 这个参数配置的副本个数都成功写入日志，这种策略会保证

只要有一个备份存活就不会丢失数据。这是最强的数据保证。一般除非是金融级别，或跟钱打交道的场景才会使用这种配置。

*/

/*props.put(ProducerConfig.ACKS_CONFIG, “1”);

//

发送失败会重试，默认重试间隔100ms，重试能保证消息发送的可靠性，但是也可能造成消息重复发送，比如网络抖动，所以需要在

接收者那边做好消息接收的幂等性处理

//

props.put(ProducerConfig.RETRIES_CONFIG, 3);

//重试间隔设置

props.put(ProducerConfig.RETRY_BACKOFF_MS_CONFIG, 300);

//设置发送消息的本地缓冲区，如果设置了该缓冲区，消息会先发送到本地缓冲区，可以提高消息发送性能，默认值是33554432，即32MB

props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 33554432);

//

kafka本地线程会从缓冲区取数据，批量发送到broker，

设置批量发送消息的大小，默认值是16384，即16kb，就是说一个batch满了16kb就发送出去

//

props.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);

//

默认值是0，意思就是消息必须立即被发送，但这样会影响性能

一般设置10毫秒左右，就是说这个消息发送完后会进入本地的一个batch，如果10毫秒内，这个batch满了16kb就会随batch一起被发送出去

如果10毫秒内，batch没满，那么也必须把消息发送出去，不能让消息的发送延迟时间太长

//

props.put(ProducerConfig.LINGER_MS_CONFIG, 10);*/

//把发送的key从字符串序列化为字节数组

props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

//把发送消息value从字符串序列化为字节数组

props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

Producer<String, String> producer = new KafkaProducer<String, String>(props);

int msgNum = 5;

final CountDownLatch countDownLatch = new CountDownLatch(msgNum);

for (int i = 1; i <= msgNum; i++) {

Order order = new Order(i, 100 + i, 1, 1000.00);

//指定发送分区

/*ProducerRecord<String, String> producerRecord = new ProducerRecord<String, String>(TOPIC_NAME

, 0, order.getOrderId().toString(), JSON.toJSONString(order));*/

//未指定发送分区，具体发送的分区计算公式：hash(key)%partitionNum

ProducerRecord<String, String> producerRecord = new ProducerRecord<String, String>(TOPIC_NAME

, order.getOrderId().toString(), JSON.toJSONString(order));

//等待消息发送成功的同步阻塞方法

/*RecordMetadata metadata = producer.send(producerRecord).get();

System.out.println(“同步方式发送消息结果：” + “topic-” + metadata.topic() + “|partition-”

• metadata.partition() + “|offset-” + metadata.offset());*/

//异步回调方式发送消息

producer.send(producerRecord, new Callback() {

public void onCompletion(RecordMetadata metadata, Exception exception) {

if (exception != null) {

System.err.println(“发送消息失败：” + exception.getStackTrace());

}

if (metadata != null) {

System.out.println(“异步方式发送消息结果：” + “topic-” + metadata.topic() + “|partition-”

• metadata.partition() + “|offset-” + metadata.offset());

}

countDownLatch.countDown();

}

});

//送积分 TODO

}

countDownLatch.await(5, TimeUnit.SECONDS);

producer.close();

}

}

消息接收端代码

package com.sky.kafka.kafkaDemo;

import org.apache.kafka.clients.consumer.ConsumerConfig;

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;

import java.time.Duration;

import java.util.Arrays;

import java.util.Properties;

public class MsgConsumer {

private final static String TOPIC_NAME = “my-replicated-topic”;

private final static String CONSUMER_GROUP_NAME = “testGroup”;

public static void main(String[] args) {

Properties props = new Properties();

props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, “106.14.132.94:9092,106.14.132.94:9093,106.14.132.94:9094”);

// 消费分组名

props.put(ConsumerConfig.GROUP_ID_CONFIG, CONSUMER_GROUP_NAME);

// 是否自动提交offset，默认就是true

props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, “true”);

// 自动提交offset的间隔时间

props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, “1000”);

//props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, “false”);

/*

当消费主题的是一个新的消费组，或者指定offset的消费方式，offset不存在，那么应该如何消费

latest(默认) ：只消费自己启动之后发送到主题的消息

earliest：第一次从头开始消费，以后按照消费offset记录继续消费，这个需要区别于consumer.seekToBeginning(每次都从头开始消费)

*/

//props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, “earliest”);

/*

consumer给broker发送心跳的间隔时间，broker接收到心跳如果此时有rebalance发生会通过心跳响应将

rebalance方案下发给consumer，这个时间可以稍微短一点

*/

props.put(ConsumerConfig.HEARTBEAT_INTERVAL_MS_CONFIG, 1000);

/*

服务端broker多久感知不到一个consumer心跳就认为他故障了，会将其踢出消费组，

对应的Partition也会被重新分配给其他consumer，默认是10秒

*/

props.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, 10 * 1000);

//一次poll最大拉取消息的条数，如果消费者处理速度很快，可以设置大点，如果处理速度一般，可以设置小点

props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, 500);

/*

如果两次poll操作间隔超过了这个时间，broker就会认为这个consumer处理能力太弱，

会将其踢出消费组，将分区分配给别的consumer消费

*/

props.put(ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG, 30 * 1000);

props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());

props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());

KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(props);

consumer.subscribe(Arrays.asList(TOPIC_NAME));

// 消费指定分区

//consumer.assign(Arrays.asList(new TopicPartition(TOPIC_NAME, 0)));

//消息回溯消费

/*consumer.assign(Arrays.asList(new TopicPartition(TOPIC_NAME, 0)));

consumer.seekToBeginning(Arrays.asList(new TopicPartition(TOPIC_NAME, 0)));*/

//指定offset消费

先自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以扫码领取！

总结

至此，文章终于到了尾声。总结一下，我们谈论了简历制作过程中需要注意的以下三个部分，并分别给出了一些建议：

1. 技术能力：先写岗位所需能力，再写加分能力，不要写无关能力；
2. 项目经历：只写明星项目，描述遵循 STAR 法则；
3. 简历印象：简历遵循三大原则：清晰，简短，必要，要有的放矢，不要海投；

以及最后为大家准备的福利时间：简历模板+Java面试题+热门技术系列教程视频

%;" />

总结

至此，文章终于到了尾声。总结一下，我们谈论了简历制作过程中需要注意的以下三个部分，并分别给出了一些建议：

1. 技术能力：先写岗位所需能力，再写加分能力，不要写无关能力；
2. 项目经历：只写明星项目，描述遵循 STAR 法则；
3. 简历印象：简历遵循三大原则：清晰，简短，必要，要有的放矢，不要海投；

以及最后为大家准备的福利时间：简历模板+Java面试题+热门技术系列教程视频

[外链图片转存中…(img-VSzMSC6h-1711474346691)]

[外链图片转存中…(img-gUPzPCjn-1711474346691)]

[外链图片转存中…(img-dKKpq5lk-1711474346691)]

需要更多Java资料的小伙伴可以帮忙点赞+关注，点击传送门，即可免费领取！