【Unity】WebSocket通信

1 前言

        Unity客户端常用的与服务器通信的方式有socket、http、webSocket。本文主要实现一个简单的WebSocket通信案例,包含客户端、服务器,实现了两端的通信以及客户端向服务器发送关闭连接请求的功能。实现上没有使用Unity相关插件,使用的就是.Net本身的WebSocket。

2 WebSocket简介

        WebSocket是一种基于TCP的应用层网络协议,客户端与服务器经过一次 HTTP 握手,两者之间便可以建立持久性的连接,进而使得客户端与服务器之间能够进行双向实时通信(全双工通信)。PS:网上有更详细的信息,这里就不展开了。

3 代码

        代码分客户端代码、服务器代码。客户端为Unity客户端,服务器是VS控制台程序。首先运行服务器代码,之后再运行客户端代码,完成连接后,在客户端输入框中输入内容,之后点击“发送信息”按钮,向服务器发送信息,点击“断开连接”按钮,向服务器发送断开连接请求,在服务器命令行窗口内输入内容按下回车即可向客户端发送信息。
        PS:先运行客户端再运行服务器也行,但客户端请求连接短时间内得不到回复便会抛出异常,手速得快。所以最好先运行服务器提前开启监听。

3.1 客户端代码

GameStart.cs

using UnityEngine;

public class GameStart : MonoBehaviour
{
    //发送的消息变量
    private string msg = null;

    void Start()
    {
        //连接服务器。
        NetManager.M_Instance.Connect("ws://127.0.0.1:8888");   //本机地址
    }

    //绘制UI
    private void OnGUI()
    {
        //绘制输入框,以及获取输入框中的内容
        //PS:第二参数必须是msg,否则在我们输入后,虽然msg可以获得到输入内容,但马上就被第二参数在下一帧重新覆盖。
        msg = GUI.TextField(new Rect(10, 10, 100, 20), msg);

        //绘制按钮,以及按下发送信息按钮,发送信息
        if (GUI.Button(new Rect(120, 10, 80, 20), "发送信息") && msg != null)
        {
            NetManager.M_Instance.Send(msg);
        }

        //绘制按钮,以及按下断开连接按钮,发送断开连接请求
        if (GUI.Button(new Rect(210, 10, 80, 20), "断开连接"))
        {
            Debug.Log("向服务器请求断开连接......");
            NetManager.M_Instance.CloseClientWebSocket();
        }
        
    }
}

NetManager.cs(单例,不需要挂到游戏对象上)

using System;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using UnityEngine;

public class NetManager
{
    #region 实现单例的代码
    //变量
    private volatile static NetManager m_instance;          //单例本身。使用volatile关键字修饰,禁止优化,确保多线程访问时访问到的数据都是最新的
    private static object m_locker = new object();          //线程锁。当多线程访问时,同一时刻仅允许一个线程访问

    //属性
    public static NetManager M_Instance
    {
        get
        {
            //线程锁。防止同时判断为null时同时创建对象
            lock (m_locker)
            {
                //如果不存在对象则创建对象
                if (m_instance == null)
                {
                    m_instance = new NetManager();
                }
            }
            return m_instance;
        }
    }
    #endregion

    //私有化构造
    private NetManager() { }

    //客户端webSocket
    private ClientWebSocket m_clientWebSocket;
    //处理接收数据的线程
    private Thread m_dataReceiveThread;
    //线程持续执行的标识符
    private bool m_isDoThread;


