一个优秀的rabbitmq消费者(consumer)设计，可直接上线使用

棉花糖_码农夜读

于 2025-04-03 11:00:00 发布

阅读量593

点赞数 27

文章标签： rabbitmq 分布式 python 人工智能

本文链接：https://blog.youkuaiyun.com/liupenglove/article/details/146969278

版权

RabbitMQ作为一个开源的消息中间件，在大数据量服务中起到关键作用，它可以将耗时的操作转为异步执行，来提升系统的吞吐量，在高峰时段，RabbitMQ可以缓存大量的消息，从而避免系统崩溃，并在低峰时段处理这些消息，提高了系统的稳定性。

rabbitmq虽然可以缓存消息，但是也不能无限制、大量的缓存消息而不进行消费，否则会导致mq内存耗尽，服务down机，因此一个高效、稳定的消费者程序对于服务稳定显得尤为重要。

该消费者设计的总思路如下：

重点要说明的是，消息接收与消息处理要分开，消息接收只做接收，消息处理要批量进行。

1、代码实现

下面就以一个具体的实例来实现此消费者的设计，首先是写了一个类，实现基本对rabbitmq的操作(这个类可以拿去直接使用)：

class DwRabbitMQ:
    def __init__(self, url, exchange, queue_name):
         self.async_queue = asyncio.Queue()
         self.url = url
         self.exchange = exchange
         self.queue_name = queue_name
         self.connection = None
         self.channel = None
         self.queue = None
    async def connect(self):
        try:
            self.connection = await aio_pika.connect_robust(
                self.url
            )
            self.channel = await self.connection.channel()
            self.exchange = await self.channel.declare_exchange(name=self.exchange, type='fanout')
            self.queue = await self.channel.declare_queue(name=self.queue_name, durable=True)
        except Exception as e:
            print(e)
    async def queue_bind_exchange(self):
        try:
            await self.queue.bind(exchange=self.exchange)
        except Exception as e:
            print(e)
    async def set_callback(self, callback):
        try:
            await self.queue.consume(callback)
        except Exception as e:
            print(e)
    async def callback(self, message: aio_pika.IncomingMessage):
        try:
            # print(f"Consumer 1 received: {message.body.decode()}")
            self.async_queue.put_nowait((message,message.body.decode()))
        except Exception:
            print(f" [!] Rejected: {message.body.decode()}")
    async def is_connected(self):
        return self.connection.is_closed
    def get_msg(self):
        return self.async_queue.get_nowait()

在上面代码中，重点看callback这个回调函数，我们发现，这个函数的实现逻辑非常简单，就是把消息放入到队列中，没有任何其他业务逻辑：

async def set_callback(self, callback):
  try:
    await self.queue.consume(callback)
  except Exception as e:
    print(e)

那消息的处理在哪呢？如开始所说，消息接收和消息处理分开，消息处理是业务逻辑，必定会耦合业务需求，每个需求都会各不相同，因此分开是正确的选择。

那我们接下来看一下如何利用上面的类实现对消息的处理：

async def main():
    buffer = []
    batch_size = 10
    last_time = time.time()
    url = "amqp://guest:guest@localhost:5672/"
    dwmq = DwRabbitMQ(url, "exchange_fan", "dw_clip_insert")
    await dwmq.connect()
    await dwmq.queue_bind_exchange()
    await dwmq.set_callback(dwmq.callback)
    print(" [*] Waiting for messages. To exit press CTRL+C")
    while True:
        # if await dwmq.is_connected():
        #     try:
        #         print("reconnecting...")
        #         dwmq = DwRabbitMQ(url, "exchange_fan", "dw_clip_insert")
        #         await dwmq.connect()
        #         await dwmq.set_callback(dwmq.callback)
        #     except Exception as e:
        #         print(e,",retry to connect")
        #         await asyncio.sleep(1)
        #         continue
        try:
            msg = dwmq.get_msg()
        except asyncio.QueueEmpty:
            await asyncio.sleep(1)
            msg = None
        if msg is not None:
            buffer.append(msg)
        if len(buffer) < batch_size and time.time() - last_time < 60:
            continue
        last_time = time.time()
        print("batch size : {},real size : {}, begin to process".format(batch_size,len(buffer)))
        # 根据实际需求，批量
        for msg in buffer:
            try:
                await msg[0].ack()
            except Exception as e:
                print(e)
            print(msg[1])
        buffer = []

在消费处理中需要说明的有两点：

对消息进行打包处理
如果消息不够设置的『包』，也要有处理策略，这里是按时间处理的，如果等待超过一定时间没有凑够这个『包』，那么就有多少算多少，先处理了。

代码实现在这里：

try:
    msg = dwmq.get_msg()
except asyncio.QueueEmpty:
    await asyncio.sleep(1)
    msg = None
if msg is not None:
    buffer.append(msg)
if len(buffer) < batch_size and time.time() - last_time < 60:
    continue