RabbitMQ Kotlin 教程实战指南:kotlin-java-client 六课全量示例与 Java AMQP 客户端源码解析

原创2026-10-14 10:46:36322 阅读
文章标签:示例工程

RabbitMQ Kotlin 教程实战指南:kotlin-java-client 六课全量示例与 Java AMQP 客户端源码解析

本文基于当前仓库 rabbitmq-tutorials 中的 kotlin-java-client/README.md 及其对应源码,系统讲解如何用 Kotlin(复用 Java AMQP 客户端 amqp-client)跑通 RabbitMQ 官方六套入门教程:从 Hello World 队列、工作队列、发布/订阅、路由、主题到 RPC 远程调用。读完本文,你将掌握 gradle run -P main=... -P argv=... 的完整运行机制、每种交换机的声明与绑定方式,以及消息持久化、手动应答、basicQos、correlationId 等核心 API 的源码级用法,可直接在本地 RabbitMQ 节点上复现全部示例。

一、项目概览:一个"贴近 Java 风格"的最小化 Kotlin 移植

kotlin-java-client 是官方 RabbitMQ Java 教程的 Kotlin 移植版,正如其 README 开篇所描述:"This is a minimalistic Kotlin port of the RabbitMQ tutorials in Java",且代码风格与 Java 版本相当接近("The port is admittedly quite close to Java in terms of code style")。这意味着:

  • 它不是使用纯 Kotlin 多平台客户端(如 kotlin/README.md 中基于 Kourier 的实现),而是直接调用 Java 生态的 com.rabbitmq:amqp-client 客户端库;
  • Kotlin 的顶层 fun main(argv: Array<String>) 函数是每个示例的入口,这与 Java 的 public static void main(String[] args) 一一对应;
  • 目录内所有示例均遵循仓库根 AGENTS.md 中定义的 AMQP 0-9-1 教程统一命名规范:T1 send/receive、T2 new_task/worker、T3 emit_log/receive_logs、T4 emit_log_direct/receive_logs_direct、T5 emit_log_topic/receive_logs_topic、T6 rpc_client/rpc_server。

目录结构与源码清单

kotlin-java-client/
├── README.md                    # 编译与运行说明(本文主体依据)
├── build.gradle                 # Gradle 构建脚本,含自定义 run 任务
├── gradle.properties            # 定义 main / argv 两个空默认属性
├── settings.gradle              # rootProject.name = 'rabbitmq-tutorial'
└── src/main/kotlin/
    ├── Send.kt / Recv.kt                    # T1 Hello World
    ├── NewTask.kt / Worker.kt               # T2 工作队列
    ├── EmitLog.kt / ReceiveLogs.kt          # T3 发布/订阅(fanout)
    ├── EmitLogDirect.kt / ReceiveLogsDirect.kt  # T4 路由(direct)
    ├── EmitLogTopic.kt / ReceiveLogsTopic.kt    # T5 主题(topic)
    ├── RPCServer.kt / RPCClient.kt          # T6 RPC
    └── EmitLogHeader.kt / ReceiveLogHeader.kt   # 附加:headers 交换机示例

二、环境准备:运行前必须满足的前提

根据仓库根 README.md 与 AGENTS.md 的约定,所有教程示例都要求一个运行在 localhost、使用默认配置的 RabbitMQ 节点,默认连接参数为端口 5672、默认账号 guest/guest(seed user 仅限 localhost 使用)。

在编译运行 kotlin-java-client 之前,请确认以下环境:

依赖项 说明
RabbitMQ 节点 运行于 localhost,默认端口 5672,默认账号 guest/guest
JDK 需支持 jvmTarget = "1.8"(即 JDK 8 及以上均可)
Gradle 任意可用的 Gradle 发行版(项目未包含 Gradle Wrapper,直接使用系统 gradle 命令)
Kotlin 插件 由 build.gradle 自动从 Maven Central 拉取 Kotlin 1.8.10 插件

依赖声明位于 build.gradle 的 dependencies 块,共三项:

implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"  // Kotlin 标准库(1.8.10)
implementation "com.rabbitmq:amqp-client:latest.release"                 // RabbitMQ Java 客户端(取最新发布版)
implementation "org.slf4j:slf4j-simple:1.7.25"                           // SLF4J 简单日志实现

注意:amqp-client 的版本被声明为 latest.release,即构建时会解析 Maven Central 上最新的发布版本,因此实际客户端能力以拉取时的最新版为准。

