Kafka 完全入门指南：从零开始理解消息队列与 Kafka

最新推荐文章于 2026-05-08 06:18:39 发布
原创 最新推荐文章于 2026-05-08 06:18:39 发布 · 428 阅读 · 7 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#kafka

一、什么是消息队列？—— 用生活场景秒懂

1.1 一个简单的比喻

想象你去银行办业务。如果没有叫号机，所有人挤在窗口前，场面非常混乱。但有了叫号机，你只需要取个号，安心等待，工作人员按顺序处理。

消息队列（Message Queue，简称 MQ） 就是计算机世界里的"叫号系统"：

角色生活类比技术含义
📦 生产者（Producer）快递员/寄信人发送消息的一方
🙋 消费者（Consumer）取件人/收信人接收、处理消息的一方
🏢 Broker（服务器）快递柜/邮局暂存消息的中间人
📬 消息（Message）包裹/信件需要传递的数据
📋 队列（Queue）排队队伍先进先出（FIFO）的容器

一句话总结：消息队列让不同的服务、进程、线程之间实现 解耦通信 ——发送方不用等待接收方处理完才继续干活。

1.2 为什么需要消息队列？—— 五大使用场景

如果服务 A 直接调用服务 B，一旦 B 挂了或处理不过来，A 也跟着出问题。加入消息队列后，A 和 B 就 解耦 了——即使 B 暂时不工作，消息也不会丢失，等 B 恢复后继续处理。

场景生活类比技术说明
异步处理网购下单后不用站在门口等快递用户注册后，发短信、邮件等后台异步完成，用户不用等
流量削峰高速公路收费站限流防拥堵秒杀场景：MQ 挡住洪水般请求，后端按能力慢慢处理
服务解耦快递员不需要认识收件人，只管放快递柜订单系统发消息，库存/物流系统各自取消息处理
发布订阅微信公众号发文，所有粉丝都能看到游戏跨服广播："全服还剩3把屠龙刀"
高并发缓冲水库蓄水，下游匀速放水日志采集、监控数据上报，Kafka 缓冲高并发数据
异步 vs 同步处理对比

结论：异步处理让原本 200ms 的操作缩短到约 50ms，大幅提升系统响应速度！

1.3 两种消息模型

特性点对点模型发布/订阅模型
消息接收者只有一个消费者能收到所有订阅者都能收到
类似于线程池分工课堂通知/广播

1.4 三大保障机制

机制作用
ACK 确认机制消费者处理完消息后回复"收到"，队列才删除消息。若消费者宕机未回复，消息会重发给其他消费者
消息持久化消息写入磁盘，即使服务器宕机重启，消息不丢失
顺序性保证FIFO 特性确保消息按发送顺序被处理

二、Kafka 是什么？—— 消息队列界的"高速公路"

2.1 一句话定义

Kafka 是 Apache 开源的 分布式消息队列系统，由 LinkedIn 开发，专为 高吞吐量、分布式、可持久化 的场景设计。每秒可处理 10万级 消息，特别适合大数据场景。

2.2 主流消息队列对比

特性RabbitMQRocketMQKafkaZeroMQ
吞吐量万级10万级10万级百万级
延迟微秒级（最低）毫秒级毫秒级以内微秒/毫秒级
可用性高（主从架构）非常高（分布式）非常高（分布式+多副本）嵌入式，非独立服务
消息可靠性基本不丢可做到零丢失可做到零丢失—
适用场景对延迟要求极高MQ功能全面，扩展性好大数据实时计算、日志采集嵌入进程内
开发语言ErlangJavaScala/JavaC

总结：如果你的场景是 大数据实时处理、日志采集、流计算，Kafka 是首选。

三、Kafka 架构详解 —— 理解核心术语

3.1 整体架构图

3.2 核心术语速查表

