Kafka流处理平台

一.课程介绍：

1.1 概述

图示：

二. 什么是Kafka

2.1 概述

LinkedIn开源产品[领英]
LinkedIn的产品有：
- 分布式数据同步系统Databus[来源无关的数据也可以同步]
- 高性能计算引擎 Cubert
- Java 异步处理框架ParSeq
- Kafka流处理平台

2.2 Kafka过程：

LinkedIn开发
2011年初开源，加入Apache基金会
2012年从Apache Incubator毕业
Apache顶级开源项目

2.3 官方描述：

消息队列，支持发布订阅
- 数据流存储的平台
- 数据产生的时候就可以对其进行处理
适用功能：[实时流处理和流传输的管道]
- 实时数据流处理管道
- 实时的数据传输管道

说明它是一个消息队列，但又不仅仅是一个消息队列

三. Kafka的设计和结构

3.1 Kafka的基本概念

物理观念
逻辑概念

是隔离的，但有时候也有交叉和交流的；

3.2 关键词

Producer: 消息和数据的生产者，向Kafka的一个topic发布消息的进程/代码/服务
Consumer:消息和数据的消费者，订阅数据(Topic)并且处理其发布的消息的进程/代码/服务
Consumer Group：逻辑概念，对于同一个topic，会广播给不同的group,一个group中，只有一个consumer可以消费该消息；
Broker：物理概念，kafka集群中的每个Kafka节点
Topic：逻辑概念,Kafka消息的类别，对数据进行区分、隔离
Partition:物理概念，Kafka下数据存储的基本单元。一个Topic数据，会被分散存储到多个Partition,每一个partition是有序的；
Replication：同一个Partiton可能会有多个Replica,多个Replica之间数据是一样的；
Replication Leader：一个partition的多个Replica上，需要一个Leader负责该Partition上与Producer和Consumer交互【Leader只有一个】
ReplicaManager:负责管理当前broker所有分区和副本的信息，处理KafkaController发起的一些请求，副本状态的切换、添加/读取消息等；【管理者】

3.3 Kafka的概念延伸

Partiton:
- 每一个Topic被切分为多个Partitons
- 消费者数目少于或等于Partition的数目
- Broker Group中的每一个Broker保存Topic的一个或多个Partitions
- Consumer Group中的仅有一个Consumer读取Topic的一个或多个Partitons，并且是唯一的Consumer
Replication:
- 当集群中有Broker挂掉的情况，系统可以主动地使Replicas提供服务
- 系统默认设置每一个Topic的replication系数为1，可以在创建Topic时单独设置；
Replication特点
- Replication的基本单位是Topic的Partition;
- 所有的读和写都从Leader进，Followers只是做为备份
- Follower必须能够及时复制Leader的数据
- 增加容错性与可扩展性
图示：

这里面，Producers作为消息的提供者，从其他的App途径给予KafkaCluster数据进行消费，在Kafka流平台中可以对数据进行流传输，也可以进行流处理，当操作过后可以通过Connectors API 保存到 DB 数据库中，也可以继续作为流Stream Processors继续进行流传输或流处理【流式交互】，也可以通过Consumers给予其他的App进行消费【比较复杂】

图示：

作为一个消息队列的图示信息，Kafka将Broker的信息、Topic等的信息都是存放在Zookeeper上面；Hadoop Cluster:大数据流处理 Real-time monitoring 实时监控 Data warehouse数据仓库

消息结构：图示：

Offset: 数据偏移 Length: 数据长度 CRC32：校验数据完整性 Magic：判断是否为Kafka消息 attributes: 可选，消息的属性，会有枚举值 Timestamp: 时间戳 Key Length 和Value Length分别为其的长度，而Key和Value 则为其的key,value;

3.4 Kafka特点

分布式：
- 多分区
- 多副本：增强容灾，容错
- 多订阅者
- 基于ZooKeeper调度
高性能：
- 高吞吐量
- 低延迟[实时流处理]
- 高并发
- 时间复杂度为O(1)
持久性和扩展性
- 数据可持久化
- 容错性
- 支持在线水平扩展
- 消息自动平衡：避免消息过于集中在一些个别机器上，导致热点机器，性能降低；

