Kafka入门

主题和日志(Topics and Logs)

一个topic是一个分类，或者说是记录被发布的时候的一个名字。对于每个主题，Kafka集群维护一个分区日志，如下图所示：

每个分区都是一个有序的、不可变的记录序列，而且记录会不断的被追加，一条记录就是一个结构化的提交日志（a structured commit log）。分区中的每条记录都被分配了一个连续的id号，这个id号被叫做offset（偏移量），这个偏移量唯一的标识出分区中的每条记录。（PS：如果把分区比作数据库表的话，那么偏移量就是主键）

Kafka集群持久化所有已发布的记录，无论它们有没有被消费，记录被保留的时间是可以配置的。例如，如果保留策略被设置为两天，那么在记录发布后的两天内，可以使用它，之后将其丢弃以释放空间。在对数据大小方面，Kafka的性能是高效的，恒定常量级的，因此长时间存储数据不是问题。

事实上，唯一维护在每个消费者上的元数据是消费者在日志中的位置或者叫偏移量。偏移量是由消费者控制的：通常消费者在读取记录的时候会线性的增加它的偏移量，但是，事实上，由于位置（偏移量）是由消费者控制的，所以它可以按任意它喜欢的顺序消费记录。例如：一个消费者可以重置到一个较旧的偏移量来重新处理之前已经处理过的数据，或者跳转到最近的记录并从“现在”开始消费。

这种特性意味着消费者可以来来去去的消费消息而不会对集群或者其它消费者造成太大影响。

日志中的分区有几个用途。首先，它们允许日志的规模超出单个服务器的大小。每个独立分区都必须与宿主的服务器相匹配，但一个主题可能有多个分区，所以它可以处理任意数量的数据。第二，它们作为并行的单位。简单地来说，日志分区的作用有两个：一、日志的规模不再受限于单个服务器，可以进行水平扩展；二、分区意味着可以并行。

分布(Distribution)

日志的分区分布在集群中的服务器上，每个服务器处理数据，并且分区请求是共享的。每个分区被复制到多个服务器上以实现容错，到底复制到多少个服务器上是可以配置的。

Each partition is replicated across a configurable number of servers for fault tolerance.

每个分区都有一个服务器充当“leader”角色，并且有0个或者多个服务器作为“followers”。leader处理对这个分区的所有读和写请求，而followers被动的从leader那里复制数据。如果leader失败，followers中的其中一个会自动变成新的leader。每个服务器充当一些分区的“leader”的同时也是其它分区的“follower”，因此在整个集群中负载是均衡的。

也就是说，每个服务器既是“leader”也是“follower”。我们知道一个主题可能有多个分区，一个分区可能在一个服务器上也可能跨多个服务器，然而这并不以为着一台服务器上只有一个分区，是可能有多个分区的。每个分区中有一个服务器充当“leader”，其余是“follower”。leader负责处理这个它作为leader所负责的分区的所有读写请求，而该分区中的follow只是被动复制leader的数据。这个有点儿像HDFS中的副本机制。例如：分区-1有服务器A和B组成，A是leader，B是follower，有请求要往分区-1中写数据的时候就由A处理，然后A把刚才写的数据同步给B，这样的话正常请求相当于A和B的数据是一样的，都有分区-1的全部数据，如果A宕机了，B成为leader，接替A继续处理对分区-1的读写请求。

需要注意的是，分区是一个虚拟的概念，是一个逻辑单元。

生产者(Producers)

生产者发布数据到它们选择的主题中。生产者负责选择将记录投递到哪个主题的哪个分区中。要做这件事情，可以简单地用循环方式以到达负载均衡，或者根据一些语义分区函数（比如：基于记录中的某些key）

消费者(Consumers)

消费者用一个消费者组名来标识它们自己（PS：相当于给自己贴一个标签，标签的名字是组名，以表明自己属于哪个组），并且每一条发布到主题中的记录只会投递给每个订阅的消费者组中的其中一个消费者实例。消费者实例可能是单独的进程或者在单独的机器上。

如果所有的消费者实例都使用相同的消费者组，那么记录将会在这些消费者之间有效的负载均衡。

如果所有的消费者实例都使用不同的消费者组，那么每条记录将会广播给所有的消费者进程。

上图中其实那个Kafka Cluster换成Topic会更准确一些

一个Kafka集群有2个服务器，4个分区（P0-P3），有两个消费者组。组A中有2个消费者实例，组B中有4个消费者实例。
通常我们会发现，主题不会有太多的消费者组，每个消费者组是一个“逻辑订阅者”（以消费者组的名义订阅主题，而非以消费者实例的名义去订阅）。每个组由许多消费者实例组成，以实现可扩展性和容错。这仍然是发布/订阅，只不过订阅者是一个消费者群体，而非单个进程。

在Kafka中，这种消费方式是通过用日志中的分区除以使用者实例来实现的，这样可以保证在任意时刻每个消费者都是排它的消费，即“公平共享”。Kafka协议动态的处理维护组中的成员。如果有心的实例加入到组中，它们将从组中的其它成员那里接管一些分区；如果组中有一个实例死了，那么它的分区将会被分给其它实例。

