Unity中与WebSocket服务端建立长连接

最新推荐文章于 2024-06-11 11:11:16 发布
最新推荐文章于 2024-06-11 11:11:16 发布
阅读量753 收藏 6
点赞数 1
文章标签： websocket unity 网络协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43872129/article/details/128373374
版权

笔记记录，由于项目需求需要和用WebSocket编写的服务端建立长连接进行实时同步，因此封装的一个脚本，这边用到了BaseHTTP的插件，因此使用这个脚本时需要导入BaseHTTP插件。脚本可以直接拿来用，可以直接通过类名点出单例来使用，接收消息的回调都通过Action事件返回，BaseHTTP插件可以自行查找下载，我也会专门写一篇专栏为了码友们提供学习参考用的一些插件的购买和下载，需要注意的本人提供的仅供学习参考用，如果版权问题概不负责，代码如下：

using System;
using System.IO;
using BestHTTP;
using BestHTTP.WebSocket;
using BestHTTP.WebSocket.Frames;
using UnityEngine;

public class WebSocketClient
{
    private WebSocket m_WebSocket=null;

    private bool m_IsInit = false;

    public string Url = "ws://127.0.0.1:6000";

    public Action<WebSocket> OnAction_Opened = null;
    public Action<WebSocket, UInt16,string> OnAction_Closed = null;
    public Action<WebSocket,string> OnAction_Error = null;
    public Action<WebSocket, string> OnAction_MessageReceived = null;
    public Action<WebSocket, byte[]> OnAction_Binary=null;
    public Action<WebSocket, WebSocketFrameReader> OnAction_IncompleteFrame = null;

    public bool IsConnected
    {
        get { return m_WebSocket!=null&&m_WebSocket.IsOpen; }
    }

    public HTTPRequest HttpRequest
    {
        get { return m_WebSocket!=null ? m_WebSocket.InternalRequest : null; }
    }

    #region 单例
    static protected WebSocketClient _instance;
    static protected bool IsCreate = false;

    public static WebSocketClient Instance
    {
        get
        {
            if (IsCreate == false)
            {
                CreateInstance();
            }

            return _instance;
        }
    }

    public static void CreateInstance()
    {
        if (IsCreate == true)
            return;

        IsCreate = true;
        _instance = new WebSocketClient();
    }

    public static void ReleaseInstance()
    {
        _instance = default(WebSocketClient);
        IsCreate = false;
    }
    #endregion

    #region 构造函数
    private WebSocketClient()
    {

    }
    #endregion

    #region 初始化
    /// <summary>
    /// 初始化
    /// </summary>
    public bool Init(string url)
    {
        if (!m_IsInit)
        {
            m_IsInit = true;

            m_WebSocket = new WebSocket(new System.Uri(url));
            m_WebSocket.OnOpen += OnOpen;
            m_WebSocket.OnMessage += OnMessageReceived;
            m_WebSocket.OnError += OnError;
            m_WebSocket.OnClosed += OnClosed;
            m_WebSocket.OnBinary += Onbinary;
            m_WebSocket.OnIncompleteFrame += OnIncompleteFrame;

            Debug.Log("初始化WebSocket成功，URL：" + url);

            return true;
        }
        Debug.LogWarning("初始化WebSocket失败，URL：" + url);
        return false;
    }
    public bool Init(string url, string origin, string protocol)
    {
        if (!m_IsInit)
        {
            m_IsInit = true;

            m_WebSocket = new WebSocket(new System.Uri(url), origin, protocol);
            m_WebSocket.OnOpen += OnOpen;
            m_WebSocket.OnMessage += OnMessageReceived;
            m_WebSocket.OnError += OnError;
            m_WebSocket.OnClosed += OnClosed;
            m_WebSocket.OnBinary += Onbinary;
            m_WebSocket.OnIncompleteFrame += OnIncompleteFrame;

            Debug.Log("初始化WebSocket成功，URL：" + url);

            return true;
        }
        Debug.LogWarning("初始化WebSocket失败，URL：" + url);
        return false;
    }