术语通俗解释生活类比
BrokerKafka 的一台服务器，多台 Broker 组成集群邮局的分支网点
Cluster多个 Broker 组成的集群整个邮政系统
Topic（主题）消息的"分类标签"，生产者和消费者面向同一个 Topic 通信信件分类（家书/公文/广告）
Partition（分区）一个 Topic 被切成多个分区，分散在不同 Broker 上，提高并发能力一个信箱有多个格子，并行处理
Offset（偏移量）消费者读到哪条消息的"书签"，重启后从上次位置继续读书签，记录读到了第几页
Replication（副本）每个分区的数据可以复制多份，防止数据丢失重要文件多复印几份放不同地方
Leader每个分区多副本中的"老大"，负责所有读写操作原件
FollowerLeader 的"小弟"，只负责同步数据。Leader 挂了，Follower 自动上位复印件
Consumer Group（消费者组）一组消费者共同消费一个 Topic，组内每人负责不同分区一个部门的多位同事共同处理邮件
ZooKeeperKafka 的"管家"，负责管理集群状态、Leader 选举等邮政系统的总调度中心

3.3 消息的三级结构

Topic（主题）
  ├── Partition 0  →  [消息0, 消息1, 消息2, ...]   ← 每条消息有 Offset
  ├── Partition 1  →  [消息0, 消息1, ...]
  └── Partition 2  →  [消息0, 消息1, 消息2, 消息3, ...]

💡 关键点：

  • 同一条消息只保存在某一个分区中，不会跨分区重复存储

  • 不同分区的 Offset 是各自独立的

  • 每个 Partition 是一个有序的日志文件，消息只追加写入末尾

3.4 消息从产生到消费的完整旅程

四、生产者（Producer）详解 —— 消息是怎么发出去的？

4.1 为什么需要分区？

一句话：水平扩展 + 负载均衡。

就像一个超市只有一个收银台时处理能力有限，开多个收银台（分区）就能同时服务更多顾客。不同分区可以放在不同机器上，当性能不够时只需加机器即可。

4.2 消息进入哪个分区？—— 分区策略

策略规则适用场景
指定分区直接指定 Partition 编号有特殊业务需求时
按 Key 哈希相同 Key 的消息 一定进同一个分区，保证顺序需要按用户 ID 等维度保序时
轮询（默认）消息依次分配到各分区，负载最均衡无特殊需求时，大部分场景适用

📌 简单记忆：指定了分区用分区，有 Key 用 Key 的哈希，啥都没有就轮询。

4.3 数据可靠性保证 —— ACK 应答机制

Producer 发消息后，需要等 Broker 确认收到。Kafka 提供三种确认级别：

ACK 值含义可靠性性能适用场景
0不等确认，发完就走❌ 最低（可能丢数据）⚡ 延迟最低日志等可容忍丢失的数据
1Leader 写入磁盘就确认⚠️ 中等（Leader 挂了可能丢）🔄 折中一般业务场景
-1 (all)Leader + 所有 Follower 都写入才确认✅ 最高（但可能产生重复消息）🐢 延迟最高核心业务数据，不可丢失

4.4 ISR 机制 —— 谁有资格当"接班人"？

ISR（In-Sync Replica Set） = 和 Leader 保持同步的 Follower 集合。

  • 只有 ISR 中的 Follower 才有资格在 Leader 挂掉时被选为新 Leader

  • 如果某个 Follower 长时间没同步数据，会被踢出 ISR

  • 超时时间由参数 replica.lag.time.max.ms 控制

4.5 副本机制的关键规则

规则说明
Leader 和 Follower 必须在不同机器上避免单点故障，确保容灾
Follower 不对外提供读服务所有读写都通过 Leader（不像 MongoDB 可以从备份读）
Leader 挂掉后自动切换ZooKeeper 感知并从 ISR 中选出新 Leader
3 个副本是生产环境推荐值既保证可靠性，又不过度浪费资源
副本数量 不能大于 Broker 数量否则创建 Topic 会失败

五、消费者（Consumer）详解 —— 消息是怎么被消费的？

5.1 Pull（拉取）模式

Kafka 的 Consumer 采用 Pull 模式 从 Broker 主动拉取数据：

特点说明
✅ 优点消费者按自己的能力消费，不会被撑爆
⚠️ 缺点如果没数据，会空转浪费资源
🔧 解决方案Kafka 提供 timeout 参数——没数据就等一会儿再返回

5.2 Consumer Group 的精妙设计