三、编译全部示例

在 kotlin-java-client 目录下执行 README 给出的编译命令:

gradle clean compileKotlin

该命令会先清理旧的构建产物,再编译 src/main/kotlin 下全部 13 个 Kotlin 源文件。编译产物的关键点在于:每个顶层 fun main 都会生成一个以文件名 + Kt 后缀命名的类(例如 Send.kt 生成 SendKt 类),这正是后面 gradle run -P main=Send 能够定位入口的根本原因。

四、运行机制揭秘:-P main=... 与 -P argv=... 如何工作

README 中所有运行命令都形如 gradle run -P main=Recv 或 gradle run -P main=NewTask -P argv="rabbit1 ....",其背后是 build.gradle 中自定义的 run 任务(type: JavaExec):

task run(type: JavaExec, dependsOn: classes) {
    if ("$argv".trim().size() > 0)
        args = "$argv".split(",").toList()
    if ("$main".trim().size() > 0)
        main = "${project.getProperty('main')}Kt"
    classpath = sourceSets.main.runtimeClasspath
}

逐行解读这个任务,就能完全掌握 README 命令的语义:

  1. -P main=ClassName 指定入口类:任务把属性 main 取出后强制拼接后缀 Kt,即 main = "RecvKt"。所以你传 -P main=Recv 实际执行的是 RecvKt 类;如果传 -P main=Recv.kt 或带包名的全限定名,需要自行换算成 xxxKt 形式。
  2. -P argv="a, b, c" 传程序参数:任务把属性 argv 按英文逗号 , 拆分成参数列表。例如 -P argv="info,error" 会生成两个参数 ["info", "error"];-P argv="rabbit1, msg1" 生成 ["rabbit1", " msg1"](注意第二个参数会带一个前导空格,消费端拼接消息时需留意)。
  3. 缺省处理:gradle.properties 预置了 main = 与 argv = 两个空属性,保证未传 -P 时 $main/$argv 均为空字符串,任务跳过对应分支。
  4. 类路径:使用 sourceSets.main.runtimeClasspath,即编译产物 + 全部运行时依赖(amqp-client、slf4j-simple)。

实操提示:不传 -P argv 时,各程序会使用源码内定义的默认值(如 Send 默认发 "Hello World!",EmitLogDirect 默认 severity 为 info),详见下文各节源码分析。

五、Tutorial 1:Hello World(队列收发)

运行步骤

按照 README,先在一个终端启动消费者:

gradle run -P main=Recv

在另一个终端发布消息:

gradle run -P main=Send

源码分析

消费者 Recv.kt 的完整流程:

val factory = ConnectionFactory()
factory.host = "localhost"                       // 连接本机 RabbitMQ
val connection = factory.newConnection()
val channel = connection.createChannel()

channel.queueDeclare(Recv.QUEUE_NAME, false, false, false, null)   // 声明队列 "hello",非持久
println(" [*] Waiting for messages. To exit press CTRL+C")

val consumer = object : DefaultConsumer(channel) {
    override fun handleDelivery(consumerTag: String, envelope: Envelope,
                                properties: AMQP.BasicProperties, body: ByteArray) {
        val message = String(body, charset("UTF-8"))
        println(" [x] Received '$message'")
    }
}
channel.basicConsume(Recv.QUEUE_NAME, true, consumer)   // autoAck = true,自动应答

生产者 Send.kt:

channel.queueDeclare(Send.QUEUE_NAME, false, false, false, null)
val message = "Hello World!"
channel.basicPublish("", Send.QUEUE_NAME, null, message.toByteArray(charset("UTF-8")))
println(" [x] Sent '$message'")
channel.close()
connection.close()

两者都通过 companion object 中的 const val QUEUE_NAME = "hello" 共享队列名,且发送时使用空交换机(默认交换机) basicPublish("", ...),此时路由键即队列名。四个布尔参数依次为 durable(持久化)、exclusive(独占)、autoDelete(自动删除)、arguments,本课全部取 false/null,即非持久、非独占、不自动删除的普通队列。

六、Tutorial 2:工作队列(任务分发与公平调度)

运行步骤

发送一个任务(立即完成,无 "." 字符):

gradle run -P main=NewTask

在独立终端启动一个 Worker:

gradle run -P main=Worker

发送带延时任务——负载中每有一个 . 点号,Worker 就模拟工作 1 秒:

