Kafka理解

1.　引言

　　最近使用Kafka做消息队列时，完成了基本的消息发送与接收，已上线运行。一方面防止出现Bug时自己不能及时定位问题，一方面网上的配置可能还可以更加优化，决定去了解下Kafka。

2.　配置

　　kafka基本配合zookeeper使用，网上有很多关于liunx上搭建zookeeper+kafka集群的实例，此处不再阐述。贴一个我以前搭建过的实例。https://blog.csdn.net/hudyang/article/details/80419214

3.　理解Kafka

3.1　kafka是什么

　　个人理解：kafka是一个消息中间件，用于各个系统中消息的传递。例如：A系统是平台主入口，每天产生大量日志，A系统不可能自己去处理这些冗杂的事务，于是发送给Kafka。B系统很空闲，让他来接收Kafka数据，于是从kafka取数据，然后记录日志；在举个例子，在微服务中，A系统是用户模块，B系统是权限模块。创建用户时也要创建用户权限。于是在A系统在创建用户时，向kafka中发送一条指定消息，B系统收到这条消息后，于是开始创建用户权限。是不是很好理解-----

　　总结一句话：kafka是一个分布流媒体平台

　　流媒体平台有以下三个关键功能：

• 发布和订阅记录流，类似于消息队列或企业消息传递系统。
• 以容错的持久方式存储记录流。
• 记录发生时处理流。

3.2　相关概念

　　主题是Kafka最核心的抽象模块，用于连接生产者和消费者。生产者发送消息到指定的主题，消费者订阅该主题的消息，于是完成基本的消息传递流程。下面为kafka建立主题的code：

./kafka-topics.sh --create --zookeeper 10.113.56.68: --replication-factor  --partitions  --topic testKafkas
// --zookeeper zookeeper集群地址
// --replication-factor 副本
// --parttitions 分区
// --topic 主题名称

　　分区的概念：分区是主题的横向拓展的实现。传统的消息队列相当于一个列表，生产者将消息放入列表中，然后消费者从列表中取出消息。吞吐量受到限制。如果使用多线程去取消息，就会造成异步操作，有可能出现数据消费混乱。Kafka中使用分区概念（相当于将一个大的队列分为成多个队列）每个分区由指定的消费者去消费，这样能极大的提高kafka的吞吐量，并且效率提高。

　　

　　每个分区都是一个有序的，不可变的记录序列，不断附加到结构化的提交日志中。分区中的记录每个都被分配一个称为偏移的顺序ID号（offSet），它唯一地标识分区中的每个记录。如上图，一个topic的消息均匀分布在partition0，partition1，partition2中。消费者写3条消息到topic上，分别记录在partition0的offset12节点，partition1的offset9节点，partition2的offset12节点。消费者消费时，会从partition的offset0节点开始，消费完成后，offset+1，下次消费时，从上次的offset开始进行消费。

　　副本的概念：每个分区拥有多个副本，其中一个副本将被指定为主副本(leader replicas)，其余的为跟随副本。所有的消息都会写入到主副本，所有的消息都从主要副本读取，其他的副本只需要保持于主副本同步即可。

　　消费组概念：消费组比较难理解。消费组相当于一个指定消费者的聚合。

　　如图，KafkaCluster相当于一个topic，topic有4个分区 P0，P1，P2，P3；P0，P3在服务器1上，P1，P2在服务器2上（此处可以忽略他们在哪个服务器）；有2个消费组ConsumerGroupA，ConsumerGroupB，里面有C1-C6消费者，每个消费者都订阅了topic的消息。上文提过，一个分区的消息只能被同一消费组下面的一个消费者消费。于是，对于ConsumerGroupA来说，C1接收P0,P3的消息，C2接收P1,P2的消息（为什么这么分配，下文会进行）。对于ConsumerGroupB来说，C3-C6分别接收P0-P3的消息。此处还有个小点，即消费组中的消费者数量不要大于分区数量。以ConsumerGroupB为例，消费者和分区刚好一一对应，如果此时增加了一个消费者C7，那么C7接受不到任何分区的消息，因为一个分区只能对应同个消费组下的一个消费者。

3.3　补充

　　描述了Kafka基本概念后，此处介绍另一个概念Rebalance（即分区分配给消费组中指定消费者的过程）

　　

　　如上，消费组中原来有2个consumer，consumerA对应主题A的0分区，主题B的1分区，主题C的0分区;consumerB对应主题A的1分区，主题B的0分区，主题C的1分区。此时，消费组新增一个consumerC，那么对应的分区就要相应的重新分配，这个过程就叫Rebalance。

　　什么时候发生Rebalance？

• 消费组中消费者新增，离开，崩溃都会触发Rebalance；
• 订阅的主题增加或减少；
• 订阅的主题分区数增加或减少；

　　Rebalance引发的问题

• Rebalance过程中，消费者不能进行消费；
• 如果一个消费者消费一段消息后，没有提交确认就发生了Rebalance，那么此段消息还会分发给分配后的消费者，造成消息重复消费；

　　Rebalance流程（简介）

• 加入组请求（JoinGroup）=>作用在于选择Group Leader（消费组中的领导，用于制定分区分配方案）。
• 同步组请求（SyncGroup）=>作用在于确定分区分配方案给Coordinator(对消费组进行管理的对象)，把方案响应给所有Consumer。

　　自己理解：consumer申请加入组，向Coordinator发送JoinGroup请求，Coordinator从重多consumer选择一个Group Leader（领导）。领导用于指定分区方案，即那个分区非配给哪个消费者。制定完成后，把分区方案给Coordinator，Coordinator然后告诉所有消费者：你负责的分区是哪个。

4.　实际案例

　　自己用Kafka做了一个简易消息系统，完成基本的消息发送。