四. Kafka应用场景和实战

4.1 应用场景

消息队列
行为跟踪
元信息监控
日志收集【改变了传统的以文件为中心，让日志"活"起来】
流处理：保存收集一些数据，对接到下游的一些系统，将所有数据串联起来，到最终的展示；
事件源：将状态转移，按照时间序列记录，可以进行回溯
持久性日志(commit log)：在节点中，日志外对日志进行压缩，持久性保存为文件，容错容灾等的功能；

4.2 Kafka的简单案例

概述：
- 环境启动
- 简单生产者
- 简单消费者
下载与安装：
- Zookeeper下载：http://zookeeper.apache.org/release.html#download
- Kafka下载: http://kafka.apache.org/downloads
- 安装：解压，配置环境变量
- Mac便捷安装 brew install Kafka
启动生产者具体操作如下：

如果没有配置环境变量就需要指向zookeeper.properties

启动Zookeeper 输入命令： zookeeper-server-start /usr/local/etc/kafka/zookeeper.properties

启动后展示了端口号等信息

进入文件目录：cd /usr/local/Cellar/kafka/1.1.0/
启动并指向配置 ./bin/kafka-server-start /usr/local/etc/kafka/server.properties
创建一个Topic目录
1. 命令1： cd/usr/local/C
2. 命令2: ./bin/kafka-topics --create --zookeeper localhost:2181 --replication-factor 1 --partitions 3 --topic myfirst-kafka-topic

这里创建Topic的时候，对ip，端口，replicationp-factor，partitions，以及topic名称等进行了配置；

查看topic命令： ./bin/kafka-topics --list --zookeeper localhost:2181

输入这个命令后就会展示Topic的列表，包括刚刚创建的Topic也会显示其中；

我们来看看bin下面有哪些命令可供使用： ./bin/
启动生产者： ./bin/kafka-console-producer --broker-list localhost:9092 --topic myfirst-kafka-topic

启动消费者：

打开新窗口
进入文件目录： cd /usr/local/Cellar/kafka/1.1.0/
创建消费者： ./bin/kafka-console-consumer --bootstrap-server localhost:9092 --topic myfirst-kafka-topic --from-beginning

生产者发送消息：

输入消息 fristMessage [直接在窗口中输入此数据]

消费者接收消息

当生产者发出消息后，消费者窗口会立即显示：

./bin/kafka-console-consumer --bootstrap-server localhost:9092 --topic myfirst-kafka-topic --from-beginning 这串命令是创建一个消费者，在结尾的"–from-beginning"决定了消费者是否从头开始消费，如果不带这个的话，那么消费者被创立后，在它创立之前生产者发出的消息将不会被它所接收并使用；

4.3 kafka代码案例

pom.xml ：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
		 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.imooc.kafka</groupId>
	<artifactId>examples</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>examples</name>
	<description>Demo project for Spring Boot</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.3.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.kafka</groupId>
			<artifactId>spring-kafka</artifactId>
		</dependency>

		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>com.google.code.gson</groupId>
			<artifactId>gson</artifactId>
			<version>2.8.5</version>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<version>3.1.0</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-databind</artifactId>
			<version>2.9.0</version>
		</dependency>
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-annotations</artifactId>
			<version>2.9.0</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>5.0.7.RELEASE</version>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>


</project>

common/ErrorCode.java

package com.imooc.kafka.common;

public class ErrorCode {
    public final static int SUCCESS = 200;
    public final static int EXCEPTION = 500;
}

common/MessageEntity.java

package com.imooc.kafka.common;

import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
@EqualsAndHashCode
public class MessageEntity {
    private String title;
    private String body;

    @Override
    public String toString() {
        return "MessageEntity{" +
                "title='" + title + '\'' +
                ", body='" + body + '\'' +
                '}';
    }
}

