mqtt消息订阅机制

实现MQTT协议需要客户端和服务器端通讯完成，在通讯过程中，MQTT协议中有三种身份：
发布者（Publish）、
代理（Broker）（服务器）、
订阅者（Subscribe）。
其中，消息的发布者和订阅者都是客户端，消息代理是服务器，消息发布者可以同时是订阅者。

MQTT传输的消息分为：主题（Topic）和负载（payload）两部分：
（1）Topic，可以理解为消息的类型，订阅者订阅（Subscribe）后，就会收到该主题的消息内容（payload）；
（2）payload，可以理解为消息的内容，是指订阅者具体要使用的内容。
当应用数据通过MQTT网络发送时，MQTT会把与之相关的服务质量（QoS）和主题名（Topic）相关连。
使用通配符可以一次订阅多个主题
如/mqtt/#:表示订阅以/mqtt/为前缀的所有主题

通过主题划分设备
qos  => 消息的安全等级 Qos详细介绍
qos=0    QoS0，At most once，至多一次；
    QoS0 代表，Sender 发送的一条消息，Receiver 最多能收到一次，也就是说 Sender 尽力向 Receiver 发送消息，如果发送失败，也就算了；
qos=1    QoS1，At least once，至少一次；
    QoS1 代表，Sender 发送的一条消息，Receiver 至少能收到一次，也就是说 Sender 向 Receiver 发送消息，如果发送失败，会继续重试，直到 Receiver 收到消息为止，但是因为重传的原因，Receiver 有可能会收到重复的消息；
qos=2    QoS2，Exactly once，确保只有一次
    QoS2 代表，Sender 发送的一条消息，Receiver 确保能收到而且只收到一次，也就是说 Sender 尽力向 Receiver 发送消息，如果发送失败，会继续重试，直到 Receiver 收到消息为止，同时保证 Receiver 不会因为消息重传而收到重复的消息。
qos安全等级需要注意的点：
    1. python中下载的paho-mqtt包中，默认qos=0。
    2. 不论是sub还是pub都需要指定qos安全等级。
Payload消息体位MQTT数据包的第三部分，包含CONNECT、SUBSCRIBE、SUBACK、UNSUBSCRIBE四种类型的消息：
（1）CONNECT，消息体内容主要是：客户端的ClientID、订阅的Topic、Message以及用户名和密码。
（2）SUBSCRIBE，消息体内容是一系列的要订阅的主题以及QoS。
（3）SUBACK，消息体内容是服务器对于SUBSCRIBE所申请的主题及QoS进行确认和回复。
（4）UNSUBSCRIBE，消息体内容是要订阅的主题。


0:连接成功
1:连接被拒绝-协议版本不正确
2:连接被拒绝-客户端标识符无效
3:连接被拒绝-服务器不可用
4:连接被拒绝-用户名或密码错误
5:连接被拒绝-未授权
6-255:当前未使用。

 # 连接
 client.on_connect = on_connect
 # 消息
 client.on_message = on_message
 # 发布
 client.on_publish = on_publish
 # 断开连接
 client.on_disconnect = on_disconnect
 # 取消回调
 client.on_unsubscribe = on_unsubscribe

client.username_pw_set(user, password)
client.connect(host=broker, port=port, keepalive=60)
client.loop_forever()
client.loop_start()
# 订阅
client.subscribe()
# 取消订阅
client.unsubscribe()
发布
client.publish('/mqtt/toro', msg)
是否连接
client.is_connected()
断开连接
client.disconnect()
# 重新连接
# client.reconnect()

client

import random
import time

from paho.mqtt import client as MQTT

broker = '127.0.0.1'
user = 'toro'
password = '1234569'
port = 1883
topic = "/python/mqtt"
client_id = 'python-mqtt-client'


# 连接
def mqtt_connect() -> MQTT:
    def on_connect(client, userdata, flags, rc):
        print("连接回调")
        if rc == 0:
            print("Connected to MQTT Broker!")
        else:
            print("Failed to connect, return code %d\n", rc)

    client = MQTT.Client(client_id)
    client.username_pw_set(user, password)
    client.on_connect = on_connect
    client.connect(host=broker, port=port, keepalive=60)
    return client


# 订阅
def subscribe(client: MQTT, topic, qos=0):
    #   订阅回调
    def on_subscribe(client, userdata, mid, granted_qos):
        print("订阅回调")
        print("On Subscribed: qos = %d" % granted_qos)

    def on_message(client, userdata, msg):
        print("消息回调")
        print(f"Received `{msg.payload.decode()}` from `{msg.topic}` topic")

    client.on_subscribe = on_subscribe
    client.on_message = on_message
    client.subscribe(topic, qos)


# 取消订阅
def unsubscribe(client: MQTT, topic):
    #   取消订阅回调
    def on_unsubscribe(client, userdata, mid):
        print("取消订阅回调")
        print("On unSubscribed: qos = %d" % mid)

    client.on_unsubscribe = on_unsubscribe
    client.unsubscribe(topic)


def disconnect(client: MQTT):
    #   断开链接回调
    def on_disconnect(client, userdata, rc):
        print("断开链接回调")
        if rc == 0:
            print("Disconnected to MQTT Broker!")
        else:
            print("Unexpected disconnection rc = " + str(rc))

    # 断开连接
    client.on_disconnect = on_disconnect
    client.disconnect()


def client():
    client = mqtt_connect()
    time.sleep(1)
    # 订阅
    subscribe(client=client, topic=topic, qos=1)
    # client.loop_forever()
    # time.sleep(1)
    #
    # # 取消订阅
    # unsubscribe(client=client, topic=topic)
    #
    # # 判断是否连接
    # state = client.is_connected()
    # print("*******", state)
    # time.sleep(20)
    # disconnect(client)
    # # 判断是否连接
    # state = client.is_connected()
    # print(state)

    client.loop_forever()


if __name__ == '__main__':
    client()

service

import random
import time

from paho.mqtt import client as MQTT

broker = '127.0.0.1'
user = 'toro'
password = '123456'
port = 1883
topic = "/python/mqtt"
service_id = 'python-mqtt-service'


# 连接
def mqtt_connect() -> MQTT:
    def on_connect(client, userdata, flags, rc):
        print("连接回调")
        print(client, userdata, flags, rc)
        if rc == 0:
            print("Connected to MQTT Broker!")
        else:
            print("Failed to connect, return code %d\n", rc)

    client = MQTT.Client(service_id)
    client.username_pw_set(user, password)
    client.on_connect = on_connect
    client.connect(host=broker, port=port, keepalive=60)
    return client


# 发布
def publish(client: MQTT, topic, msg, qos=0):
    def on_publish(client, userdata, mid):
        print(f"发布回调")
        print(client, userdata, mid)
        # if rc == 0:
        #     print(f"Send `{msg}` to topic `{topic}`")
        # else:
        #     print(f"Failed to send message to topic {topic}")

    while True:
        time.sleep(3)
        client.on_publish = on_publish
        # # 判断是否连接
        # state = client.is_connected()
        # print(state)
        # if state:
        #     print("连接正常")
        # else:
        #     # client.reconnect()
        #     print("重新连接")
        result = client.publish(topic, msg, qos)
        # result: [0, 1]
        status = result[0]
        if status == 0:
            print(f"Send `{msg}` to topic `{topic}`")
        else:
            print(f"Failed to send message to topic {topic}")


def service():
    client = mqtt_connect()
    time.sleep(1)
    # 发布
    client.loop_start()
    publish(client=client, topic=topic, qos=1, msg=f"mqtt test{time.time()}")


if __name__ == '__main__':
    service()