gradle run -P main=NewTask -P argv="rabbit1 ...."

README 特别说明:向同一队列添加更多 Worker 后,消息会以 round robin(轮询) 方式分发。这正是工作队列的核心价值:把耗时任务平均分摊到多个消费者。

源码分析:生产者 NewTask.kt

与 T1 的关键差异在于持久化:

channel.queueDeclare(NewTask.TASK_QUEUE_NAME, true, false, false, null)   // durable = true

val message = NewTask.getMessage(argv)

channel.basicPublish("", NewTask.TASK_QUEUE_NAME,
        MessageProperties.PERSISTENT_TEXT_PLAIN,                          // 持久化消息属性
        message.toByteArray(charset("UTF-8")))
  • 队列名 task_queue 以 durable=true 声明,队列本身在 RabbitMQ 重启后不丢失;
  • 消息使用 MessageProperties.PERSISTENT_TEXT_PLAIN(delivery mode = 2),确保消息写入磁盘;
  • getMessage(argv) 的逻辑是:无参数时默认 "Hello World!",有参数时用空格拼接所有参数(实现见 companion object 内的 joinStrings)。

源码分析:消费者 Worker.kt

Worker 展示了工作队列的三件套:持久队列 + 预取限制 + 手动应答:

channel.queueDeclare(Worker.TASK_QUEUE_NAME, true, false, false, null)
channel.basicQos(1)                                   // 每次只预取 1 条,公平分发

val consumer = object : DefaultConsumer(channel) {
    @Throws(IOException::class)
    override fun handleDelivery(...) {
        val message = String(body, charset("UTF-8"))
        println(" [x] Received '$message'")
        try {
            Worker.doWork(message)                    // 每遇一个 '.' 睡眠 1 秒
        } finally {
            println(" [x] Done")
            channel.basicAck(envelope.deliveryTag, false)   // 手动确认
        }
    }
}
channel.basicConsume(Worker.TASK_QUEUE_NAME, false, consumer)   // autoAck = false

三个要点的源码级解释:

  1. channel.basicQos(1)(公平分发 fair dispatch):默认情况下 RabbitMQ 是轮询分发,但遇到"慢消费者"时可能失衡。basicQos(1) 告诉 Broker 每次只给该消费者 1 条未确认消息,处理完并 ack 后才发下一条,从而保证 Worker 之间按处理能力均分负载;
  2. 手动应答:basicConsume(..., false, ...) 关闭自动应答,处理完成后在 finally 中调用 channel.basicAck(envelope.deliveryTag, false) 显式确认。若 Worker 在处理中途崩溃(未 ack),消息会被重新投递给其他 Worker——这就是"任务不丢失"的保障;
  3. doWork 模拟耗时:for (ch in task.toCharArray()) { if (ch == '.') Thread.sleep(1000) },一个点号睡 1 秒。

七、Tutorial 3:发布/订阅(fanout 交换机广播)

运行步骤

启动日志接收者:

gradle run -P main=ReceiveLogs

发布日志(可传消息内容参数):

gradle run -P main=EmitLog -P argv="rabbit1, msg1"

源码分析:生产者 EmitLog.kt

channel.exchangeDeclare(EmitLog.EXCHANGE_NAME, BuiltinExchangeType.FANOUT)   // 声明 fanout 交换机 "logs"

val message = EmitLog.getMessage(args)
channel.basicPublish(EmitLog.EXCHANGE_NAME, "", null, message.toByteArray()) // 路由键为空
  • 交换机名 logs,类型 BuiltinExchangeType.FANOUT;
  • fanout 交换机的语义:忽略路由键,把消息广播给所有绑定到该交换机的队列;
  • getMessage(args) 无参数时默认 "info: Hello World!",否则空格拼接参数。

源码分析:消费者 ReceiveLogs.kt

channel.exchangeDeclare(ReceiveLogs.EXCHANGE_NAME, BuiltinExchangeType.FANOUT)
val queueName = channel.queueDeclare().queue          // 服务端命名的临时队列
channel.queueBind(queueName, ReceiveLogs.EXCHANGE_NAME, "")   // 以空路由键绑定
  • 临时队列:channel.queueDeclare() 不传队列名时,RabbitMQ 会生成一个随机唯一名称(如 amq.gen-...),并随连接断开自动删除;
  • 绑定:queueBind(queueName, "logs", "") 将该临时队列与 logs 交换机绑定,路由键为空对 fanout 无影响;
  • 消费端同样使用 DefaultConsumer 匿名对象,basicConsume(queueName, true, consumer) 自动应答。

