RabbitMQ快速入門python教程

HelloWorld

簡介

RabbitMQ：接受訊息再傳遞訊息，可以視為一個“郵局”。寄件者和接受者通過隊列來進行互動，隊列的大小可以視為無限的，多個寄件者可以發生給一個隊列，多個接收者也可以從一個隊列中接受訊息。

code

rabbitmq使用的協議是amqp，用於python的推薦用戶端是pika

pip install pika -i https://pypi.douban.com/simple/

send.py

# coding: utf8import pika# 建立一個串連connection = pika.BlockingConnection(pika.ConnectionParameters(           'localhost'))  # 串連本地的RabbitMQ伺服器channel = connection.channel()  # 獲得channel

這裡連結的是原生，如果想要串連其他機器上的伺服器，只要填入地址或主機名稱即可。

接下來我們開始發送訊息了，注意要確保接受訊息的隊列是存在的，否則rabbitmq就丟棄掉該訊息

channel.queue_declare(queue='hello')  # 在RabbitMQ中建立hello這個隊列channel.basic_publish(exchange='',  # 使用預設的exchange來發送訊息到隊列                  routing_key='hello',  # 發送到該隊列 hello 中                  body='Hello World!')  # 訊息內容connection.close()  # 關閉 同時flush

RabbitMQ預設需要1GB的空閑磁碟空間，否則發送會失敗。

這時已在本地隊列hello中存放了一個訊息，如果使用 rabbitmqctl list_queues 可看到

hello 1

說明有一個hello隊列 裡面存放了一個訊息

receive.py

# coding: utf8import pikaconnection = pika.BlockingConnection(pika.ConnectionParameters(               'localhost'))channel = connection.channel()

還是先連結到伺服器，和之前發送時相同

channel.queue_declare(queue='hello')  # 此處就是聲明了 來確保該隊列 hello 存在 可以多次聲明 這裡主要是為了防止接受程式先運行時出錯def callback(ch, method, properties, body):  # 用於接收到訊息後的回調    print(" [x] Received %r" % body)channel.basic_consume(callback,                      queue='hello',  # 收指定隊列hello的訊息                      no_ack=True)  #在處理完訊息後不發送ack給伺服器channel.start_consuming()  # 啟動訊息接受 這會進入一個死迴圈

工作隊列（任務隊列）

工作隊列是用於分發耗時任務給多個背景工作處理序的。不立即做那些耗費資源的任務（需要等待這些任務完成），而是安排這些任務之後執行。例如我們把task作為message發送到隊列裡，啟動背景工作處理序來接受並最終執行，且可啟動多個背景工作處理序來工作。這適用於web應用，即不應在一個http請求的處理視窗內完成複雜任務。