（画外音：什么意思呢？举个例子，在上面的图中，4个分区，组A有2个消费者，组B有4个消费者，那么对A来讲组中的每个消费者负责4/2=2个分区，对组B来说组中的每个消费者负责4/4=1个分区，而且同一时间消息只能被组中的一个实例消费。如果组中的成员数量有变化，则重新分配。）

Kafka只提供分区下的记录的总的顺序，而不提供主题下不同分区的总的顺序。每个分区结合按key划分数据的能力排序对大多数应用来说是足够的。然而，如果你需要主题下总的记录顺序，你可以只使用一个分区，这样做的做的话就意味着每个消费者组中只能有一个消费者实例。

保证

在一个高级别的Kafka给出下列保证：

被一个生产者发送到指定主题分区的消息将会按照它们被发送的顺序追加到分区中。也就是说，如果记录M1和M2是被同一个生产者发送到同一个分区的，而且M1是先发送的，M2是后发送的，那么在分区中M1的偏移量一定比M2小，并且M1出现在日志中的位置更靠前。
一个消费者看到记录的顺序和它们在日志中存储的顺序是一样的。
对于一个副本因子是N的主题，我们可以容忍最多N-1个服务器失败，而不会丢失已经提交给日志的任何记录。

Spring Kafka

Spring提供了一个“模板”作为发送消息的高级抽象。它也通过使用@KafkaListener注释和“监听器容器”提供对消息驱动POJOs的支持。这些库促进了依赖注入和声明式的使用。

<dependency>
    <groupId>org.springframework.kafka</groupId>
    <artifactId>spring-kafka</artifactId>
    <version>2.1.10.RELEASE</version>
</dependency>

纯java方式

package com.lucifer.kafka.example;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.IntegerDeserializer;
import org.apache.kafka.common.serialization.IntegerSerializer;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.kafka.core.*;
import org.springframework.kafka.listener.KafkaMessageListenerContainer;
import org.springframework.kafka.listener.MessageListener;
import org.springframework.kafka.listener.config.ContainerProperties;

import java.util.HashMap;
import java.util.Map;

public class PureJavaDemo {

    /**
     * 生产者配置
     */
    private static Map<String, Object> senderProps() {
        Map<String, Object> props = new HashMap<>();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "127.0.0.1:9093");
        props.put(ProducerConfig.RETRIES_CONFIG, 0);
        props.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, IntegerSerializer.class);
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        return props;
    }

    /**
     * 消费者配置
     */
    private static Map<String, Object> consumerProps() {
        Map<String, Object> props = new HashMap<>();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "127.0.0.1:9093");
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "hello");
        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);
        props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "100");
        props.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, "15000");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, IntegerDeserializer.class);
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        return props;
    }

    /**
     * 发送模板配置
     */
    private static KafkaTemplate<Integer, String> createTemplate() {
        Map<String, Object> senderProps = senderProps();
        ProducerFactory<Integer, String> producerFactory = new DefaultKafkaProducerFactory<>(senderProps);
        KafkaTemplate<Integer, String> kafkaTemplate = new KafkaTemplate<>(producerFactory);
        return kafkaTemplate;
    }

    /**
     * 消息监听器容器配置
     */
    private static KafkaMessageListenerContainer<Integer, String> createContainer() {
        Map<String, Object> consumerProps = consumerProps();
        ConsumerFactory<Integer, String> consumerFactory = new DefaultKafkaConsumerFactory<>(consumerProps);
        //设置主题
        ContainerProperties containerProperties = new ContainerProperties("test");
        KafkaMessageListenerContainer<Integer, String> container = new KafkaMessageListenerContainer<>(consumerFactory, containerProperties);
        return container;
    }

    public static void main(String[] args) throws InterruptedException {
        String topic1 = "test"; //  主题

        KafkaMessageListenerContainer container = createContainer();
        ContainerProperties containerProperties = container.getContainerProperties();
        containerProperties.setMessageListener(new MessageListener<Integer, String>() {
            @Override
            public void onMessage(ConsumerRecord<Integer, String> record) {
                System.out.println("Received: " + record);
            }
        });
        container.setBeanName("testAuto");

        container.start();

        KafkaTemplate<Integer, String> kafkaTemplate = createTemplate();
        //设置生产者默认主题
        kafkaTemplate.setDefaultTopic(topic1);
        //发往默认主题
        kafkaTemplate.sendDefault(0, "foo");
        kafkaTemplate.sendDefault(2, "bar");
        kafkaTemplate.sendDefault(0, "baz");
        kafkaTemplate.sendDefault(2, "qux");
        //发往主题“test”
        kafkaTemplate.send("test", 0, "foo2");

        kafkaTemplate.flush();
        container.stop();

        System.out.println("结束");
    }
}

SpringBoot方式

package com.lucifer.kafka.example;

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.core.KafkaTemplate;

@Configuration
public class JavaConfigurationDemo {

    @KafkaListener(topics = "test")
    public void listen(ConsumerRecord<String, String> record) {
        System.out.println("收到消息: " + record);
    }

    @Bean
    public CommandLineRunner commandLineRunner() {
        return new MyRunner();
    }

