RabbitMQ Kotlin 教程实战指南:kotlin-java-client 六课全量示例与 Java AMQP 客户端源码解析
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、T2new_task/worker、T3emit_log/receive_logs、T4emit_log_direct/receive_logs_direct、T5emit_log_topic/receive_logs_topic、T6rpc_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 命令的语义:
-P main=ClassName指定入口类:任务把属性main取出后强制拼接后缀Kt,即main = "RecvKt"。所以你传-P main=Recv实际执行的是RecvKt类;如果传-P main=Recv.kt或带包名的全限定名,需要自行换算成xxxKt形式。-P argv="a, b, c"传程序参数:任务把属性argv按英文逗号,拆分成参数列表。例如-P argv="info,error"会生成两个参数["info", "error"];-P argv="rabbit1, msg1"生成["rabbit1", " msg1"](注意第二个参数会带一个前导空格,消费端拼接消息时需留意)。- 缺省处理:gradle.properties 预置了
main =与argv =两个空属性,保证未传-P时$main/$argv均为空字符串,任务跳过对应分支。 - 类路径:使用
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
三个要点的源码级解释:
channel.basicQos(1)(公平分发 fair dispatch):默认情况下 RabbitMQ 是轮询分发,但遇到"慢消费者"时可能失衡。basicQos(1)告诉 Broker 每次只给该消费者 1 条未确认消息,处理完并 ack 后才发下一条,从而保证 Worker 之间按处理能力均分负载;- 手动应答:
basicConsume(..., false, ...)关闭自动应答,处理完成后在finally中调用channel.basicAck(envelope.deliveryTag, false)显式确认。若 Worker 在处理中途崩溃(未 ack),消息会被重新投递给其他 Worker——这就是"任务不丢失"的保障; 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 |
十三、常见问题与排查建议
- 连接被拒 /
connection refused:确认 RabbitMQ 节点已在localhost:5672运行,且默认guest账号可用(仓库根 README.md 明确要求"stock/default settings")。 gradle run找不到主类:检查-P main=Send拼写,任务会自动追加Kt后缀;如果gradle.properties中的main残留了上次的值,gradle.properties的属性会与-P同名覆盖冲突时以-P为准,必要时先gradle clean。- argv 参数带空格:
run任务用逗号,拆分参数,-P argv="rabbit1, msg1"的第二个参数会保留前导空格;若需要无空格参数,请勿在逗号后加空格。 - Worker 消息堆积 / 分发不均:检查是否遗漏
channel.basicQos(1)与手动 ack——这是公平分发的前提(参见 Worker.kt 第 35、51 行)。 - 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 列表提供了完整入口。