    /// <summary>
    /// ClientWebSocket,与服务器建立连接。
    /// </summary>
    /// <param name="uriStr"></param>
    public void Connect(string uriStr)
    {
        try
        {
            //创建ClientWebSocket
            m_clientWebSocket = new ClientWebSocket();

            //初始化标识符
            m_isDoThread = true;

            //创建线程
            m_dataReceiveThread = new Thread(ReceiveData);  //创建数据接收线程  
            m_dataReceiveThread.IsBackground = true;        //设置为后台可以运行,主线程关闭时,此线程也会关闭(实际在Unity中并没什么用,还是要手动关闭)

            //设置请求头部
            //m_clientWebSocket.Options.SetRequestHeader("headerName", "hearValue");

            //开始连接
            var task = m_clientWebSocket.ConnectAsync(new Uri(uriStr), CancellationToken.None);
            task.Wait();    //等待

            //启动数据接收线程
            m_dataReceiveThread.Start(m_clientWebSocket);

            //输出提示
            if (m_clientWebSocket.State == WebSocketState.Open)
            {
                Debug.Log("连接服务器完毕。");
            }
        }
        catch (WebSocketException ex)
        {
            Debug.LogError("连接出错:" + ex.Message);
            Debug.LogError("WebSokcet状态:" + m_clientWebSocket.State);
            //关闭连接
            //函数内可能需要考虑WebSokcet状态不是WebSocketState.Open时如何关闭连接的情况。目前没有处理这种情况。
            //比如正在连接时出现了异常,当前状态还是Connecting状态,那么该如何停止呢?
            //虽然我有了解到ClientWebSocket包含的Abort()、Dispose()方法,但并未出现过这种异常情况所以也没继续深入下去,放在这里当个参考吧。
            CloseClientWebSocket();
        }

    }

    /// <summary>
    /// 持续接收服务器的信息。
    /// </summary>
    /// <param name="socket"></param>
    private void ReceiveData(object socket)
    {
        //类型转换
        ClientWebSocket socketClient = (ClientWebSocket)socket;
        //持续接收信息
        while (m_isDoThread)
        {
            //接收数据
            string data = Receive(socketClient);
            //数据处理(可以和服务器一样使用事件(委托)来处理)
            if (data != null)
            {
                Debug.Log("接收的服务器消息:" + data);
            }
        }
        Debug.Log("接收信息线程结束。");
    }

    /// <summary>
    /// 接收服务器信息。
    /// </summary>
    /// <param name="socket"></param>
    /// <returns></returns>
    private string Receive(ClientWebSocket socket)
    {
        try
        {
            //接收消息时,对WebSocketState是有要求的,所以加上if判断(如果不是这两种状态,会报出异常)
            if (socket != null && (socket.State == WebSocketState.Open || socket.State == WebSocketState.CloseSent))
            {
                byte[] arrry = new byte[1024];  //注意长度,如果服务器发送消息过长,这也需要跟着调整
                ArraySegment<byte> buffer = new ArraySegment<byte>(arrry);  //实例化一个ArraySegment结构体
                //接收数据
                var task = socket.ReceiveAsync(buffer, CancellationToken.None);
                task.Wait();//等待

                //仅作状态展示。在客户端发送关闭消息后,服务器会回复确认信息,在收到确认信息后状态便是CloseReceived,这里打印输出。
                Debug.Log("socekt当前状态:" + socket.State);

                //如果是结束消息确认,则返回null,不再解析信息
                if (socket.State == WebSocketState.CloseReceived || task.Result.MessageType == WebSocketMessageType.Close)
                {
                    return null;
                }
                //将接收数据转为string类型,并返回。注意只解析我们接收到的字节数目(task.Result.Count)
                return Encoding.UTF8.GetString(buffer.Array, 0, task.Result.Count);
            }
            else
            {
                return null;
            }
        }
        catch (WebSocketException ex)
        {
            Debug.LogError("接收服务器信息错误:" + ex.Message);
            CloseClientWebSocket();
            return null;
        }
    }

    /// <summary>
    /// 发送消息
    /// </summary>
    /// <param name="content"></param>
    public void Send(string content)
    {
        try
        {
            //发送消息时,对WebSocketState是有要求的,加上if判断(如果不是这两种状态,会报出异常)
            if (m_clientWebSocket != null && (m_clientWebSocket.State == WebSocketState.Open || m_clientWebSocket.State == WebSocketState.CloseReceived))
            {
                ArraySegment<byte> array = new ArraySegment<byte>(Encoding.UTF8.GetBytes(content)); //创建内容的字节编码数组并实例化一个ArraySegment结构体
                var task = m_clientWebSocket.SendAsync(array, WebSocketMessageType.Binary, true, CancellationToken.None);  //发送
                task.Wait();  //等待

                Debug.Log("发送了一个消息到服务器。");
            }
        }
        catch (WebSocketException ex)
        {
            Debug.LogError("向服务器发送信息错误:" + ex.Message);
            CloseClientWebSocket();
        }
    }