    public bool Init(Uri url)
    {
        if (!m_IsInit)
        {
            m_IsInit = true;

            m_WebSocket = new WebSocket(url);
            m_WebSocket.OnOpen += OnOpen;
            m_WebSocket.OnMessage += OnMessageReceived;
            m_WebSocket.OnError += OnError;
            m_WebSocket.OnClosed += OnClosed;
            m_WebSocket.OnBinary += Onbinary;
            m_WebSocket.OnIncompleteFrame += OnIncompleteFrame;

            Debug.Log("初始化WebSocket成功，URL：" + url);

            return true;
        }
        Debug.LogWarning("初始化WebSocket失败，URL：" + url);
        return false;
    }

    public bool Init(Uri url, string origin, string protocol)
    {
        if (!m_IsInit)
        {
            m_IsInit = true;

            m_WebSocket = new WebSocket(url, origin, protocol);
            m_WebSocket.OnOpen += OnOpen;
            m_WebSocket.OnMessage += OnMessageReceived;
            m_WebSocket.OnError += OnError;
            m_WebSocket.OnClosed += OnClosed;
            m_WebSocket.OnBinary += Onbinary;
            m_WebSocket.OnIncompleteFrame += OnIncompleteFrame;

            Debug.Log("初始化WebSocket成功，URL：" + url);

            return true;
        }
        Debug.LogWarning("初始化WebSocket失败，URL：" + url);
        return false;
    }

    /// <summary>
    /// 重新初始化
    /// </summary>
    public bool ReInit(string url)
    {
        if (m_WebSocket != null)
        {
            m_WebSocket.Close();

            m_WebSocket.OnOpen = null;
            m_WebSocket.OnMessage = null;
            m_WebSocket.OnError = null;
            m_WebSocket.OnClosed = null;
            m_WebSocket.OnBinary = null;
            m_WebSocket.OnIncompleteFrame = null;

            m_WebSocket = null;

            m_IsInit = false;

            Debug.Log("关闭重置WebSocket成功");
        }

        return Init(url);
    }
    public bool ReInit(string url, string origin, string protocol)
    {
        if (m_WebSocket != null)
        {
            m_WebSocket.Close();

            m_WebSocket.OnOpen = null;
            m_WebSocket.OnMessage = null;
            m_WebSocket.OnError = null;
            m_WebSocket.OnClosed = null;
            m_WebSocket.OnBinary = null;
            m_WebSocket.OnIncompleteFrame = null;

            m_WebSocket = null;

            m_IsInit = false;

            Debug.Log("关闭重置WebSocket成功");
        }

        return Init(url, origin, protocol);
    }
    public bool ReInit(Uri url)
    {
        if (m_WebSocket != null)
        {
            m_WebSocket.Close();

            m_WebSocket.OnOpen = null;
            m_WebSocket.OnMessage = null;
            m_WebSocket.OnError = null;
            m_WebSocket.OnClosed = null;
            m_WebSocket.OnBinary = null;
            m_WebSocket.OnIncompleteFrame = null;

            m_WebSocket = null;

            m_IsInit = false;

            Debug.Log("关闭重置WebSocket成功");
        }

        return Init(url);
    }
    public bool ReInit(Uri url, string origin, string protocol)
    {
        if (m_WebSocket != null)
        {
            m_WebSocket.Close();

            m_WebSocket.OnOpen = null;
            m_WebSocket.OnMessage = null;
            m_WebSocket.OnError = null;
            m_WebSocket.OnClosed = null;
            m_WebSocket.OnBinary = null;
            m_WebSocket.OnIncompleteFrame = null;

            m_WebSocket = null;

            m_IsInit = false;

            Debug.Log("关闭重置WebSocket成功");
        }

        return Init(url, origin, protocol);
    }
    #endregion