Kafka 用 Consumer Group（消费者组） 这一个机制，同时实现了两种消息模型：

核心规则：

  • ✅ 所有消费者在同一个 Group → 实现「消息队列」模型（一条消息只被一个消费者处理）

  • ✅ 每个消费者在不同的 Group → 实现「发布/订阅」模型（一条消息被所有消费者处理）

  • 🔒 一个分区只能被同一 Group 内的一个消费者消费（避免重复消费）

  • 🔓 不同消费者组之间互不影响（各组各读各的）

5.3 分区分配策略

当 Consumer Group 内有多个消费者时，如何决定谁消费哪个分区？

Range 策略（默认）

按主题分配。分区数 ÷ 消费者数，除不尽则前面的消费者多分一个。

场景分区分配结果
10 分区，3 消费者C1→[0,1,2,3]　C2→[4,5,6]　C3→[7,8,9]
11 分区，3 消费者C1→[0,1,2,3]　C2→[4,5,6,7]　C3→[8,9,10]

⚠️ 弊端：当订阅多个 Topic 时，前面的消费者总是多消费，分配不均。

RoundRobin 策略（轮询）

将所有 Topic 的所有分区打散排序后，轮流分配给消费者。分配最大差别仅为 1 个分区，更均衡。

⚠️ 前提：所有消费者必须订阅相同的 Topic 集合，否则可能分配混乱。

5.4 消费可靠性 —— Offset 管理

提交方式说明风险
enable.auto.commit = true自动提交 Offset（默认）可能丢消息或重复消费
手动提交消费完成后主动提交更安全，高可靠场景推荐

📌 核心原则：宁愿重复消费，也不丢消息。

六、开发环境搭建 —— 手把手教你装 Kafka

6.1 安装流程总览

6.2 安装 Java 环境

# 解压 JDK
tar -zxvf jdk-8u291-linux-x64.tar.gz
​
# 移动到标准目录
sudo mkdir /usr/lib/jdk
sudo mv jdk1.8.0_291 /usr/lib/jdk/
​
# 配置环境变量（编辑 /etc/profile，末尾添加）
export JAVA_HOME=/usr/lib/jdk/jdk1.8.0_291
export JRE_HOME=${JAVA_HOME}/jre
export CLASSPATH=.:${JAVA_HOME}/lib:${JRE_HOME}/lib
export PATH=${JAVA_HOME}/bin:$PATH
​
# 生效并验证
source /etc/profile
java -version

6.3 安装并启动 Kafka

# 下载并解压
wget https://archive.apache.org/dist/kafka/2.0.0/kafka_2.11-2.0.0.tgz
tar -zxvf kafka_2.11-2.0.0.tgz
cd kafka_2.11-2.0.0
​
# 启动 ZooKeeper（默认端口 2181）
sh bin/zookeeper-server-start.sh -daemon config/zookeeper.properties
​
# 修改 Kafka 配置（config/server.properties）确保：
# zookeeper.connect=localhost:2181
​
# 启动 Kafka（默认端口 9092）
sh bin/kafka-server-start.sh -daemon config/server.properties

6.4 Topic 操作命令速查

# 创建 Topic（1个分区，1个副本）
sh kafka-topics.sh --create --zookeeper localhost:2181 \
    --replication-factor 1 --partitions 1 --topic test
​
# 查看所有 Topic
sh kafka-topics.sh --list --zookeeper localhost:2181
​
# 查看 Topic 详细信息
sh kafka-topics.sh --describe --zookeeper localhost:2181 --topic test
​
# 增加分区数（只能增不能减！）
sh kafka-topics.sh --zookeeper localhost:2181 --topic test \
    --alter --partitions 3
​
# 删除 Topic（需要先设置 delete.topic.enable=true）
sh kafka-topics.sh --zookeeper localhost:2181 --delete --topic test

6.5 收发消息测试

# 终端1：启动生产者（输入消息后回车发送）
sh kafka-console-producer.sh --broker-list 127.0.0.1:9092 --topic test
> Hello Kafka!
> 你好世界!
​
# 终端2：启动消费者（从头开始消费）
sh kafka-console-consumer.sh --bootstrap-server 127.0.0.1:9092 \
    --topic test --from-beginning

  • 副本数不能大于 Broker 数量，否则创建 Topic 会失败

  • 分区数只能增加不能减少，如需减少只能删除 Topic 重建

  • 删除 Topic 需要在 server.properties 中设置 delete.topic.enable=true