    /// <summary>
    /// 关闭ClientWebSocket。
    /// </summary>
    public void CloseClientWebSocket()
    {
        //关闭Socket
        if (m_clientWebSocket != null && m_clientWebSocket.State == WebSocketState.Open)
        {
            var task = m_clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
            Debug.Log("如果打印过快,↓下面↓这个socket状态可能为Open,出现Open就多试几次,我们想看的是CloseSent状态。");
            Debug.Log("socekt当前状态:" + m_clientWebSocket.State);
            task.Wait();
            Debug.Log("socekt当前状态:" + m_clientWebSocket.State);
            Debug.Log("连接已断开。");
        }
        //关闭线程
        if (m_dataReceiveThread != null && m_dataReceiveThread.IsAlive)
        {
            m_isDoThread = false;   //别想Abort()了,unity中的线程关闭建议使用bool来控制线程结束。
            m_dataReceiveThread = null;
        }
    }
}

 3.2 服务器代码

Program.cs

using System;
using System.Threading.Tasks;

internal class Program
{
    //创建一个WebSocketService
    private static WebSocketService m_serviceSocket;
    static void Main(string[] args)
    {
        //开启后台线程,监听客户端连接
        Task.Run(() =>
        {
            m_serviceSocket = new WebSocketService();           //实例化一个WebSocketService
            m_serviceSocket.m_DataReceive += HandleDataRecive;    //监听消息事件,处理函数,当有接收到客户端消息时会调用此处理函数来处理
            m_serviceSocket.Listening();                        //开始监听
        });

        //持续接收键盘输入,为了能多次向客户端发消息,同时起到不关闭控制台程序的作用
        while (true)
        {
            //输入内容,发送消息到客户端
            string msg = Console.ReadLine();
            m_serviceSocket.Send(msg);
        }
    }

    /// <summary>
    /// 消息事件处理函数
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private static void HandleDataRecive(object sender, string e)
    {
        Console.WriteLine("接收的客户端消息:" + e);
    }
}

WebSocketService.cs

using System;
using System.Net;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

internal class WebSocketService
{
    HttpListener m_httpListener;                //监听者
    private WebSocket m_webSocket;              //socket
    public event EventHandler<string> m_DataReceive;  //事件(委托),消息处理函数添加到这里。
    private bool m_isDoThread;              //线程持续执行标识符

    public void Listening()
    {
        Console.WriteLine("正在监听...");
        //监听Ip、端口
        m_httpListener = new HttpListener();
        m_httpListener.Prefixes.Add("http://127.0.0.1:8888/");  //监听本机地址
        m_httpListener.Start();
        var httpListenContext = m_httpListener.GetContext();    //这里就等待客户端连接了。
        var webSocketContext = httpListenContext.AcceptWebSocketAsync(null);
        m_webSocket = webSocketContext.Result.WebSocket;
        //初始化标识符
        m_isDoThread = true;
        //开启后台线程,持续接收客户端消息
        Task.Run(() =>
        {
            while (m_isDoThread)
            {
                //接收消息
                string msg = Receive(m_webSocket);
                if (msg != null)
                {
                    m_DataReceive?.Invoke(m_webSocket, msg);  //数据处理
                }
            }
            Console.WriteLine("接收信息线程结束。");
        });
        Console.WriteLine("连接建立成功!");
    }

    /// <summary>
    /// 发送信息
    /// </summary>
    /// <param name="content">发送的内容</param>
    public void Send(string content)
    {
        //同客户端,WebSocketState要求
        if (m_webSocket != null && (m_webSocket.State == WebSocketState.Open || m_webSocket.State == WebSocketState.CloseReceived))
        {
            ArraySegment<byte> array = new ArraySegment<byte>(Encoding.UTF8.GetBytes(content)); //创建数组,并存储发送内容字节编码
            var task = m_webSocket.SendAsync(array, WebSocketMessageType.Binary, true, CancellationToken.None);  //发送   
            task.Wait();          //等待
            Console.WriteLine("发送了一个消息到客户端。");
        }
    }