common/Response.java

package com.imooc.kafka.common;

import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class Response {
    private int code;
    private String message;

    public Response(int code, String message) {
        this.code = code;
        this.message = message;
    }
}

config/KafkaConsumerConfig.java

package com.imooc.kafka.config;


import com.imooc.kafka.common.MessageEntity;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.EnableKafka;
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.support.serializer.JsonDeserializer;

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

@Configuration
@EnableKafka
public class KafkaConsumerConfig {

    @Value("${kafka.consumer.servers}")
    private String servers;
    @Value("${kafka.consumer.enable.auto.commit}")
    private boolean enableAutoCommit;
    @Value("${kafka.consumer.session.timeout}")
    private String sessionTimeout;
    @Value("${kafka.consumer.auto.commit.interval}")
    private String autoCommitInterval;
    @Value("${kafka.consumer.group.id}")
    private String groupId;
    @Value("${kafka.consumer.auto.offset.reset}")
    private String autoOffsetReset;
    @Value("${kafka.consumer.concurrency}")
    private int concurrency;

    @Bean
    public KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<String, MessageEntity>> kafkaListenerContainerFactory() {
        ConcurrentKafkaListenerContainerFactory<String, MessageEntity> factory = new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(consumerFactory());
        factory.setConcurrency(concurrency);
        factory.getContainerProperties().setPollTimeout(1500);
        return factory;
    }

    private ConsumerFactory<String, MessageEntity> consumerFactory() {
        return new DefaultKafkaConsumerFactory<>(
                consumerConfigs(),
                new StringDeserializer(),
                new JsonDeserializer<>(MessageEntity.class)
        );
    }


    private Map<String, Object> consumerConfigs() {
        Map<String, Object> propsMap = new HashMap<>();
        propsMap.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, servers);
        propsMap.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, enableAutoCommit);
        propsMap.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, autoCommitInterval);
        propsMap.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, sessionTimeout);
        propsMap.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        propsMap.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        propsMap.put(ConsumerConfig.GROUP_ID_CONFIG, groupId);
        propsMap.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, autoOffsetReset);
        return propsMap;
    }
}
~~~java
- config/KafkaProducerConfig.java
~~~java
package com.imooc.kafka.config;

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

import com.imooc.kafka.common.MessageEntity;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.EnableKafka;
import org.springframework.kafka.core.DefaultKafkaProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.core.ProducerFactory;
import org.springframework.kafka.support.serializer.JsonDeserializer;
import org.springframework.kafka.support.serializer.JsonSerializer;

@Configuration
@EnableKafka
public class KafkaProducerConfig {

    @Value("${kafka.producer.servers}")
    private String servers;
    @Value("${kafka.producer.retries}")
    private int retries;
    @Value("${kafka.producer.batch.size}")
    private int batchSize;
    @Value("${kafka.producer.linger}")
    private int linger;
    @Value("${kafka.producer.buffer.memory}")
    private int bufferMemory;


    public Map<String, Object> producerConfigs() {
        Map<String, Object> props = new HashMap<>();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, servers);
        props.put(ProducerConfig.RETRIES_CONFIG, retries);
        props.put(ProducerConfig.BATCH_SIZE_CONFIG, batchSize);
        props.put(ProducerConfig.LINGER_MS_CONFIG, linger);
        props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, bufferMemory);
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        return props;
    }

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

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

consumer/SimpleConsumer.java

package com.imooc.kafka.consumer;


import com.google.gson.Gson;
import com.imooc.kafka.common.MessageEntity;
import lombok.extern.slf4j.Slf4j;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class SimpleConsumer {

    private final Gson gson = new Gson();

    @KafkaListener(topics = "${kafka.topic.default}", containerFactory = "kafkaListenerContainerFactory")
    public void receive(MessageEntity message) {
        log.info(gson.toJson(message));
    }
}

controller/ProduceController.java

package com.imooc.kafka.controller;