七、C++ 操作 Kafka 实战 —— 使用 librdkafka

7.1 librdkafka 库安装

librdkafka 是 Kafka 的高性能 C/C++ 客户端库。

git clone https://github.com/edenhill/librdkafka.git
cd librdkafka
git checkout v1.7.0
./configure
make
sudo make install
sudo ldconfig

7.2 核心类关系图

7.3 回调类速查

类名作用
RdKafka::DeliveryReportCb投递报告回调——消息发送成功/失败时触发
RdKafka::EventCb事件回调——错误、统计、日志等
RdKafka::RebalanceCb消费者组再平衡回调——分区重新分配时触发
RdKafka::PartitionerCb自定义分区器回调——决定消息进入哪个分区

7.4 Producer 开发流程

完整 Producer 示例代码：

#include "rdkafkacpp.h"
#include <iostream>
#include <string>
​
// 1. 投递报告回调：消息发送成功/失败时调用
class ProducerDeliveryReportCb : public RdKafka::DeliveryReportCb {
public:
    void dr_cb(RdKafka::Message &message) {
        if (message.err())
            std::cerr << "❌ 发送失败: " << message.errstr() << std::endl;
        else
            std::cerr << "✅ 发送成功 topic=" << message.topic_name()
                      << " partition=" << message.partition()
                      << " offset=" << message.offset() << std::endl;
    }
};
​
// 2. 自定义 Hash 分区器（可选）
class HashPartitionerCb : public RdKafka::PartitionerCb {
public:
    int32_t partitioner_cb(const RdKafka::Topic *topic, const std::string *key,
                           int32_t partition_cnt, void *msg_opaque) {
        return generate_hash(key->c_str(), key->size()) % partition_cnt;
    }
private:
    static unsigned int generate_hash(const char *str, size_t len) {
        unsigned int hash = 5381;
        for (size_t i = 0; i < len; i++)
            hash = ((hash << 5) + hash) + str[i];
        return hash;
    }
};
​
int main() {
    std::string errstr;
​
    // 创建全局配置
    RdKafka::Conf *conf = RdKafka::Conf::create(RdKafka::Conf::CONF_GLOBAL);
    conf->set("bootstrap.servers", "192.168.0.105:9092", errstr);
​
    // 注册投递报告回调
    ProducerDeliveryReportCb dr_cb;
    conf->set("dr_cb", &dr_cb, errstr);
​
    // 创建 Topic 配置 & 注册自定义分区回调
    RdKafka::Conf *tconf = RdKafka::Conf::create(RdKafka::Conf::CONF_TOPIC);
    HashPartitionerCb partitioner_cb;
    tconf->set("partitioner_cb", &partitioner_cb, errstr);
​
    // 创建 Producer 和 Topic
    RdKafka::Producer *producer = RdKafka::Producer::create(conf, errstr);
    RdKafka::Topic *topic = RdKafka::Topic::create(producer, "test", tconf, errstr);
​
    // 发送消息
    std::string msg = "Hello Kafka";
    std::string key = "mykey";
    producer->produce(topic, RdKafka::Topic::PARTITION_UA,
                      RdKafka::Producer::RK_MSG_COPY,
                      (void*)msg.data(), msg.size(), &key, NULL);
    producer->poll(0);
    producer->flush(5000);  // 等待所有消息发送完成
​
    // 清理资源
    delete topic;
    delete producer;
    delete tconf;
    delete conf;
    RdKafka::wait_destroyed(5000);
    return 0;
}

7.5 Consumer 开发流程

完整 Consumer 示例代码：

#include "rdkafkacpp.h"
#include <iostream>
#include <vector>
#include <string>