// 引入kafka相关jar包
<dependency>
    <groupId>org.springframework.kafka</groupId>
    <artifactId>spring-kafka</artifactId>
    <version>2.1.7.RELEASE</version>
</dependency>

import org.apache.kafka.clients.consumer.CommitFailedException;
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.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.Arrays;
import java.util.Properties;
import java.util.concurrent.ExecutionException;
import java.util.function.Consumer;

/**
 * @Author  xiabing5
 * @Create  2019/8/1 19:34
 * @Desc    kafka工具类
 **/
public class KafkaUtil {

    private static Producer<String, String> producer;

    private static KafkaConsumer<String, String> consumer;

    private static KafkaConsumer<String, String> consumer1;
    static {
        Properties producerProps = new Properties();
        //必需的3个参数
        producerProps.put("bootstrap.servers", "10.113.56.68:9093,10.113.56.68:9094,10.113.56.68:9092");
        producerProps.put("key.serializer",
                "org.apache.kafka.common.serialization.StringSerializer");
        producerProps.put("value.serializer",
                "org.apache.kafka.common.serialization.StringSerializer");
        producer = new KafkaProducer<String, String>(producerProps);

        Properties consumerProps = new Properties();
        consumerProps.put("bootstrap.servers", "10.113.56.68:9093,10.113.56.68:9094,10.113.56.68:9092");
        consumerProps.put("key.deserializer",
                "org.apache.kafka.common.serialization.StringDeserializer");
        consumerProps.put("value.deserializer",
                "org.apache.kafka.common.serialization.StringDeserializer");
        consumerProps.put("group.id", "VoucherGroup");
        //关闭自动提交offset
        consumerProps.put("enable.auto.commit", "false");
    //此处开启2个消费者进行消费
        consumer = new KafkaConsumer<String, String>(consumerProps);
        consumer1 = new KafkaConsumer<String, String>(consumerProps);
    }

    /**
     * @Author xiabing5
     * @Create 2019/8/1 19:40
     * @Desc 同步发送消息 topic 主题 value 消息内容
     **/
    public static void sendSync(String topic, String value) throws ExecutionException, InterruptedException {
        producer.send(new ProducerRecord<String, String>(topic, value)).get();
    }

    public static void consume(Consumer<String> c) {
        // 订阅主题，可订阅多个主题
        consumer.subscribe(Arrays.asList("testKafkas"));
        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(10);
            for (ConsumerRecord<String, String> record : records) {
                System.out.println("A"+record);
                c.accept(record.value());
            }
            try {
                //同步手动提交offset
                consumer.commitSync();
            } catch (CommitFailedException e) {
                System.out.println("Kafka消费者提交offset失败");
            }
        }
    }

    public static void consume1(Consumer<String> c) {
        // 订阅主题，可订阅多个主题
        consumer1.subscribe(Arrays.asList("testKafkas"));
        while (true) {
            ConsumerRecords<String, String> records = consumer1.poll(10);
            for (ConsumerRecord<String, String> record : records) {
                System.out.println("A"+record);
                c.accept(record.value());
            }
            try {
                //同步手动提交offset
                consumer1.commitSync();
            } catch (CommitFailedException e) {
                System.out.println("Kafka消费者提交offset失败");
            }
        }
    }

}

// 发送消息接口
public interface MessageService {

    // 发送消息
    boolean sendMessage(String topic,String content);

}

@Service
public class MessageServiceImpl implements MessageService {

    // 创建线程池
    @PostConstruct
    public void init() {
        ThreadFactory threadFactory = new ThreadFactoryBuilder()
                .setNameFormat("MessageConsumerThread-%d")
                .setDaemon(true)
                .build();
        //ExecutorService executorService = Executors.newSingleThreadExecutor(threadFactory);
        ExecutorService executorService = Executors.newFixedThreadPool(2,threadFactory);
        MqMessageConsumerThread mqMessageConsumerThread= new MqMessageConsumerThread();
        MqMessageConsumerThread1 mqMessageConsumerThread1= new MqMessageConsumerThread1();
        executorService.execute(mqMessageConsumerThread);
        executorService.execute(mqMessageConsumerThread1);
    }

    // 自定义接收线程
    private class MqMessageConsumerThread implements Runnable {
        @Override
        public void run() {
            KafkaUtil.consume(consumerRecord -> {
              System.out.println("A"+consumerRecord);
            });
        }
    }
    private class MqMessageConsumerThread1 implements Runnable {
        @Override
        public void run() {
            KafkaUtil.consume1(consumerRecord -> {
                System.out.println("B"+consumerRecord);
            });
        }
    }
    @Override
    public boolean sendMessage(String topic, String content) {
        try {
            KafkaUtil.sendSync(topic,content);
            // 执行业务逻辑
            System.out.println("发送kafka消息成功");
        }
        catch (Exception e) {
            // 发送失败
            System.out.println("发送kafka消息失败");
            // 失败重发
            try {
                KafkaUtil.sendSync(topic,content);
            }catch (Exception e1) {
                System.out.println("失败");
            }
        }
        return true;
    }
}

/**
 * @Author  xiabing5
 * @Create  2019/9/19 20:17
 * @Desc    容器初始化（模拟消息发送）
 **/
@Component
public class InitApplication implements CommandLineRunner{

    @Autowired
    MessageService messageService;

    @Override
    public void run(String... strings) throws Exception {
        for (int i = 0; i < 10; i++) {
            messageService.sendMessage("testKafkas",i+"");
        }
    }
}

　　启动容器，会出现如下界面

5.　总结

　　学习一项新技术，最好知道它实现的基本内涵，希望自己这个小白在每一次记录中成长；

　　本文纯原创，写的不好或理解不到位的地方请多多指教；