    #region 连接服务
    /// <summary>
    /// 主动连接
    /// </summary>
    /// <param name="url">连接地址</param>
    /// <returns></returns>
    public bool Connect(string url)
    {
        if (ReInit(url))
        {
            m_WebSocket.Open();
            Debug.Log("打开WebSocket");

            return m_WebSocket.IsOpen;
        }
        else
        {
            return false;
        }
    }
    public bool Connect(string url, string origin, string protocol)
    {
        if (ReInit(url, origin, protocol))
        {
            m_WebSocket.Open();
            Debug.Log("打开WebSocket");

            return m_WebSocket.IsOpen;
        }
        else
        {
            return false;
        }
    }
    public bool Connect(Uri url)
    {
        if (ReInit(url))
        {
            m_WebSocket.Open();
            Debug.Log("打开WebSocket");

            return m_WebSocket.IsOpen;
        }
        else
        {
            return false;
        }
    }
    public bool Connect(Uri url, string origin, string protocol)
    {
        if (ReInit(url, origin, protocol))
        {
            m_WebSocket.Open();
            Debug.Log("打开WebSocket");

            return m_WebSocket.IsOpen;
        }
        else
        {
            return false;
        }
    }

    public bool Connect()
    {
        if (m_WebSocket != null)
        {
            m_WebSocket.Open();
            Debug.Log("打开WebSocket");

            return m_WebSocket.IsOpen;
        }
        else
        {
            return false;
        }
    }

    /// <summary>
    /// 断开连接
    /// </summary>
    /// <returns></returns>
    public bool DisConnect()
    {
        if (m_WebSocket != null)
        {
            m_WebSocket.Close();
            return true;
        }
        return false;
    }
    #endregion

    #region 发送消息
    public void SendMessage(int msgType, byte[] data)
    {
        //内存流对象
        using (MemoryStream ms = new MemoryStream())
        {
            using (BinaryWriter bw = new BinaryWriter(ms))
            {
                //先写入长度
                bw.Write(msgType);
                //再写入数据
                bw.Write(data);

                byte[] byteArray = new byte[(int)ms.Length];
                Buffer.BlockCopy(ms.GetBuffer(), 0, byteArray, 0, (int)ms.Length);

                m_WebSocket?.Send(byteArray);
            }
        }
    }

    public void SendMessage(byte[] data)
    {
        m_WebSocket?.Send(data);
    }

    public void SendMessage(string data)
    {
        m_WebSocket?.Send(data);
        Debug.Log(string.Format("{0:D2}:{1:D2}:{2:D2}", DateTime.Now.Hour, DateTime.Now.Minute, DateTime.Now.Second) + data);
    }
    #endregion

    #region 回调
    /// <summary>
    /// 连接成功回调
    /// </summary>
    /// <param name="webSocket"></param>
    private void OnOpen(WebSocket webSocket)
    {
        Debug.Log("连接成功！");
        OnAction_Opened?.Invoke(webSocket);
    }

    /// <summary>
    /// 关闭连接回调
    /// </summary>
    /// <param name="webSocket"></param>
    private void OnClosed(WebSocket webSocket, UInt16 code, string message)
    {
        Debug.Log("关闭连接："+ message);
        OnAction_Closed?.Invoke(webSocket,code,message);
    }

    /// <summary>
    /// 错误回调
    /// </summary>
    /// <param name="webSocket"></param>
    /// <param name="reason"></param>
    private void OnError(WebSocket webSocket,string reason)
    {
        Debug.LogError($"错误消息：{reason}");
        OnAction_Error?.Invoke(webSocket,reason);
    }

    /// <summary>
    /// 收到消息
    /// </summary>
    /// <param name="webSocket"></param>
    /// <param name="message"></param>
    private void OnMessageReceived(WebSocket webSocket, string message)
    {
        Debug.Log($"接收到消息：{message}");
        OnAction_MessageReceived?.Invoke(webSocket, message);
    }