// 再平衡回调：分区重新分配时触发
class ConsumerRebalanceCb : public RdKafka::RebalanceCb {
public:
    void rebalance_cb(RdKafka::KafkaConsumer *consumer,
                      RdKafka::ErrorCode err,
                      std::vector<RdKafka::TopicPartition*> &partitions) {
        if (err == RdKafka::ERR__ASSIGN_PARTITIONS)
            consumer->assign(partitions);    // 分配分区
        else
            consumer->unassign();            // 撤销分配
    }
};

// 消息处理函数
void msg_consume(RdKafka::Message *msg) {
    switch (msg->err()) {
    case RdKafka::ERR_NO_ERROR:
        std::cout << "📬 收到消息: topic=" << msg->topic_name()
                  << " partition=" << msg->partition()
                  << " offset=" << msg->offset()
                  << " 内容=" << (char*)msg->payload() << std::endl;
        break;
    case RdKafka::ERR__TIMED_OUT:
        break;  // 超时，正常情况
    default:
        std::cerr << "❌ 消费错误: " << msg->errstr() << std::endl;
    }
}

int main() {
    std::string errstr;

    // 创建配置
    RdKafka::Conf *conf = RdKafka::Conf::create(RdKafka::Conf::CONF_GLOBAL);
    conf->set("bootstrap.servers", "192.168.0.105:9092", errstr);
    conf->set("group.id", "testGroup", errstr);       // 必须设置消费者组

    // 注册再平衡回调
    ConsumerRebalanceCb rebalance_cb;
    conf->set("rebalance_cb", &rebalance_cb, errstr);

    // Topic 配置：从最新消息开始消费
    RdKafka::Conf *tconf = RdKafka::Conf::create(RdKafka::Conf::CONF_TOPIC);
    tconf->set("auto.offset.reset", "latest", errstr);
    conf->set("default_topic_conf", tconf, errstr);

    // 创建消费者
    RdKafka::KafkaConsumer *consumer = RdKafka::KafkaConsumer::create(conf, errstr);

    // 订阅 Topic
    std::vector<std::string> topics = {"test", "test2"};
    consumer->subscribe(topics);

    // 消费循环
    while (true) {
        RdKafka::Message *msg = consumer->consume(1000);  // 等待1秒
        msg_consume(msg);
        delete msg;  // 及时释放，避免内存泄漏
    }

    // 关闭并清理
    consumer->close();
    delete consumer;
    delete tconf;
    delete conf;
    RdKafka::wait_destroyed(5000);
    return 0;
}

7.6 CMake 构建配置

cmake_minimum_required(VERSION 2.8)
project(KafkaDemo)
​
set(CMAKE_CXX_STANDARD 11)
​
# Kafka 头文件和库路径
include_directories(/usr/local/include/librdkafka)
link_directories(/usr/local/lib)
​
aux_source_directory(. SOURCE)
add_executable(${PROJECT_NAME} ${SOURCE})
​
# 链接 librdkafka 的 C++ 库
target_link_libraries(${PROJECT_NAME} rdkafka++)

7.7 produce() 函数的 msgflags 参数

标志含义
RK_MSG_COPY拷贝消息数据，produce 后原始数据可以安全释放
RK_MSG_FREEproduce 完成后由 librdkafka 负责释放 payload 内存
RK_MSG_BLOCK消息队列满时阻塞等待（⚠️ 注意死锁风险）

⚠️ RK_MSG_FREE 和 RK_MSG_COPY 互斥，只能选一个。

7.8 librdkafka 常用缩略语

缩写全称说明
rdRapid Development库前缀
rkRdKafkaKafka 相关结构
rkbRdKafka BrokerBroker 代理
rkoRdKafka Operation操作对象
rkmRdKafka Message消息对象
topparTopic Partition主题分区组合

八、常用配置参数速查

8.1 全局配置（重点参数）

参数默认值说明
bootstrap.servers—Broker 地址列表（必填）
group.id—消费者组 ID（Consumer 必填）
acks / request.required.acks1ACK 应答级别：0 / 1 / -1
message.max.bytes1000000最大消息大小（约1MB）
enable.auto.committrue是否自动提交 Offset
auto.commit.interval.ms5000自动提交 Offset 间隔（毫秒）
session.timeout.ms30000消费者组会话超时（30秒）
heartbeat.interval.ms1000心跳间隔（1秒）
max.partition.fetch.bytes1MB每分区最大拉取大小
security.protocolplaintext通信协议（可选 ssl / sasl）