八、Tutorial 4:路由(direct 交换机按 severity 过滤)

运行步骤

订阅多个严重级别(参数用逗号分隔,对应源码中的多个绑定):

gradle run -P main="ReceiveLogsDirect" -P argv="info,error"

发布一条指定 severity 的日志:

gradle run -P main=EmitLogDirect -P argv="error, Run. Run. Or it will explode."

(README 原文中 main=EmitLogDirect 后有一个多余的引号,属笔误,实际命令按上述无引号形式执行。)

源码分析:生产者 EmitLogDirect.kt

channel.exchangeDeclare(EmitLogDirect.EXCHANGE_NAME, BuiltinExchangeType.DIRECT)  // direct_logs

val severity = EmitLogDirect.getSeverity(argv)   // 无参数默认 "info",否则取 argv[0]
val message = EmitLogDirect.getMessage(argv)     // 从 argv[1] 起拼接,缺省 "Hello World!"

channel.basicPublish(EmitLogDirect.EXCHANGE_NAME, severity, null, message.toByteArray(charset("UTF-8")))
  • 交换机 direct_logs,类型 DIRECT;
  • 路由键即 severity(info/warning/error 等),direct 交换机只把消息投递给路由键精确匹配的绑定队列;
  • 注意参数约定:argv[0] 是 severity,argv[1] 起才是消息正文。

源码分析:消费者 ReceiveLogsDirect.kt

channel.exchangeDeclare(ReceiveLogsDirect.EXCHANGE_NAME, BuiltinExchangeType.DIRECT)
val queueName = channel.queueDeclare().queue

if (argv.isEmpty()) {
    System.err.println("Usage: ReceiveLogsDirect [info] [warning] [error]")
    System.exit(1)
}

for (severity in argv) {
    channel.queueBind(queueName, ReceiveLogsDirect.EXCHANGE_NAME, severity)   // 一个队列多个绑定
}
  • 必须至少传一个 severity 参数,否则打印用法说明并以退出码 1 结束;
  • 一个队列可绑定多个路由键:for (severity in argv) 循环里对每个 severity 调用一次 queueBind,从而实现"订阅 info 和 error 两种日志";
  • 消费回调中通过 envelope.routingKey 打印实际路由键:System.out.println(" [x] Received '" + envelope.routingKey + "':'" + message + "'")。

九、Tutorial 5:主题(topic 交换机模式匹配)

运行步骤

订阅匹配 anonymous.* 模式(* 匹配一个单词)的消息:

gradle run -P main=ReceiveLogsTopic -P argv="anonymous.*"

发布路由键为 anonymous.info 的消息:

gradle run -P main=EmitLogTopic -P argv="anonymous.info"

源码分析:生产者 EmitLogTopic.kt

channel.exchangeDeclare(EmitLogTopic.EXCHANGE_NAME, BuiltinExchangeType.TOPIC)  // topic_logs

val routingKey = EmitLogTopic.getRouting(argv)    // 无参数默认 "anonymous.info",否则取 argv[0]
val message = EmitLogTopic.getMessage(argv)       // 从 argv[1] 起拼接

channel.basicPublish(EmitLogTopic.EXCHANGE_NAME, routingKey, null, message.toByteArray(charset("UTF-8")))

源码分析:消费者 ReceiveLogsTopic.kt

channel.exchangeDeclare(ReceiveLogsTopic.EXCHANGE_NAME, BuiltinExchangeType.TOPIC)
val queueName = channel.queueDeclare().queue

if (argv.isEmpty()) {
    System.err.println("Usage: ReceiveLogsTopic [binding_key]...")
    System.exit(1)
}

for (bindingKey in argv) {
    channel.queueBind(queueName, ReceiveLogsTopic.EXCHANGE_NAME, bindingKey)   // 多个模式绑定
}

topic 交换机与通配符规则(RabbitMQ 主题语义):

符号 含义
*(星号) 恰好匹配一个单词(点分隔段),如 anonymous.* 匹配 anonymous.info、anonymous.error
#(井号) 匹配零个或多个单词,如 kern.# 匹配 kern、kern.info、kern.critical.error
精确词 与 direct 一样精确匹配该段,如 anonymous.info

