我虽然也读《变形记》，但这Kafka非彼卡夫卡(一)

前言

Franz Kafka创作了荒诞派文学代表作《变形记》，富有创造的程序员孕育了Kafka，一位是存在主义大师，一个是高性能中间件，他们在各自的领域缔造传奇。

至于这篇文章主要讲述Kafka的一些事件内容，就不过多赘述基本概念和原理了。

引读

终于有人把 kafka 原理说清楚了！(文章里的比喻很好理解，你懂的😄)

转载链接：https://mp.weixin.qq.com/s/yH0NDocqb6oJhYf9R79uJw

打板开讲🔔

1.Java客户端访问Kafka

引入maven依赖

<dependency>
    <groupId>org.apache.kafka</groupId> 
    <artifactId>kafka‐clients</artifactId> 
    <version>1.1.0</version> 
</dependency>

发送端(附参数释义)

public class ZhangjiangMsgProducer { 
 public static void main(String[] args) throws InterruptedException, ExecutionException { 
 Properties props = new Properties(); 
 props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.0.60:9092,192.168.0.60:9093,192.168.0.60:9094"); 
 /* 
 发出消息持久化机制参数 
（1）acks=0： 表示producer不需要等待任何broker确认收到消息的回复，就可以继续发送下一条消息。性能最高，但是最容易丢消息。
 （2）acks=1： 至少要等待leader已经成功将数据写入本地log，但是不需要等待所有follower是否成功写入。就可以继续发送下一条消息。 这种情况下，如果follower没有成功备份数据，而此时leader 
 又挂掉，则消息会丢失。 
 （3）acks=‐1或all： 这意味着leader需要等待所有备份(min.insync.replicas配置的备份个数)都成功写入日志，这种策略会保证只要有 一个备份存活就不会丢失数据。 
 这是最强的数据保证。一般除非是金融级别，或跟钱打交道的场景才会使用这种配置。 
 */ 
 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，意思就是消息必须立即被发送，但这样会影响性能 
//一般设置100毫秒左右，就是说这个消息发送完后会进入本地的一个batch，如果100毫秒内，这个batch满了16kb就会随batch一起被发送出 去
 //如果100毫秒内，batch没满，那么也必须把消息发送出去，不能让消息的发送延迟时间太长 
 props.put(ProducerConfig.LINGER_MS_CONFIG, 100); 
 //把发送的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<>(props); 
 int msgNum = 5; 
 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>("order‐topic" 
 , 0, order.getOrderId().toString(), JSON.toJSONString(order)); 
 //未指定发送分区，具体发送的分区计算公式：hash(key)%partitionNum 
 /*ProducerRecord<String, String> producerRecord = new ProducerRecord<String, String>("my‐replicated‐topic" 
 , 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() { 
 @Override 
   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(); 
 } 
 }

消费端(附参数释义)

public class ZhangjiangMsgConsumer { 
public static void main(String[] args) { 
 Properties props = new Properties(); 
 props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.0.60:9092"); 
 // 消费分组名 
 props.put(ConsumerConfig.GROUP_ID_CONFIG, "testGroup"); 
 // 是否自动提交offset

 /*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"); 
 /* 
 心跳时间，服务端broker通过心跳确认consumer是否故障，如果发现故障，就会通过心跳下发 
 rebalance的指令给其他的consumer通知他们进行rebalance操作，这个时间可以稍微短一点 
 */ 
 props.put(ConsumerConfig.HEARTBEAT_INTERVAL_MS_CONFIG, 1000); 
 //服务端broker多久感知不到一个consumer心跳就认为他故障了，默认是10秒 
 props.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, 10 * 1000); 
 /* 
 如果两次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<>(props); 
 // 消费主题 
 String topicName = "order‐topic"; 
 //consumer.subscribe(Arrays.asList(topicName)); 
 // 消费指定分区 
 //consumer.assign(Arrays.asList(new TopicPartition(topicName, 0))); 

 //消息回溯消费 
 consumer.assign(Arrays.asList(new TopicPartition(topicName, 0))); 
 consumer.seekToBeginning(Arrays.asList(new TopicPartition(topicName, 0))); 

 //指定offset消费 
 //consumer.seek(new TopicPartition(topicName, 0), 10); 

 while (true) { 
 /* 
 * poll() API 是拉取消息的长轮询，主要是判断consumer是否还活着，只要我们持续调用poll()， 
 * 消费者就会存活在自己所在的group中，并且持续的消费指定partition的消息。 
 * 底层是这么做的：消费者向server持续发送心跳，如果一个时间段（session. 
 * timeout.ms）consumer挂掉或是不能发送心跳，这个消费者会被认为是挂掉了， 
 * 这个Partition也会被重新分配给其他consumer
 */ 
 ConsumerRecords<String, String> records = consumer.poll(Integer.MAX_VALUE); 
 for (ConsumerRecord<String, String> record : records) { 
   System.out.printf("收到消息：offset = %d, key = %s, value = %s%n", 
   record.offset(), record.key(), 
   record.value()); 
 } 

   if (records.count() > 0) { 
      // 提交offset 
     consumer.commitSync(); 
    } 
   } 
  } 
 }    

2.Spring Boot整合Kafka 

引入spring boot kafka依赖

 <dependency> 
    <groupId>org.springframework.kafka</groupId>
    <artifactId>spring‐kafka</artifactId> 
 </dependency>

application.yml配置如下：

server: 
 port: 8080 
spring: 
 kafka: 
    bootstrap‐servers: 192.168.0.60:9092,192.168.0.60:9093
    producer: # 生产者 
    retries: 3 # 设置大于0的值，则客户端会将发送失败的记录重新发送 
    batch‐size: 16384 
    buffer‐memory: 33554432  # 指定消息key和消息体的编解码方式
    key‐serializer: org.apache.kafka.common.serialization.StringSerializer 
    value‐serializer: org.apache.kafka.common.serialization.StringSerializer 
    consumer: 
      group‐id: mygroup 
      enable‐auto‐commit: true

消息发送端代码

 @RestController 
public class KafkaController {
    @Autowired 
    private KafkaTemplate<String, String> kafkaTemplate;
    @RequestMapping("/send") 
   public void send() { 
      kafkaTemplate.send("mytopic", 0, "key", "this is a msg"); 
   } 
 }

消费者代码

@Component 
public class ZhangjiangConsumer { 
 /*** @KafkaListener(groupId = "testGroup", topicPartitions = { 
 * @TopicPartition(topic = "topic1", partitions = {"0", "1"}), 
 * @TopicPartition(topic = "topic2", partitions = "0", 
 * partitionOffsets = @PartitionOffset(partition = "1", initialOffset = "100")) 
 * },concurrency = "6") 
 * //concurrency就是同组下的消费者个数，就是并发消费数，必须小于等于分区总数 
 * @param record 
 */ 
 @KafkaListener(topics = "mytopic",groupId = "testGroup") 
 public void listen(ConsumerRecord<String, String> record) { 
    String value = record.value(); 
     System.out.println(value);
     System.out.println(record); 
  } 
}