8.2 Topic 配置（重点参数）

参数默认值说明
auto.offset.resetlargest无初始 Offset 时的策略：earliest / latest
compression.codecinherit消息压缩算法：none / gzip / snappy / lz4
message.timeout.ms300000消息发送超时（5分钟）
auto.commit.enabletrue是否自动提交偏移量

九、知识体系全景图

十、核心结论与最佳实践

✅ 何时选择 Kafka？

  • 日志采集与实时分析

  • 大数据流处理（配合 Spark、Flink）

  • 系统间异步解耦

  • 高并发场景的流量削峰

✅ 生产环境六大建议

序号建议原因
1副本数设为 3既保证可靠性，又不过度浪费资源
2ACK 设为 -1（对于重要数据）确保所有副本都写入，数据不丢失
3消费者手动提交 Offset避免自动提交导致的消息丢失
4Topic 分区数合理规划分区数 ≈ 期望的消费者并发数
5监控 ISR 集合变化ISR 缩小意味着有 Follower 掉队，需告警
6合理设置消息大小限制防止超大消息阻塞队列

✅ C++ 开发五大要点

序号要点
1使用 KafkaConsumer（高级 API）而非 Consumer（低级 API）
2生产者务必注册 DeliveryReportCb 回调以确认消息是否发送成功
3消费者必须设置 group.id
4调用 flush() 确保程序退出前所有消息发送完毕
5及时 delete 消费到的 Message 对象，避免内存泄漏

✅ 学习重点回顾清单

  • Kafka 环境搭建（JDK + ZooKeeper + Kafka）
  • Kafka 基本架构：生产者分区策略、消费者组消费策略
  • C++ 操作 Kafka（librdkafka）核心流程
  • Kafka 命令行工具（./kafka-console-consumer.sh --help）
  • Kafka 存储逻辑：索引 index → log，如何查找消息，零拷贝技术
  • 生产者：强一致性 vs 可用性的权衡（ACK 配置）
  • 消费者：重复消费问题、自动提交 vs 手动提交
  • Broker 内部：HW（High Watermark）与 LEO（Log End Offset）的关系

📚 参考资料