例如:绑定 "anonymous.*" 会收到 anonymous.info、anonymous.error,但收不到 anonymous.critical.error(两段点号)。结合仓库内 Java 版 java/README.md 的教程五示例可以看到更丰富的用法,例如 ReceiveLogsTopic "kern.*" "*.critical" 可同时绑定多个模式(多个绑定键之间空格分隔),这与本目录 README 用 -P argv 逗号分隔传多个绑定键是等价的。

十、Tutorial 6:RPC(远程过程调用:斐波那契计算)

运行步骤

终端一启动 RPC 服务端:

gradle run -P main=RPCServer

终端二启动 RPC 客户端(默认请求 fib(30)):

gradle run -P main=RPCClient

服务端源码 RPCServer.kt

channel.queueDeclare(RPCServer.RPC_QUEUE_NAME, false, false, false, null)   // rpc_queue
channel.basicQos(1)

val consumer = object : DefaultConsumer(channel) {
    override fun handleDelivery(consumerTag: String, envelope: Envelope,
                                properties: AMQP.BasicProperties, body: ByteArray) {
        val replyProps = AMQP.BasicProperties.Builder()
                .correlationId(properties.correlationId)     // 回传相同的 correlationId
                .build()
        val message = String(body, charset("UTF-8"))
        val n = Integer.parseInt(message)
        println(" [.] fib($message)")
        val response = RPCServer.fib(n).toString()
        channel.basicPublish("", properties.replyTo, replyProps, response.toByteArray())  // 发回 replyTo 队列
        channel.basicAck(envelope.deliveryTag, false)
    }
}
channel.basicConsume(RPCServer.RPC_QUEUE_NAME, false, consumer)
  • 服务端监听 rpc_queue,手动应答;
  • 收到请求后解析整数 n,调用 companion object 中的迭代版斐波那契 fib(n)(循环实现,非递归);
  • 回传关键:把请求中的 correlationId 原样带回,并把结果发到请求属性里的 replyTo 回调队列;
  • 主线程末尾用 while (true) { synchronized(consumer) { (consumer as Object).wait() } } 挂起,保持进程存活持续消费。

客户端源码 RPCClient.kt

init {
    val factory = ConnectionFactory()
    factory.host = "localhost"
    connection = factory.newConnection()
    channel = connection.createChannel()
    replyQueueName = channel.queueDeclare().queue        // 临时回调队列
}

fun call(message: String): String {
    val corrId = UUID.randomUUID().toString()            // 唯一关联 ID
    val props = AMQP.BasicProperties.Builder()
            .correlationId(corrId)
            .replyTo(replyQueueName)
            .build()
    channel.basicPublish("", requestQueueName, props, message.toByteArray(charset("UTF-8")))

    val response = ArrayBlockingQueue<String>(1)          // 阻塞等待响应
    channel.basicConsume(replyQueueName, true, object : DefaultConsumer(channel) {
        override fun handleDelivery(...) {
            if (properties.correlationId == corrId) {     // 只接受匹配 corrId 的响应
                response.offer(String(body, charset("UTF-8")))
            }
        }
    })
    return response.take()                                 // 线程安全地拿到结果
}

客户端封装了完整的 RPC 协议:UUID 生成 correlationId、replyTo 指向临时回调队列、用 ArrayBlockingQueue<String>(1) 在回调线程与主线程之间传递结果、并通过 correlationId 比对过滤掉其他请求的响应。main 中默认调用 fibonacciRpc.call("30") 并打印结果。该模式可直接推广到任何"请求-应答"场景(如查询服务、计算服务)。

十一、附加示例:headers 交换机(源码中未在 README 列出但可运行)

除 README 记载的六课之外,目录中还包含两个基于 headers 交换机 的完整示例:EmitLogHeader.kt 与 ReceiveLogHeader.kt,交换机名为 header_test。它们同样可用 gradle run -P main=EmitLogHeader 方式运行。

headers 交换机的核心语义:路由不再依赖路由键,而是匹配消息头(headers)键值对。绑定方通过 x-match 头控制匹配策略——x-match = any 表示任意一个头匹配即可,x-match = all(默认)表示所有头都必须匹配。

生产者关键代码(EmitLogHeader.kt):

