在 Work Queue 的教程中，我们已经学会如何利用工作队列来实现耗时任务的消息分发。
如果我们还想要获得耗时任务的结果呢？这项技术叫做 Remote Procedure Call or RPC 。
在本教程中，我们将利用 RabbitMQ 构建一个 RPC 系统:包含一个客户端和一个服务端。服务端执行一个计算斐波那契数的函数模拟耗时操作。
A note on RPC
尽管 RPC 在编程领域已经不是已经新的概念，并且饱受争议。当程序员不清楚使用的是本地函数还是 RPC 函数时问题尤为突出，会增加系统的复杂程度并且增加调试的难度。滥用 RPC 会导致程序不可维护，代码也会像“屎山”一样。
牢记 3 条建议:
- 明确区分本地函数和 RPC 函数
- 清晰的文档。明确组件之间的依赖关系
- 错误机制。当 RPC 长时间不响应时，客户端错误处理
Callback queue
使用 RabbitMQ 实现 RPC 非常简单，客户端发送请求消息，服务端回复响应消息即可。为了客户端能够收到响应消息，需要在请求消息中包含回调的队列名称。
q, err := ch.QueueDeclare(
"", // name
false, // durable
false, // delete when unused
true, // exclusive
false, // noWait
nil, // arguments
)
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
err = ch.PublishWithContext(ctx,
"", // exchange
"rpc_queue", // routing key
false, // mandatory
false, // immediate
amqp.Publishing{
ContentType: "text/plain",
CorrelationId: corrId,
ReplyTo: q.Name,
Body: []byte(strconv.Itoa(n)),
})
Message properties
AMQP 0-9-1 预置了 14 个消息属性，其中大部分属性很少会被用到，经常使用的属性由下列几种:
persistent:指定消息是否持久化，在 Work Queue 中使用过。content_type: 指定编码类型。最常使用的是 JSON 格式 -application/json。reply_to: 回调队列名称。correlation_id:用于关联 RPC 响应与请求
Correlation Id
在上述代码中，我们为每一个 RPC 请求都创建了一个回调队列，这是一种非常低效的方式 - 可以让客户端都使用同一个队列来提高效率。
如果所有的请求都使用同一个队列的话，又带来了一个新的问题: 如何来区分收到的消息是响应哪个请求？这个时候就需要用到 correlation_id 属性了。对于每一个请求都需要唯一的 correlation_id（不可重复）。需要用到这个值将消息响应和请求进行配对处理，当 correlation_id是无法匹配时就可以将消息丢弃。
你可能会疑惑为什么是直接将不能匹配的消息丢弃而不是返回一个错误？首先需要明白的是: RPC 服务器在完成处理后，会发出一个响应消息和一个 ACK 消息到 RabbitMQ 中，保证消息已经被处理了。设想如下情况: 在发送完响应消息但是发送 ACK 之前，服务挂掉了（基本不可能发生），当重启 RPC 服务器后，由于 RabbitMQ没有收到那条消息的 ACK，所以又会下发一次，RabbitMQ 就会多处理一次，也意味着会在发出一个响应消息和 ACK 消息。这就是为什么我们要丢弃那些未知的 correlation_id了，RPC 服务需要保证幂等性。
Summary
RPC 服务工作流程如下:
- 启动客户端，同时创建一个匿名队列作为回调队列
- 客户端构造一条请求消息。该消息中有 2 个重要的属性:
reply_to（回调队列） 和correlation_id（唯一值） - 将请求消息通过
rpc_queue发送到RabbitMQ中。 - 服务端接收到
RabbitMQ中的消息，处理数据，通过获取到的reply_to队列，将结果返回给客户端（线发送到RabbitMQ中） - 客户端接收到消息后，先校验
correlation_id的合法性。合法的数据才会被处理，不合法就直接丢弃。
Putting it all together
斐波那契函数:
func fib(n int) int {
if n == 0 || n == 1 {
return n
} else {
return fib(n-1) + fib(n-2)
}
}
使用上述函数模拟耗时操作，不要传入过大的值，该算法复杂度为O(2n)，值大了以后，耗时太久。
package main
import (
"context"
"log"
"strconv"
"time"
amqp "github.com/rabbitmq/amqp091-go"
)
func failOnError(err error, msg string) {
if err != nil {
log.Panicf("%s: %s", msg, err)
}
}
func fib(n int) int {
if n == 0 {
return 0
} else if n == 1 {
return 1
} else {
return fib(n-1) + fib(n-2)
}
}
func main() {
conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
failOnError(err, "Failed to connect to RabbitMQ")
defer conn.Close()
ch, err := conn.Channel()
failOnError(err, "Failed to open a channel")
defer ch.Close()
q, err := ch.QueueDeclare(
"rpc_queue", // name
false, // durable
false, // delete when unused
false, // exclusive
false, // no-wait
nil, // arguments
)
failOnError(err, "Failed to declare a queue")
err = ch.Qos(
1, // prefetch count
0, // prefetch size
false, // global
)
failOnError(err, "Failed to set QoS")
msgs, err := ch.Consume(
q.Name, // queue
"", // consumer
false, // auto-ack
false, // exclusive
false, // no-local
false, // no-wait
nil, // args
)
failOnError(err, "Failed to register a consumer")
var forever chan struct{}
go func() {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
for d := range msgs {
n, err := strconv.Atoi(string(d.Body))
failOnError(err, "Failed to convert body to integer")
log.Printf(" [.] fib(%d)", n)
response := fib(n)
err = ch.PublishWithContext(ctx,
"", // exchange
d.ReplyTo, // routing key
false, // mandatory
false, // immediate
amqp.Publishing{
ContentType: "text/plain",
CorrelationId: d.CorrelationId,
Body: []byte(strconv.Itoa(response)),
})
failOnError(err, "Failed to publish a message")
d.Ack(false)
}
}()
log.Printf(" [*] Awaiting RPC requests")
<-forever
}
服务端逻辑:
- 初始化 connection, channel 和queue
- 多服务端负载均衡，设置预期值（qos）
- 定义消费者，从 queue 中获取 channel，开启协程处理并将发送返回值到
RabbitMQ
package main
import (
"context"
"log"
"math/rand"
"os"
"strconv"
"strings"
"time"
amqp "github.com/rabbitmq/amqp091-go"
)
func failOnError(err error, msg string) {
if err != nil {
log.Panicf("%s: %s", msg, err)
}
}
func randomString(l int) string {
bytes := make([]byte, l)
for i := 0; i < l; i++ {
bytes[i] = byte(randInt(65, 90))
}
return string(bytes)
}
func randInt(min int, max int) int {
return min + rand.Intn(max-min)
}
func fibonacciRPC(n int) (res int, err error) {
conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
failOnError(err, "Failed to connect to RabbitMQ")
defer conn.Close()
ch, err := conn.Channel()
failOnError(err, "Failed to open a channel")
defer ch.Close()
q, err := ch.QueueDeclare(
"", // name
false, // durable
false, // delete when unused
true, // exclusive
false, // noWait
nil, // arguments
)
failOnError(err, "Failed to declare a queue")
msgs, err := ch.Consume(
q.Name, // queue
"", // consumer
true, // auto-ack
false, // exclusive
false, // no-local
false, // no-wait
nil, // args
)
failOnError(err, "Failed to register a consumer")
corrId := randomString(32)
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
err = ch.PublishWithContext(ctx,
"", // exchange
"rpc_queue", // routing key
false, // mandatory
false, // immediate
amqp.Publishing{
ContentType: "text/plain",
CorrelationId: corrId,
ReplyTo: q.Name,
Body: []byte(strconv.Itoa(n)),
})
failOnError(err, "Failed to publish a message")
for d := range msgs {
if corrId == d.CorrelationId {
res, err = strconv.Atoi(string(d.Body))
failOnError(err, "Failed to convert body to integer")
break
}
}
return
}
func main() {
rand.Seed(time.Now().UTC().UnixNano())
n := bodyFrom(os.Args)
log.Printf(" [x] Requesting fib(%d)", n)
res, err := fibonacciRPC(n)
failOnError(err, "Failed to handle RPC request")
log.Printf(" [.] Got %d", res)
}
func bodyFrom(args []string) int {
var s string
if (len(args) < 2) || os.Args[1] == "" {
s = "30"
} else {
s = strings.Join(args[1:], " ")
}
n, err := strconv.Atoi(s)
failOnError(err, "Failed to convert arg to integer")
return n
}
源码地址: rpc_client.go & rpc_server.go