Zookeeper集群+Kafka集群+ELK
下雨天的放羊娃的博客
07-20 1733
目录一.Zookeeper 概述1.Zookeeper定义2.Zookeeper工作机制3.Zookeeper特点4.Zookeeper数据结构5.Zookeeper应用场景6.Zookeeper选举机制二.部署Zookeeper集群1.环境准备2.安装准备2.安装Zookeeper3.启动 Zookeeper 一.Zookeeper 概述 1.Zookeeper定义 Zookeeper是一个开源的分布式的，为分布式框架提供协调服务的Apache项目。 2.Zookeeper工作机制 Zookeeper
Kafka 入门教程（超详细）
热门推荐
西门催学不吹雪
03-29 2万+
文章目录1. Kafka 概述1.1 定义1.2 消息队列1.2.1 传统消息队列的应用场景1.2.2 消息队列的两种形式 1. Kafka 概述 1.1 定义    Kafka 是一个分布式的基于发布/订阅模式的消息队列（Message Queue），主要应用于大数据实时处理领域。 1.2 消息队列 1.2.1 传统消息队列的应用场景 使用消息队列的好处： 解耦 允许独立的扩展或修改两边...
别再傻傻分不清CPK和PPK了！用Excel和Minitab手把手教你搞定过程能力分析
最新发布
weixin_30819085的博客
05-08 285
本文深入解析制造业中CPK与PPK的核心差异，提供从数据准备到实战分析的完整指南。通过Excel和Minitab工具演示，帮助质量工程师准确评估过程能力，识别潜在变异因素，提升产品质量控制效率。特别适合汽车零部件、医疗器件等精密制造领域参考应用。
【分布式技术】消息队列Kafka
liu_xueyin的博客
01-22 2445
主要原因是由于在高并发环境下，同步请求来不及处理，请求往往会发生阻塞。比如大量的请求并发访问数据库，导致行锁表锁，最后请求线程会堆积过多，从而触发 too many connection 错误，引发雪崩效应。我们使用消息队列，通过异步处理请求，从而缓解系统的压力。消息队列常应用于异步处理，流量削峰，应用解耦，消息通讯等场景。
消息队列——kafka基础
qq_51936245的博客
06-04 2839
Kafka 是一个分布式的---基于发布/订阅模式的消息队列（Message Queue），主要应用于 大数据实时处理领域。发布/订阅模式​ 原文链接：https://blog.csdn.net/tjvictor/article/details/5223309​ 定义了一种一对多的依赖关系，让多个订阅者对象同时监听某一个主题对象。这个主题对象在自身状态变化时，会通知所有订阅者对象，使它们能够自动更新自己的状态。​将一个系统分割成一系列相互协作的类有一个很不好的副作用，那就是需要维护相应对象间的一致性。
kafka消息队列
qq_45972323的博客
10-23 1850
消息（Message）是指在应用之间传送的数据，消息可以非常简单，比如只包含文本字符串，也可以更复杂，可能包含嵌入对象。消息队列（Message Queue）是一种应用间的通信方式，消息发送后可以立即返回，有消息系统来确保信息的可靠专递，消息发布者只管把消息发布到 MQ 中而不管谁来取，消息使用者只管从 MQ 中取消息而不管谁发布的，这样发布者和使用者都不用知道对方的存在。RabbitMQ。
Kafka入门指南：从零开始掌握分布式消息队列
ATaylorSu的博客
07-24 1316
Kafka入门指南：从零开始掌握分布式消息队列
Kafka快速入门
m0_61925586的博客
10-04 8898
消息队列(message queue)简称MQ，是一种以“先进先出”的数据结构为基础的消息服务器。消息：两个系统间要传输的数据作用：实现消息的传递原始的数据传递方式：传输效率较低。基于MQ实现消息的传输，如下图所示：上述的数据的传输方式属于异步传输【作为调用方法不用等待被调用方执行完毕就可以接续传递消息】，数据传输的效率较高。services:zookeeper:ports:volumes:services：定义 Docker Compose 文件中的服务。zookeeper。
读懂消息队列：Kafka与RocketMQ
Hopefully Sky的博客
04-16 1万+
3月份学完了极客时间的《消息列队高手课》专栏，专栏讲解了许多消息队列的基础知识并且对Kafka与RocketMQ两种主流消息队列有精彩的对比分析。学完专栏后将所有要点整理为笔记记录下来。
Python之kafka消息队列操作入门
ZONGXP的博客
10-10 7616
1 kafka简介 1.1 什么是kafka kafka是一个分布式、高吞吐量、高扩展性的消息队列系统。kafka最初是由Linkedin公司开发的，后来在2010年贡献给了Apache基金会，成为了一个开源项目。主要应用在日志收集系统和消息系统，相信大家之前也听说过其他的消息队列中间件，比如RabbitMQ、AcitveMQ，其实kafka就是这么一个东西，也可以叫做KafkaMQ。总之，K...
深入浅出理解基于 Kafka 和 ZooKeeper 的分布式消息队列
GitChat
07-03 1万+
消息队列中间件是分布式系统中重要的组件，主要解决应用耦合，异步消息，流量削锋等问题。实现高性能，高可用，可伸缩和最终一致性架构，是大型分布式系统不可缺少的中间件。 消息队列在电商系统、消息通讯、日志收集等应用中扮演着关键作用，以阿里为例，其研发的消息队列(MQ)服务于阿里集团超过11年，在历次天猫双十一活动中支撑了万亿级的数据洪峰，为大规模交易提供了有力保障。 目前在生产环境，使用较多的消息队列有...
kafka快速入门
赵广陆
02-17 3894
目录1 kafka1.1 kafka介绍1.2 kafka安装和配置1.2.1 jdk环境1.2.2 zookeeper安装1.2.3 kafka安装1.3 kafka入门案例1.3.1 创建工程kafka-demo1.3.2 消息生产者1.3.3 消息消费者1.3.4 测试及结论-重要1.3.5 相关概念再介绍1.3.5 生产者详解-理解1.3.6 消费者详解-理解1.4 spring boot集成kafka收发消息1.4.1 环境搭建1.4.2 消息生产者1.4.3 消息消费者1.4.4 测试1.5 传
Kafka 消息队列
BlueProtocolBlog
02-14 3279
什么是Kafka？Kafka是一个基于分布式的、具有高吞吐量的发布、订阅模式的消息队列，主要应用于大数据领域，它可以承担大数据的存储、分析和计算。
消息队列和KafKa
记录一位C++爱好者的笔记
09-24 1734
消息 + 队列 （Message + Queue） 简称MQ。消息队列本质就是个队列，FIFO先入先出，只不过队列中存放的内容是Message，从而叫消息队列。消息队列的主要用途就是在不同的服务、进程、线程之间进行通信。解耦：允许我们独立的扩展或修改队列两边的处理过程。可恢复性：即使一个处理消息的进程挂掉，加入队列中的消息仍然可以在系统恢复后被处理。缓冲：有助于解决生产消息和消费消息的处理速度不一致的情况。灵活性和峰值处理能力：不会因为突发的超负荷的请求而完全崩溃，消息队列能够使关键组件顶住突发的访问压力。
【后端】消息队列--Kafka篇
王大阳的博客
04-02 5111
parition中的消息采用多个小文件段的方式存储，很容易实现消息定期清除或删除已经消费完的文件。通过索引文件可以快速定位message在日志文件中的位置。索引文件通过Mmap技术直接映射到内存中，这样对索引的操作就不需要操作磁盘IO，也减少了数据在内存中的拷贝次数。索引文件采用稀疏存储，可以大幅降低索引文件映射到内存中时占用的内存空间大小。它把所有的消息都变成一个批量的文件，并且进行合理的批量压缩，减少网络IO损耗通过mmap提高I/O速度，写入数据的时候由于。
超详细！ kafka 入门最佳实践
民工哥的博客
02-05 1961
点击下方“民工哥技术之路”，选择“设为星标”回复“1024”获取独家整理的学习资料！认识 kafkakafka简介Kafka 是一个分布式流媒体平台，kafka官网：http://kafk...
Kafka、ActiveMQ、RabbitMQ、RocketMQ四大消息队列优劣对比与选择指南
知行同学
04-08 2783
在分布式系统架构中，消息队列（Message Queue, MQ）扮演着至关重要的角色，它作为异步通信的核心组件，能够实现系统解耦、削峰填谷、数据缓冲等功能。本文将聚焦于四大主流消息队列——Kafka、ActiveMQ、RabbitMQ、RocketMQ，深度剖析它们各自的优缺点，并在最后提供一份详尽的选择指南，以助您在实际项目中做出最适合的选择。：RabbitMQ提供了丰富的交换机类型（直连、主题、头部、扇出），支持复杂的路由规则，能满足多样化的消息分发需求。如需灵活的路由规则，RabbitMQ更适合。
Kafka消息队列
king05yh的博客
06-23 1356
ZooKeeper 是一种分布式协调技术，所谓分布式协调技术主要是用来解决分布式环境当中多个进程之间的同步控制，让他们有序的去访问某种共享资源，防止造成资源竞争(脑裂)的后果。脑裂是指在主备切换时,由于切换不彻底或其他原因,导致客户端和 Slave 误以为出现两个 activemaster,最终使得整个集群处于混乱状态。
大数据Kafka（一）：消息队列和Kafka的基本介绍
Lansonli（蓝深李）的博客
07-31 6013
什么是消息队列消息队列，英文名：Message Queue，经常缩写为MQ。从字面上来理解，消息队列是一种用来存储消息的队列。来看一下下面的代码上述代码，创建了一个队列，先往队列中添加了一个消息，然后又从队列中取出了一个消息。这说明了队列是可以用来存取消息的总结:消息队列指的就是将数据放置到一个队列中, 从队列一端进入, 然后从另一端流出的过程二、消息队列的应用场景消息队列在实际应用中包括如下四个场景：1、应用耦合：多应用间通过消息队列对同一消息进行处理，避免调用接口失败导致整个过程失败；
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值