    /// <summary>
    /// 接收信息
    /// </summary>
    /// <param name="webSocket"></param>
    /// <returns></returns>
    private string Receive(WebSocket webSocket)
    {
        //同客户端,WebSocketState要求
        if (webSocket != null && (webSocket.State == WebSocketState.Open || webSocket.State == WebSocketState.CloseSent))
        {
            //接收消息
            byte[] arrry = new byte[1024];  //大小根据情况调整
            ArraySegment<byte> buffer = new ArraySegment<byte>(arrry);
            var task = webSocket.ReceiveAsync(buffer, CancellationToken.None);
            task.Wait();

            Console.WriteLine("当前socket状态:" + webSocket.State);
            //当收到关闭连接的请求时(关闭确认)
            if (webSocket.State == WebSocketState.CloseReceived || task.Result.MessageType == WebSocketMessageType.Close)
            {
                webSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "Acknowledge Close frame", CancellationToken.None);//关闭确认
                Console.WriteLine("当前socket状态:" + webSocket.State);
                Console.WriteLine("连接已断开。");
                //关闭线程
                m_isDoThread = false;

                return null;
            }
            //将接收数据转为string类型,并返回。注意只解析我们接收到的字节数目(task.Result.Count)
            return Encoding.UTF8.GetString(buffer.Array, 0, task.Result.Count);
        }
        else
        {
            return null;
        }
    }
}

4 演示

通信、断开连接: 

socket状态变化截图:

5 webSocket状态变化

        这里说一下客户端在发送断开连接请求时,客户端与服务器socket的状态变化,在代码中socket状态变化时都会有打印出来。
        状态变化:客户端使用CloseAsync申请关闭,客户端socket转为CloseSent状态;服务器接收到请求后,服务器socket转为CloseReceived状态;服务器执行CloseOutputAsync确认关闭,自己转为Closed状态;客户端受到确认转为CloseReceived,经过一小段时间(非常短)转为Closed状态。

6 结束语

        开始在找Unity WebSocket通信这方面资料时,发现大多数的方案都是使用插件,插件的确很方便,用起来也比较舒服,但我个人还是倾向于使用非插件的方法,所以就研究了下。所提供的代码只是实现了简单的通信与控制,演示了相关API,在具体到项目中时肯定还要根据需要进行修改补充。

        列举目前代码中可优化的部分内容(想要真正应用到项目,那么要完善和考虑的东西非常多,这里只列举几个):

  1. 发送和关闭方法处于主线程中(异常抛出时,关闭方法在非主线程中执行,直接调用在主线程),当task.Wait()时便会阻塞主线程,当时间等待过长时就会出现卡死主线程的情况,所以可以考虑创建两个新线程来处理发送、关闭,就像接收消息线程一样,发送线程负责整个客户端的消息发送,关闭线程负责客户端断开连接请求,避免可能出现的卡死主线程的情况。
  2. 在CloseClientWebSocket()方法中还应该考虑到连接到一半时出错该如何关闭socket的处理情况,但目前并未遇到这种情况,所以也没有针对这种情况进行处理。我是在查阅资料时看到有人出现过这种错误,但后来再找那篇文章时找不到了.......所以目前就先这样吧,以后有机会再更新。更具体的内容在代码注释中有说明。
  3. 关于catch抛出的异常的问题,在代码中我catch的是WebSocketException,但到具体项目中要根据情况再修改,如服务器不监听的情况下客户端连接超时时会抛出异常,但使用WebSocketException我们就catch不到抛出的异常,使用Exception才可以catch到,那如果我们想捕获此异常并提示连接超时之类信息时就需要将WebSocketException修改为Exception了。
  4. 使用事件(委托)来处理接收到的消息时,最好单独开个线程来处理消息,接收消息的线程只负责接收并存储消息,而处理则由另一个线程负责(也可以多个线程处理),当然,也可以直接使用主线程来处理消息。这样做是为了减少接收线程的任务量,让其可以更专注于接收与存储,及时接收数据。
  5. 代码中接收数据每次都会new一个新数组,接收数据不频繁时无所谓,但如果过于频繁,最好把数组放到外面只new一个,之后每次接收之前Clear一下,以Clear替换new操作,这样性能上会好些。
  6. 断线重连。
  7. 心跳包。