    /// <summary>
    /// 收到不完整帧时的消息
    /// </summary>
    /// <param name="webSocket"></param>
    /// <param name="frame"></param>
    private void OnIncompleteFrame(WebSocket webSocket, WebSocketFrameReader frame)
    {

        Debug.LogWarning("接收到不完整帧的消息：" + frame.DataAsText);
        OnAction_IncompleteFrame?.Invoke(webSocket,frame);
    }

    /// <summary>
    /// 接收二进制消息
    /// </summary>
    /// <param name="webSocket"></param>
    /// <param name="data"></param>
    private void Onbinary(WebSocket webSocket, byte[] data)
    {
        Debug.Log("接收到二进制消息");
        OnAction_Binary?.Invoke(webSocket,data);
    }
    #endregion
}

使用的测试脚本如下，测试脚本中连接时如果要添加token等可以按脚本中编写，如果不需要就直接删除AddHeader的代码即可：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class WebSocketTest : MonoBehaviour
{
    public string URL = "ws://127.0.0.1:6000";

    public string Content = "测试内容";

    // Start is called before the first frame update
    void Start()
    {
        WebSocketClient.Instance.Init(URL);
        WebSocketClient.Instance.HttpRequest.AddHeader("X-AUTH-TOKEN", "eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiJkNTU0Njg3Zi1jNGZkLTQ0MjQtOGJlOS1lMzEzMWU0Yzk4MDYiLCJzdWIiOiJUSi1ZTCIsImlhdCI6MTY1MzM1NjQ1N30.jE7h6z50etjpEXrC86VXgs3GXnr1y5l7GkV-FiPvaZ4");
        //WebSocketClient.Instance.HttpRequest.AddHeader("Content-Type", "application/json");
        WebSocketClient.Instance.Connect();
    }

    // Update is called once per frame
    void Update()
    {
        if (Input.GetKeyDown(KeyCode.F))
        {
            WebSocketClient.Instance.SendMessage(Content);
        }
        if (Input.GetKeyDown(KeyCode.Q))
        {
            WebSocketClient.Instance.DisConnect();
        }
        if (Input.GetKeyDown(KeyCode.C))
        {
            WebSocketClient.Instance.Connect(URL);
        }
    }
}
TenderRain。
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Unity WebSocket建立长链接
qq_43912395的博客
06-23 1095
首先需要用到 Best HTTP (Pro) 插件 链接: 直接上代码,里面已经包含了注释 using BestHTTP.WebSocket; using UnityEngine; using System; using BestHTTP.WebSocket.Frames; using LitJson; public class WebSocket2 : MonoBehaviour { private static WebSocket2 instance; public st..
unity websocket连接
08-22
支持游戏长连接，方便好用
Unity 实现WebSocket 简单通信——客户端
最新发布
2301_79311694的博客
06-11 538
【代码】Unity 实现WebSocket 简单通信——客户端
Unity 连接WebSocket（ws://）服务器
weixin_30911451的博客
07-01 1871
Unity 连接ws，不用任何插件，忙活了一天终于搞定了，一直连接不上，原来是没有添加header， 代码比较简单，直接贴出来普度众生 using System; using System.Net.WebSockets; using System.Text; using System.Threading; using UnityEngine; public c...
Unity长连接
weixin_33967071的博客
06-02 777
http://blog.csdn.net/claine/article/details/52374546  
unity 连接WebSocket
地球OL重生之我是程序员
09-15 3507
unity 连接WebSocket
unty websocket 客户端 服务端 通信
11-06
1. 创建服务端：在Unity中，通常需要在单独的应用程序或服务器上运行WebSocket服务端，但WebSocketSharp同样提供了服务端库。在服务端，你需要创建一个WebSocketServer实例并设置监听端口。 ```csharp WebSocket...
WebSocket服务端
05-31
在Unity3D中，开发WebSocket服务端应用通常需要使用第三方库，如UnityWebSocket或UniWebSocket等。这些库封装了WebSocket的底层细节，提供了易于使用的API，允许开发者轻松地创建和管理WebSocket连接。在Unity中，你...
unity websocket 聊天室案例
02-20
WebSocket API在Unity中的实现通常是通过第三方库，如Unity Asset Store中的"UnityWebSocket"或者"WebSocketSharp"等。这些库封装了WebSocket协议，使得开发者能更方便地在Unity中创建和管理WebSocket连接。 接下来...
UnityWebSocket
06-02
这是客户端，服务端：https://blog.csdn.net/abcd5711664321/article/details/125094523?spm=1001.2014.3001.5502 服务器阿里云 亲测 能用
unity3d websocket 客户端库 socket.io v3 v4
07-31
unity3d商城付费资源，用于实现websocket客户端，有服务端范例代码
unity通过WebAPI连接Websocket实现讯飞语音识别与合成
06-03
unity写的讯飞语音识别合成与评测功能，走的是webapi,连接讯飞WebSocket服务器没有接入任何sdk，也没有多余插件，开发工具unity2019.3.6 ，真正实现了跨平台，不用在每个平台重新接入sdk这么麻烦了！
Unity组件开发--长连接webSocket
一个人的夏天
01-11 2092
6.定义心跳协议类：HeartBeatServiceGameObject。5.定义协议索引管理，添加长连接的协议：ProtoMaps。8.定义服务器对应的协议消息：TestProto.cs。3.定义包协议结构：PackageProtocol。1.下载安装UnityWebSocket 插件。
Unity使用C#实现简单Scoket连接及服务端与客户端通讯
真像大白阿的博客
03-05 8736
简介：网络编程是个很有意思的事情，偶然翻出来很久之前刚开始看Socket的时候写的一个实例，贴出来吧Unity中实现简单的Socket连接，c#中提供了丰富的API，直接上代码。服务端代码： Thread connectThread;//当前服务端监听子线程 public string address;//当前地址 public int port;//当前本地端口 T...
Unity 创建 websocket 链接
这知识它不进脑子啊
04-02 2724
using System.Collections; using System.Collections.Generic; using System.Text; using LitJson; using UnityEngine; using WebSocketSharp; public class WebsocketTest : MonoBehaviour { private string S...
Unity网络连接之Socket（基于UnityWebSocket插件）
qq1342753906的博客
05-27 1439
Unity使用Socket来接入网络也是较为常见的。 private void ConnectWeb() { moveAgvData = MoveAGVData.CreateInstance(); WebSocketState state = socket == null ? WebSocketState.Closed : socket.ReadyState; socket = new WebSocket(url); socke
Unity 如何使用KCP实现长连接
TxNet
01-16 5236
unity接入kcp 一.前言 KCP是一种基于UDP的上层协议，项目地址：KCP – A Fast and Reliable ARQ Protocol，以下是github上的介绍： KCP是一个快速可靠协议，能以比 TCP浪费10%-20%的带宽的代价，换取平均延迟降低 30%-40%，且最大延迟降低三倍的传输效果。纯算法实现，并不负责底层协议（如UDP）的收发，需要使用者自己定义下层数据包的发送方式，以 callback的方式提供给 KCP。 连时钟都需要外部传递进来，内部不会有任何一次系统调用。 整
Unity3D与Web之间的通信
shiyigongteng的专栏
06-27 3994
本示例利用U3D2.5中的Island Demo项目为例，加入代码，显示Unity3D与Web之间的通信方法。运行环境为Unity4D 4.0   1、Unity3D中设置 在U3D下建立空物体WebConnect，为其添加代码WebConnect.js 具体代码如下 WebConnect.js //接收第一人称参数 var fpc:GameObject;   /
unity 实现websocket服务端
07-04
综上所述，要在 Unity 中实现 WebSocket 服务端，我们可以利用 .NET 中的 HttpListener 类来监听客户端连接，并在处理请求过程中实现 WebSocket 的相关逻辑。这样就可以通过 Unity 实现 WebSocket 服务端了。 ### ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

TenderRain。

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值