import com.google.gson.Gson;
import com.imooc.kafka.common.ErrorCode;
import com.imooc.kafka.common.MessageEntity;
import com.imooc.kafka.common.Response;
import com.imooc.kafka.producer.SimpleProducer;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;


@Slf4j
@RestController
@RequestMapping("/kafka")
public class ProduceController {
    @Autowired
    private SimpleProducer simpleProducer;

    @Value("${kafka.topic.default}")
    private String topic;

    private Gson gson = new Gson();

    @RequestMapping(value = "/hello", method = RequestMethod.GET, produces = {"application/json"})
    public Response sendKafka() {
        return new Response(ErrorCode.SUCCESS, "OK");
    }


    @RequestMapping(value = "/send", method = RequestMethod.POST, produces = {"application/json"})
    public Response sendKafka(@RequestBody MessageEntity message) {
        try {
            log.info("kafka的消息={}", gson.toJson(message));
            simpleProducer.send(topic, "key", message);
            log.info("发送kafka成功.");
            return new Response(ErrorCode.SUCCESS, "发送kafka成功");
        } catch (Exception e) {
            log.error("发送kafka失败", e);
            return new Response(ErrorCode.EXCEPTION, "发送kafka失败");
        }
    }

}

producer/ProducerCallback.java

package com.imooc.kafka.producer;


import com.google.gson.Gson;
import com.imooc.kafka.common.MessageEntity;
import lombok.extern.slf4j.Slf4j;
import org.apache.kafka.clients.producer.RecordMetadata;
import org.springframework.kafka.support.SendResult;
import org.springframework.lang.Nullable;
import org.springframework.util.concurrent.ListenableFutureCallback;

@Slf4j
public class ProducerCallback implements ListenableFutureCallback<SendResult<String, MessageEntity>> {

    private final long startTime;
    private final String key;
    private final MessageEntity message;

    private final Gson gson = new Gson();

    public ProducerCallback(long startTime, String key, MessageEntity message) {
        this.startTime = startTime;
        this.key = key;
        this.message = message;
    }


    @Override
    public void onSuccess(@Nullable SendResult<String, MessageEntity> result) {
        if (result == null) {
            return;
        }
        long elapsedTime = System.currentTimeMillis() - startTime;

        RecordMetadata metadata = result.getRecordMetadata();
        if (metadata != null) {
            StringBuilder record = new StringBuilder();
            record.append("message(")
                    .append("key = ").append(key).append(",")
                    .append("message = ").append(gson.toJson(message)).append(")")
                    .append("sent to partition(").append(metadata.partition()).append(")")
                    .append("with offset(").append(metadata.offset()).append(")")
                    .append("in ").append(elapsedTime).append(" ms");
            log.info(record.toString());
        }
    }

    @Override
    public void onFailure(Throwable ex) {
        ex.printStackTrace();
    }
}

producer/SimpleProducer.java

package com.imooc.kafka.producer;

import com.google.gson.Gson;
import com.imooc.kafka.common.MessageEntity;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.support.SendResult;
import org.springframework.stereotype.Component;
import org.springframework.util.concurrent.ListenableFuture;

@Component
public class SimpleProducer {

    @Autowired
    @Qualifier("kafkaTemplate")
    private KafkaTemplate<String, MessageEntity> kafkaTemplate;

    public void send(String topic, MessageEntity message) {
        kafkaTemplate.send(topic, message);
    }

    public void send(String topic, String key, MessageEntity entity) {
        ProducerRecord<String, MessageEntity> record = new ProducerRecord<>(
                topic,
                key,
                entity);

        long startTime = System.currentTimeMillis();

        ListenableFuture<SendResult<String, MessageEntity>> future = kafkaTemplate.send(record);
        future.addCallback(new ProducerCallback(startTime, key, entity));
    }

}

ExamplesApplication.java 启动类

package com.imooc.kafka;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@EnableAutoConfiguration
@SpringBootApplication
public class ExamplesApplication {

	public static void main(String[] args) {
		SpringApplication.run(ExamplesApplication.class, args);
	}
}