channel.exchangeDeclare(EmitLogHeader.EXCHANGE_NAME, BuiltinExchangeType.HEADERS)
val builder = AMQP.BasicProperties.Builder()
builder.deliveryMode(MessageProperties.PERSISTENT_TEXT_PLAIN.deliveryMode)  // 持久化投递模式
builder.priority(MessageProperties.PERSISTENT_TEXT_PLAIN.priority)
builder.headers(headers)            // 命令行解析出的键值对
val theProps = builder.build()
channel.basicPublish(EmitLogHeader.EXCHANGE_NAME, "ourTestRoutingKey", theProps, message.toByteArray(...))

源码注释明确指出:headers 交换机下路由键不参与路由,但发送方仍可把信息放进路由键供接收方读取(源码中固定使用 "ourTestRoutingKey")。命令行用法为 EmitLogHeader 消息内容 queueName [headers]...,例如依次传入 message queueName x-match any header1 value1。

消费者关键代码(ReceiveLogHeader.kt):

channel.exchangeDeclare(ReceiveLogHeader.EXCHANGE_NAME, BuiltinExchangeType.HEADERS)
val queueName = channel.queueDeclare(queueInputName, true, false, false, null).queue   // 持久队列
channel.queueBind(queueName, ReceiveLogHeader.EXCHANGE_NAME, routingKeyFromUser, headers)  // 带头绑定

消费端把命令行解析出的头键值对(含 x-match)作为绑定参数传入 queueBind,实现"按消息头路由"。这是官方七课之外对交换机类型的补充演示,适合需要按任意属性路由的场景。

十二、六课核心对象速查表

教程 源文件 交换机(类型) 队列 关键机制
T1 Hello World Send.kt / Recv.kt 默认交换机(空串) hello 空交换机 + 队列名即路由键,自动应答
T2 工作队列 NewTask.kt / Worker.kt 默认交换机 task_queue(持久) 持久消息、basicQos(1) 公平分发、手动 ack
T3 发布/订阅 EmitLog.kt / ReceiveLogs.kt logs(fanout) 临时队列 广播、服务端命名队列、空路由键绑定
T4 路由 EmitLogDirect.kt / ReceiveLogsDirect.kt direct_logs(direct) 临时队列 路由键精确匹配、一队列多绑定
T5 主题 EmitLogTopic.kt / ReceiveLogsTopic.kt topic_logs(topic) 临时队列 * / # 通配符模式匹配
T6 RPC RPCServer.kt / RPCClient.kt 默认交换机 rpc_queue + 临时回调队列 correlationId + replyTo 请求应答
附加 EmitLogHeader.kt / ReceiveLogHeader.kt header_test(headers) 具名持久队列 消息头匹配,x-match any/all

十三、常见问题与排查建议

  1. 连接被拒 / connection refused:确认 RabbitMQ 节点已在 localhost:5672 运行,且默认 guest 账号可用(仓库根 README.md 明确要求"stock/default settings")。
  2. gradle run 找不到主类:检查 -P main=Send 拼写,任务会自动追加 Kt 后缀;如果 gradle.properties 中的 main 残留了上次的值,gradle.properties 的属性会与 -P 同名覆盖冲突时以 -P 为准,必要时先 gradle clean。
  3. argv 参数带空格:run 任务用逗号 , 拆分参数,-P argv="rabbit1, msg1" 的第二个参数会保留前导空格;若需要无空格参数,请勿在逗号后加空格。
  4. Worker 消息堆积 / 分发不均:检查是否遗漏 channel.basicQos(1) 与手动 ack——这是公平分发的前提(参见 Worker.kt 第 35、51 行)。
  5. RPC 无响应:务必先启动 RPCServer 再运行 RPCClient,且两端都连接同一 RabbitMQ 节点;服务端 while(true){...wait()} 挂起是正常行为,不是死循环故障。

十四、小结

kotlin-java-client 以最小化、贴近 Java 的风格,把 RabbitMQ 官方六课完整移植到 Kotlin,并统一通过 gradle run -P main=... -P argv=... 驱动运行。本文从 build.gradle 的运行任务讲起,逐课结合源码剖析了默认交换机、fanout/direct/topic/headers 四种交换机、持久化、预取、手动应答、临时队列与 RPC 关联 ID 等全部核心概念,并补充了 README 未记载的 headers 交换机示例。你可以直接复制各节命令在本地 RabbitMQ 上依次体验,也可对照 kotlin-java-client/README.md 与 src/main/kotlin 下的源码逐步加深理解;若要进一步探索其他语言实现或 Stream 协议版本,仓库根 README.md 的 Languages 列表提供了完整入口。

登录后查看全文
rabbitmq-tutorials