    class MyRunner implements CommandLineRunner {

        @Autowired
        private KafkaTemplate<String, String> kafkaTemplate;

        @Override
        public void run(String... args) throws Exception {
            kafkaTemplate.send("test", "foo1");
            kafkaTemplate.send("test", "foo2");
            kafkaTemplate.send("test", "foo3");
            kafkaTemplate.send("test", "foo4");
        }
    }
}

application.properties配置

spring.kafka.bootstrap-servers=127.0.0.1:9092
spring.kafka.consumer.group-id=world

生产者

package com.lucifer.kafka.example.send;

import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.IntegerSerializer;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.core.DefaultKafkaProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.core.ProducerFactory;

import java.util.HashMap;
import java.util.Map;

@Configuration
public class Config {

    public Map<String, Object> producerConfigs() {
        Map<String, Object> props = new HashMap<>();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "127.0.0.1:9092");
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, IntegerSerializer.class);
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        return props;
    }

    public ProducerFactory<Integer, String> producerFactory() {
        return new DefaultKafkaProducerFactory<>(producerConfigs());
    }

    @Bean
    public KafkaTemplate<Integer, String> kafkaTemplate() {
        return new KafkaTemplate<Integer, String>(producerFactory());
    }

}

package com.lucifer.kafka.example.send;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.support.SendResult;
import org.springframework.stereotype.Component;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.util.concurrent.ListenableFutureCallback;

@Component
public class MyCommandLineRunner implements CommandLineRunner {

    @Autowired
    private KafkaTemplate<Integer, String> kafkaTemplate;

    public void sendTo(Integer key, String value) {
        ListenableFuture<SendResult<Integer, String>> listenableFuture = kafkaTemplate.send("test", key, value);
        listenableFuture.addCallback(new ListenableFutureCallback<SendResult<Integer, String>>() {
            @Override
            public void onFailure(Throwable throwable) {
                System.out.println("发送失败啦");
                throwable.printStackTrace();
            }

            @Override
            public void onSuccess(SendResult<Integer, String> sendResult) {
                System.out.println("发送成功，" + sendResult);
            }
        });
    }

    @Override
    public void run(String... args) throws Exception {
        sendTo(1, "aaa");
        sendTo(2, "bbb");
        sendTo(3, "ccc");
    }
}

消费者

package com.lucifer.kafka.example.receive;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.common.serialization.IntegerDeserializer;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.annotation.TopicPartition;
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.config.KafkaListenerContainerFactory;
import org.springframework.kafka.core.ConsumerFactory;
import org.springframework.kafka.core.DefaultKafkaConsumerFactory;
import org.springframework.kafka.listener.ConcurrentMessageListenerContainer;
import org.springframework.kafka.listener.config.ContainerProperties;
import org.springframework.kafka.support.Acknowledgment;
import org.springframework.kafka.support.KafkaHeaders;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.messaging.handler.annotation.Payload;

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

@Configuration
public class ConfigConsumer {

    @Bean
    public KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<Integer, String>> kafkaListenerContainerFactory() {
        ConcurrentKafkaListenerContainerFactory<Integer, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(consumerFactory());
        factory.setConcurrency(3);
        ContainerProperties containerProperties = factory.getContainerProperties();
        containerProperties.setPollTimeout(2000);
//        containerProperties.setAckMode(AbstractMessageListenerContainer.AckMode.MANUAL_IMMEDIATE);
        return factory;
    }

    private ConsumerFactory<Integer,String> consumerFactory() {
        return new DefaultKafkaConsumerFactory<>(consumerProps());
    }

    private Map<String, Object> consumerProps() {
        Map<String, Object> props = new HashMap<>();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "127.0.0.1:9092");
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "hahaha");
//        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, IntegerDeserializer.class);
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        return props;
    }


    @KafkaListener(topics = "test")
    public void listen(String data) {
        System.out.println("listen 收到: " + data);
    }


    @KafkaListener(topics = "test", containerFactory = "kafkaListenerContainerFactory")
    public void listen2(String data, Acknowledgment ack) {
        System.out.println("listen2 收到: " + data);
        ack.acknowledge();
    }

    @KafkaListener(topicPartitions = {@TopicPartition(topic = "test", partitions = "0")})
    public void listen3(ConsumerRecord<?, ?> record) {
        System.out.println("listen3 收到: " + record.value());
    }


    @KafkaListener(id = "xyz", topics = "test")
    public void listen4(@Payload String foo,
                        @Header(KafkaHeaders.RECEIVED_MESSAGE_KEY) Integer key,
                        @Header(KafkaHeaders.RECEIVED_PARTITION_ID) int partition,
                        @Header(KafkaHeaders.RECEIVED_TOPIC) String topic,
                        @Header(KafkaHeaders.OFFSET) List<Long> offsets) {
        System.out.println("listen4 收到: ");
        System.out.println(foo);
        System.out.println(key);
        System.out.println(partition);
        System.out.println(topic);
        System.out.println(offsets);
    }
}

posted @ 2020-03-05 16:20 江舟阅读(150) 评论(0) 收藏举报

刷新页面返回顶部

江舟