resources/application.properties

#============== kafka ===================
kafka.consumer.zookeeper.connect=127.0.0.1:2181
kafka.consumer.servers=127.0.0.1:9092
kafka.consumer.enable.auto.commit=true
kafka.consumer.session.timeout=6000
kafka.consumer.auto.commit.interval=100
kafka.consumer.auto.offset.reset=latest
kafka.consumer.topic=imooc-kafka
kafka.consumer.group.id=imooc
kafka.consumer.concurrency=10

kafka.producer.servers=127.0.0.1:9092
kafka.producer.retries=0
kafka.producer.batch.size=4096
kafka.producer.linger=1
kafka.producer.buffer.memory=40960

kafka.topic.default=imooc-kafka

源码地址： https://gitee.com/zhang199/kafka_demo

五. Kafka的高级特性

5.1 为什么要支持事务

满足"读取-处理-写入" 模式
流处理需求的不断增强
不准确的数据处理的零容忍度

5.2 数据传输的事务定义

最多一次：消息不会被重复发送，最多被传输一次，但也有可能一次不传输
最少一次：消息不会被漏发送，最少被传输一次，但也有可能被重复传输
精确的一次（Exactly once）:不会漏传输也不会重复传输，每个消息都传输被一次而且仅仅被传输一次，这是大家所期望的；

5.3 事务保证

内部重试问题：Procedure幂等处理
多分区原子写入

5.4 事务保证–避免僵尸实例

每个事务Producer分配一个transactional.id,在进程重新启动时能够识别相同的Producer实例
Kafka增加了一个与transactional.id相关的epoch，存储每个transactional.id内部元数据
一旦epoch被触发，任何具有相同的transactional.id和更旧的epoch的Producer被视为僵尸，Kafka会拒绝来自这些Procedure的后续性事务写入；

简单来说，Kafka会为每个带事务的生产者配一个专属的id，这样有便于区分并且增加的epoch存储了其内部的数据，当进行版本迭代时，也只有最新的生效，而老的版本和已经通过transactional.id识别为僵尸的，直接拒绝事务写入。能让我们更简易的使用Kafka的事务；

5.5 零拷贝简介

网络传输持久性日志块
Java Nio channel.transforTo()方法
Linux sendfile系统调用

5.6 文件传输到网络的公共数据路径(常规拷贝)

操作系统将数据从磁盘读入到内核空间的页缓存
应用程序将数据从内核空间读入到用户空间缓存中
应用程序将数据写回到内核空间到socket缓存中
操作系统将数据从socket缓冲区复制到网卡缓冲区，以便将数据经网络发出；

5.7 零拷贝过程

操作系统将数据从磁盘读入到内核空间的页缓存
将数据的位置和长度的信息的描述符增加至内核空间(socket缓冲区)
操作系统将数据从内核拷贝到网卡缓冲区，以便于将数据经网络发出

5.8 文件传输到网络的公共数据路径演变

在这里插入图片描述

拷贝的过程减少了，提高的效率；

暗余

发布了127 篇原创文章 · 获赞 52 · 访问量 2万+

私信关注

** Kafka流处理快速入门*

Kafka流处理平台

导航：

一.课程介绍：

1.1 概述

二. 什么是Kafka

2.1 概述

2.2 Kafka过程：

2.3 官方描述：

三. Kafka的设计和结构

3.1 Kafka的基本概念

3.2 关键词

3.3 Kafka的概念延伸

3.4 Kafka特点

四. Kafka应用场景和实战

4.1 应用场景

4.2 Kafka的简单案例

4.3 kafka代码案例

五. Kafka的高级特性

5.1 为什么要支持事务

5.2 数据传输的事务定义

5.3 事务保证

5.4 事务保证–避免僵尸实例

5.5 零拷贝简介

5.6 文件传输到网络的公共数据路径(常规拷贝)

5.7 零拷贝过程

5.8 文件传输到网络的公共数据路径演变

猜你喜欢