MQTTnet.Extensions.ManagedClient
一、MQTT客户端简单暴力版
可将以下代码直接挂在物体上使用
using MQTTnet;
using MQTTnet.Client;
using MQTTnet.Extensions.ManagedClient;
using MQTTnet.Protocol;
using QFramework;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Linq;
using UnityEngine;
public class UDPDataMqtt : MonoBehaviour
{
string[] topicArray;
//private IMqttClient m_mqttClient = null;
private IManagedMqttClient m_managedmqttClient;
private MqttFactory Factory = new MqttFactory();
/// <summary>
/// 操作参数
/// </summary>
private MqttClientOptions Options;
/// <summary>
/// 消息参数
/// </summary>
private ManagedMqttClientOptions ManagedOptions;
// Start is called before the first frame update
async void Start()
{
//将XML文件加载进来
XDocument document = XDocument.Load(CommonInfo.NetWorkSettingPath + "/MqttSConfig.xml");
//获取到XML的根元素进行操作
XElement root = document.Root;
XElement ele = root.Element("MqttConfig");
//获取心跳包时间间隔
XAttribute Topic = ele.Attribute("MQTTDataTopics");
if (!string.IsNullOrEmpty(Topic.Value))
{
topicArray = Topic.Value.Split(new char[] {
';' }, StringSplitOptions.RemoveEmptyEntries);
}
await ConnectMqttServerAsync();
}
/// <summary>
/// 客户端初始化
/// </summary>
public void Client_Init()
{
//配置初始化
//配置连接参数
Options = new MqttClientOptionsBuilder()
.WithTcpServer("127.0.0.1", 1883) //服务器地址端口号
.WithClientId("JiJuReceiveData") //连接客户端id
.WithCredentials("", "") //用户名账号密码 没有可不填
.WithWillQualityOfServiceLevel(MqttQualityOfServiceLevel.AtMostOnce)
// .WithCleanSession()
.WithKeepAlivePeriod(TimeSpan.FromSeconds(5))
.Build();
//配置重连机制
ManagedOptions = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(Options)
.Build();
//创建客户端
m_managedmqttClient = Factory.CreateManagedMqttClient();
//配置数据接收事件
m_managedmqttClient.ApplicationMessageReceivedAsync += Receive_Event;
m_managedmqttClient.ConnectedAsync += Connected_Event;
m_managedmqttClient.DisconnectedAsync += Disconnected_Event;
}
public async Task ConnectMqttServerAsync()
{
Client_Init();
try
{
//订阅主题
if (topicArray.Length > 0)
{
await m_managedmqttClient.SubscribeAsync(
topicArray.Select(t => new MqttTopicFilterBuilder().WithTopic(t).WithAtLeastOnceQoS().Build()).ToArray()
);
}
//连接服务器
await m_managedmqttClient.StartAsync(ManagedOptions);
}
catch (Exception e)
{
Console.WriteLine(e);
}
#region m_mqttClient
//配置连接参数
//var options = new MqttClientOptionsBuilder()
// .WithTcpServer("127.0.0.1", 1883)
// .WithClientId(Guid.NewGuid().ToString())
// .WithCleanSession()
// .WithKeepAlivePeriod(TimeSpan.FromSeconds(5))
// .Build();
//if (m_mqttClient == null)
//{
// m_mqttClient = new MqttFactory().CreateMqttClient();
// // MqttServerOptions mqttServerOptions = new MqttServerOptions();
// // mqttServer = new MqttFactory().CreateMqttServer(mqttServerOptions);
//}
// await m_mqttClient.ConnectAsync(options);
// await m_mqttClient.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic("test/topic").Build());
// 发布一条消息
//var applicationMessage = new MqttApplicationMessageBuilder()
// .WithTopic("4001")
// .WithPayload("Hello, MQTT!")
// .WithQualityOfServiceLevel(MQTTnet.Protocol.MqttQualityOfServiceLevel.AtLeastOnce)
// .Build();
// await m_mqttClient.PublishAsync(applicationMessage);
#endregion
}
/// <summary>
/// 消息接收处理方法
/// </summary>
/// <param name="arg"></param>
/// <returns></returns>
public async Task Receive_Func(MqttApplicationMessageReceivedEventArgs arg)
{
//try
//{
// if (msg.Topic.Contains("4001"))
// {
// DataHandle.GetInstance.AddDataHC(Encoding.UTF8.GetString(msg.Payload), 4001);
// }
// else if (msg.Topic.Contains("4002"))
// {
// DataHandle.GetInstance.AddData(Encoding.UTF8.GetString(msg.Payload), 4002);
// }
//}
//catch (Exception e)
//{
// Debug.Log(e.Message);
//}
}
/// <summary>
/// 连接服务器处理方法
/// </summary>
/// <param name="arg"></param>
/// <returns></returns>
public virtual async Task Connected_Func(MqttClientConnectedEventArgs arg)
{
Debug.Log("客户端与服务器连接成功");
}
/// <summary>
/// 断开服务器出来方法
/// </summary>
/// <param name="arg"></param>
/// <returns></returns>
public async Task Disconnected_Func(MqttClientDisconnectedEventArgs arg)
{
Debug.Log("客户端与服务器断开");
}
/// <summary>
/// 发送消息
/// </summary>
/// <param name="topic">主题</param>
/// <param name="content">内容</param>
public void SendMessage(string topic, string content)
{
if (m_managedmqttClient != null && m_managedmqttClient.IsConnected)
m_managedmqttClient.EnqueueAsync(topic, content);
}
#region 事件处理
/// <summary>
/// 断开连接事件
/// </summary>
/// <param name="arg"></param>
/// <returns></returns>
private async Task Disconnected_Event(MqttClientDisconnectedEventArgs arg)
{
await Disconnected_Func(arg);
}
/// <summary>
/// 连接成功事件
/// </summary>
/// <param name="arg"></param>
/// <returns></returns>
private async Task Connected_Event(MqttClientConnectedEventArgs arg)
{
await Connected_Func(arg);
}
#endregion
#region 消息事件处理
/// <summary>
/// 消息接收
/// </summary>
/// <param name="arg"></param>
/// <returns></returns>
private async Task Receive_Event(MqttApplicationMessageReceivedEventArgs arg)
{
// await Receive_Func(arg);
MqttApplicationMessage msg = arg.ApplicationMessage;
Debug.Log("MQTTDATA======" + msg.Topic + "_______" + Encoding.UTF8.GetString(msg.Payload));
if (msg.Topic.Contains("4001"))
{
DataHandle.GetInstance.AddData(Encoding.UTF8.GetString(msg.Payload), 4001);
}
else if (msg.Topic.Contains("4002"))
{
DataHandle.GetInstance.AddDataHC(Encoding.UTF8.GetString(msg.Payload), 4002);
}
}
#endregion
/// <summary>
/// 客户端断开
/// </summary>
public void Disconnected()
{
m_managedmqttClient.StopAsync();
m_managedmqttClient.ApplicationMessageReceivedAsync -= Receive_Event;
m_managedmqttClient.ConnectedAsync -= Connected_Event;
m_managedmqttClient.DisconnectedAsync -= Disconnected_Event;
}
void OnDestroy()
{
Disconnected();
}
// Update is called once per frame
void Update()
{
}
}
二、MQTT客户端面向对象版
创建父类
using MQTTnet;
using MQTTnet.Client;
using MQTTnet.Extensions.ManagedClient;
using MQTTnet.Protocol;
using MQTTnet.Server;
using Newtonsoft.Json;
using System;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Xml.Linq;
using UnityEngine;
namespace ElectronicAlbum.ConnClientModules
{
public class ClientMqtt<T>:SingleTon<T> where T : ClientMqtt<T>, new()
{
#region 公用字段
#endregion
#region 私有字段
/// <summary>
/// Managed客户端
/// </summary>
protected IManagedMqttClient ManagedClient;
/// <summary>
/// 工厂
/// </summary>
private MqttFactory Factory = new MqttFactory();
/// <summary>
/// 操作参数
/// </summary>
private MqttClientOptions Options;
/// <summary>
/// 消息参数
/// </summary>
private ManagedMqttClientOptions ManagedOptions;
protected CancellationTokenSource TaskSource = new CancellationTokenSource();
protected string MQTTServerIp;
protected string MQTTClientId;
protected string MQTTUserName;
protected string MQTTPassWord ;
protected double MQTTKeepAlive;
protected string[] MQTTTopic;
#endregion
#region 构造函数
public ClientMqtt()
{
}
#endregion
#region 方法
/// <summary>
/// 初始化配置
/// </summary>
private void Config_Init()
{
//将XML文件加载进来
XDocument document = XDocument.Load(Application.streamingAssetsPath + "/MqttSConfig.xml");
//获取到XML的根元素进行操作
XElement root = document.Root;
XElement ele = root.Element("MqttConfig");
//获取服务器IP
XAttribute ServerIp = ele.Attribute("server");
if (ServerIp != null)
{
MQTTServerIp = ServerIp.Value;
}
//获取客户端ID
XAttribute ClientId = ele.Attribute("clientId");
if (ClientId != null)
{
MQTTClientId = ClientId.Value;
}
//获取用户名
XAttribute UserName = ele.Attribute("userName");
if (ClientId != null)
{
MQTTUserName = UserName.Value;
}
//获取用户密码
XAttribute PassWord = ele.Attribute("passWord");
if (ClientId != null)
{
MQTTPassWord = PassWord.Value;
}
//获取心跳包时间间隔
XAttribute KeepAlive = ele.Attribute("keepAlive");
if (ClientId != null)
{
MQTTKeepAlive = Convert.ToDouble(KeepAlive.Value);
}
//获取心跳包时间间隔
XAttribute Topic = ele.Attribute("topics");
if (ClientId != null)
{
if (!string.IsNullOrEmpty(Topic.Value))
{
MQTTTopic = Topic.Value.Split(new char[] {
';'}, StringSplitOptions.RemoveEmptyEntries);
}
}
//配置连接参数
Options = new MqttClientOptionsBuilder()
.WithTcpServer(MQTTServerIp)
.WithClientId(MQTTClientId)
.WithCredentials(MQTTUserName, MQTTPassWord)
.WithCleanSession()
.WithKeepAlivePeriod(TimeSpan.FromSeconds(MQTTKeepAlive))
.Build();
//配置重连机制
ManagedOptions = new ManagedMqttClientOptionsBuilder()
.WithAutoReconnectDelay(TimeSpan.FromSeconds(5))
.WithClientOptions(Options)
.Build();
}
/// <summary>
/// 客户端初始化
/// </summary>
public void Client_Init()
{
//配置初始化
Config_Init();
//创建客户端
ManagedClient = Factory.CreateManagedMqttClient();
//配置数据接收事件
ManagedClient.ApplicationMessageReceivedAsync += Receive_Event;
ManagedClient.ConnectedAsync += Connected_Event;
ManagedClient.DisconnectedAsync += Disconnected_Event;
}
/// <summary>
/// 客户端连接
/// </summary>
public async Task Connected()
{
try
{
//订阅主题
if (MQTTTopic != null && MQTTTopic.Length > 0)
await ManagedClient.SubscribeAsync(
MQTTTopic.Select(t => new MqttTopicFilterBuilder()
.WithTopic(t)
.WithAtLeastOnceQoS()
.Build()).ToArray());
//连接服务器
await ManagedClient.StartAsync(ManagedOptions);
}
catch (Exception e)
{
Debug.Log(e);
}
}
/// <summary>
/// 客户端断开
/// </summary>
public void Disconnected()
{
ManagedClient.StopAsync();
ManagedClient.ApplicationMessageReceivedAsync -= Receive_Event;
ManagedClient.ConnectedAsync -= Connected_Event;
ManagedClient.DisconnectedAsync -= Disconnected_Event;
}
/// <summary>
/// 消息接收处理方法
/// </summary>
/// <param name="arg"></param>
/// <returns></returns>
public virtual async Task Receive_Func(MqttApplicationMessageReceivedEventArgs arg)
{
}
/// <summary>
/// 连接服务器处理方法
/// </summary>
/// <param name="arg"></param>
/// <returns></returns>
public virtual async Task Connected_Func(MqttClientConnectedEventArgs arg)
{
Debug.Log("客户端与服务器连接成功");
}
/// <summary>
/// 断开服务器出来方法
/// </summary>
/// <param name="arg"></param>
/// <returns></returns>
public virtual async Task Disconnected_Func(MqttClientDisconnectedEventArgs arg)
{
Debug.Log("客户端与服务器断开");
}
/// <summary>
/// 发送消息
/// </summary>
/// <param name="topic">主题</param>
/// <param name="content">内容</param>
public virtual void SendMessage(string topic, string content)
{
if (ManagedClient != null && ManagedClient.IsConnected)
ManagedClient.EnqueueAsync(topic, content);
}
#endregion
#region 事件处理
/// <summary>
/// 断开连接事件
/// </summary>
/// <param name="arg"></param>
/// <returns></returns>
private async Task Disconnected_Event(MqttClientDisconnectedEventArgs arg)
{
await Disconnected_Func(arg);
}
/// <summary>
/// 连接成功事件
/// </summary>
/// <param name="arg"></param>
/// <returns></returns>
private async Task Connected_Event(MqttClientConnectedEventArgs arg)
{
await Connected_Func(arg);
}
#endregion
#region 消息事件处理
/// <summary>
/// 消息接收
/// </summary>
/// <param name="arg"></param>
/// <returns></returns>
private async Task Receive_Event(MqttApplicationMessageReceivedEventArgs arg)
{
await Receive_Func(arg);
}
#endregion
}
}
创建子类
using LitJson;
using MQTTnet;
using MQTTnet.Client;
using MQTTnet.Extensions.ManagedClient;
using MQTTnet.Protocol;
using Newtonsoft.Json;
using QFramework;
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Xml.Linq;
using UnityEngine;
using UnityEngine.Networking;
public class ClientMqttDemo:ClientMqtt<ClientMqttDemo>
{
public event Func<MqttApplicationMessage, Task> ReceiveFuncExp;
/// <summary>
/// 结构消息
/// </summary>
/// <param name="arg"></param>
/// <returns></returns>
public override async Task Receive_Func(MqttApplicationMessageReceivedEventArgs arg)
{
//Task<MqttApplicationMessage> msg = null;
// await ReceiveFuncExp?.Invoke(arg.ApplicationMessage);
MqttApplicationMessage msg = arg.ApplicationMessage;
if (msg != null)
{
Loom.QueueOnMainThread(() =>
{
if (msg.Topic.Equals("TopicDemo"))
{
// EnumEventSystem.Global.Send(EquipmentType.AA, msg.Topic, Encoding.UTF8.GetString(msg.Payload));
}
});
}
await base.Receive_Func(arg);
}
public override async Task Connected_Func(MqttClientConnectedEventArgs arg)
{
await base.Connected_Func(arg);
//CommonInfo.CarBaseInfo.State = "Logined";
//await ManagedClient.EnqueueAsync("Login",JsonMapper.ToJson(CommonInfo.CarBaseInfo));
//await GetCarOnline();
}
public override async Task Disconnected_Func(MqttClientDisconnectedEventArgs arg)
{
//CommonInfo.CarBaseInfo.State = "Logout";
//await ManagedClient.EnqueueAsync("Login", JsonMapper.ToJson(CommonInfo.CarBaseInfo));
await base.Disconnected_Func(arg);
}
protected override void OnDestroy()
{
Disconnected();
base.OnDestroy();
}
}
public enum EquipmentType
{
AA,
BB,
CC,
None,
}
连接初始化
void Awake()
{
ClientMqttDemo.GetInstance.Client_Init();
}
// Start is called before the first frame update
async void Start()
{
await ClientMqttDemo.GetInstance.Connected();
}
单例模板
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class SingleTon<T> : MonoBehaviour where T : SingleTon<T>
{
private static T instance;
static readonly object mylock = new object();
public static T GetInstance
{
get
{
if (instance == null)
{
lock (mylock)
{
instance = FindObjectOfType(typeof(T)) as T;
if (instance == null)
{
GameObject obj = new GameObject();
obj.hideFlags = HideFlags.HideAndDontSave;
instance = (T)obj.AddComponent(typeof(T));
}
}
}
return instance;
}
}
protected virtual void Start()
{
}
protected virtual void Awake()
{
if (instance == null)
{
instance = (T)this;
}
}
protected virtual void OnDestroy()
{
if (instance == this)
{
instance = null;
}
}
}