channel.basic_publish(exchange='',                  routing_key='task_queue',                  body=message,                  properties=pika.BasicProperties(                     delivery_mode = 2, # 使得訊息持久化                  ))

分配訊息的方式為 輪詢 即每個背景工作處理序獲得相同的訊息數。

訊息ack

如果訊息分配給某個背景工作處理序，但是該背景工作處理序未處理完成就崩潰了，可能該訊息就丟失了，因為rabbitmq一旦把一個訊息分發給背景工作處理序，它就把該訊息刪掉了。

為了預防訊息丟失，rabbitmq提供了ack，即背景工作處理序在收到訊息並處理後，發送ack給rabbitmq，告知rabbitmq這時候可以把該訊息從隊列中刪除了。如果背景工作處理序掛掉 了，rabbitmq沒有收到ack，那麼會把該訊息 重新分發給其他背景工作處理序。不需要設定timeout，即使該任務需要很長時間也可以處理。

ack預設是開啟的，之前我們的背景工作處理序顯示指定了no_ack=True

channel.basic_consume(callback, queue='hello')  # 會啟用ack

帶ack的callback:

def callback(ch, method, properties, body):    print " [x] Received %r" % (body,)    time.sleep( body.count('.') )    print " [x] Done"    ch.basic_ack(delivery_tag = method.delivery_tag)  # 發送ack

訊息持久化

但是，有時RabbitMQ重啟了，訊息也會丟失。可在建立隊列時設定持久化：
(隊列的性質一旦確定無法改變）

channel.queue_declare(queue='task_queue', durable=True)

同時在發送訊息時也得設定該訊息的持久化屬性：

channel.basic_publish(exchange='',

                  routing_key="task_queue",                  body=message,                  properties=pika.BasicProperties(                     delivery_mode = 2, # make message persistent                  ))

但是，如果在RabbitMQ剛接收到訊息還沒來得及儲存，訊息還是會丟失。同時，RabbitMQ也不是在接受到每個訊息都進行存檔操作。如果還需要更完善的保證，需要使用publisher confirm。

公平的訊息分發

輪詢模式的訊息分發可能並不公平，例如奇數的訊息都是繁重任務的話，某些進程則會一直運行繁 重任務。即使某背景工作處理序上有積壓的訊息未處理，如很多都沒發ack，但是RabbitMQ還是會按照順序發訊息給它。可以在接受進程中加設定：

channel.basic_qos(prefetch_count=1)

告知RabbitMQ，這樣在一個背景工作處理序沒回傳ack情況下是不會再分配訊息給它。

群發

一般情況下，一條訊息是發送給一個背景工作處理序，然後完成，有時想把一條訊息同時發送給多個進程：

exchange

寄件者是不是直接發送訊息到隊列中的，事實上發生者根本不知道訊息會發送到那個隊列，寄件者只能把訊息發送到exchange裡。exchange一方面收生產者的訊息，另一方面把他們推送到隊列中。所以作為exchange，它需要知道當收到訊息時它需要做什麼，是應該把它加到一個特殊的隊列中還是放到很多的隊列中，或者丟棄。exchange有direct、topic、headers、fanout等種類，而群發使用的即fanout。之前在發布訊息時，exchange的值為 '' 即使用default exchange。

channel.exchange_declare(exchange='logs', type='fanout')  # 該exchange會把訊息發送給所有它知道的隊列中

暫存佇列

result = channel.queue_declare()  # 建立一個隨機隊列result = channel.queue_declare(exclusive=True)  # 建立一個隨機隊列，同時在沒有接收者串連該隊列後則銷毀它queue_name = result.method.queue

這樣result.method.queue即是隊列名稱，在發送或接受時即可使用。

綁定exchange 和 隊列

channel.queue_bind(exchange='logs',               queue='hello')

logs在發送訊息時給hello也發一份。

在發送訊息是使用剛剛建立的 logs exchange

   channel.basic_publish(exchange='logs',                  routing_key='',                  body=message)

路由

之前已經使用過bind，即建立exchange和queue的關係（該隊列對來自該exchange的訊息有興趣），bind時可另外指定routing_key選項。

使用direct exchange

將對應routing key的訊息發送到綁定相同routing key的隊列中

channel.exchange_declare(exchange='direct_logs',                     type='direct')

發送函數，發布不同severity的訊息：

channel.basic_publish(exchange='direct_logs',                  routing_key=severity,                  body=message)

接受函數中綁定對應severity的：

channel.queue_bind(exchange='direct_logs',                   queue=queue_name,                   routing_key=severity)

使用topic exchange

之前使用的direct exchange 只能綁定一個routing key，可以使用這種可以拿.隔開routing key的topic exchange，例如：

"stock.usd.nyse" "nyse.vmw"

和direct exchange一樣，在接受者那邊綁定的key與發送時指定的routing key相同即可，另外有些特殊的值：

* 代表1個單詞# 代表0個或多個單詞

如果寄件者發出的routing key都是3個部分的，如：celerity.colour.species。

Q1:*.orange.*  對應的是中間的colour都為orange的Q2:*.*.rabbit  對應的是最後部分的species為rabbit的lazy.#      對應的是第一部分是lazy的

qucik.orange.rabbit Q1 Q2都可接收到，quick.orange.fox 只有Q1能接受到，對於lazy.pink.rabbit雖然匹配到了Q2兩次，但是只會發送一次。如果綁定時直接綁定#，則會收到所有的。

　RPC

在遠程機器上運行一個函數然後獲得結果。

１、用戶端啟動　同時設定一個暫存佇列用於接受回調，綁定該隊列

    self.connection = pika.BlockingConnection(pika.ConnectionParameters(            host='localhost'))    self.channel = self.connection.channel()    result = self.channel.queue_declare(exclusive=True)    self.callback_queue = result.method.queue    self.channel.basic_consume(self.on_response, no_ack=True,                               queue=self.callback_queue)

２、用戶端發送rpc請求，同時附帶reply_to對應回調隊列，correlation_id設定為每個請求的唯一id（雖然說可以為每一次RPC請求都建立一個回調隊列，但是這樣效率不高，如果一個用戶端只使用一個隊列，則需要使用correlation_id來匹配是哪個請求），之後阻塞在回調隊列直到收到回複

注意：如果收到了非法的correlation_id直接丟棄即可，因為有這種情況--伺服器已經發了響應但是還沒發ack就掛了，等一會伺服器重啟了又會重新處理該任務，又發了一遍相應，但是這時那個請求已經被處理掉了

channel.basic_publish(exchange='',                       routing_key='rpc_queue',                       properties=pika.BasicProperties(                             reply_to = self.callback_queue,                             correlation_id = self.corr_id,                             ),                       body=str(n))  # 發出調用while self.response is None:  # 這邊就相當於阻塞了    self.connection.process_data_events()  # 查看回調隊列return int(self.response)

3、請求會發送到rpc_queue隊列
4、RPC伺服器從rpc_queue中取出，執行，發送回複

channel.basic_consume(on_request, queue='rpc_queue')  # 綁定 等待請求# 處理之後：ch.basic_publish(exchange='',                 routing_key=props.reply_to,                 properties=pika.BasicProperties(correlation_id = \                                                     props.correlation_id),                 body=str(response))  # 發送回複到回調隊列ch.basic_ack(delivery_tag = method.delivery_tag)  # 發送ack

5、用戶端從回調隊列中取出資料，檢查correlation_id，執行相應操作

if self.corr_id == props.correlation_id:        self.response = body