devbox
菜鸟追梦旅行
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Unity web聊天通讯功能开发（1）_unity besthttp websocket

作者：菜鸟追梦旅行 | 2024-02-15 09:07:36

赞

踩

unity besthttp websocket

注：发文章我不像某些大咖只发大概思路，每一步我的操作我都会写下来，如果实在看不懂就去下载我的案例哈，本文章只研究下如何互发文字通讯，web端互发图片的等我研究出来再发哈

Unity做聊天室，网上大多数都是通过socket做的，我之前也尝试了一下不难，但是最近的项目都是发布成webgl，我发现一个问题，那就是web端不支持socket，通过查找资料，我找到另一个通讯方式——websocket，先普及型websocket。

WebSocket protocol 是HTML5一种新的协议。它实现了浏览器与服务器全双工通信(full-duplex)。一开始的握手需要借助HTTP请求完成。

1.原理：

WebSocket同HTTP一样也是应用层的协议，但是它是一种双向通信协议，是建立在TCP之上的。

2.连接过程 —— 握手过程

  • 1. 浏览器、服务器建立TCP连接，三次握手。这是通信的基础，传输控制层，若失败后续都不执行。
  • 2. TCP连接成功后，浏览器通过HTTP协议向服务器传送WebSocket支持的版本号等信息。（开始前的HTTP握手）
  • 3. 服务器收到客户端的握手请求后，同样采用HTTP协议回馈数据。
  • 4. 当收到了连接成功的消息后，通过TCP通道进行传输通信。

3.WebSocket与HTTP的关系

相同点

  • 1. 都是一样基于TCP的，都是可靠性传输协议。
  • 2. 都是应用层协议。

不同点

  • 1. WebSocket是双向通信协议，模拟Socket协议，可以双向发送或接受信息。HTTP是单向的。
  • 2. WebSocket是需要握手进行建立连接的。

联系

WebSocket在建立握手时，数据是通过HTTP传输的。但是建立之后，在真正传输时候是不需要HTTP协议的。

4.WebSocket与Socket的关系

Socket其实并不是一个协议，而是为了方便使用TCP或UDP而抽象出来的一层，是位于应用层和传输控制层之间的一组接口。

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。

当两台主机通信时，必须通过Socket连接，Socket则利用TCP/IP协议建立TCP连接。TCP连接则更依靠于底层的IP协议，IP协议的连接则依赖于链路层等更低层次。

WebSocket则是一个典型的应用层协议。

区别

Socket是传输控制层协议，WebSocket是应用层协议。

5.在Unity中，WebSocket比Socket更适用各个平台的开发

以下介绍下Unity发布Web,通讯功能如何做，以聊天室为案例

1.导入BestHttp插件

这个插件包含所有即使通讯方式的简单使用，下载地址为BestHttp通讯插件-C#文档类资源-CSDN下载

2.布置UI

这边我只做了两个简易界面，一个是登录界面，一个是聊天窗口界面，功能如图所示

 

 3.构建服务端

使用VS新建项目C#控制台

 

通过包管理器，引用websocket和litjson相关组件

 

 

 

除了控制台自带的类Program，还需新建类MessageData，ClientController，各代码如下：

  1. using SuperSocket.SocketBase;
  2. using SuperWebSocket;
  3. using System;
  4. using System.Collections.Generic;
  5.  
  6. class Program
  7. {
  8.     public static List<ClientController> clientControllerList = new List<ClientController>();
  9.     static void Main(string[] args)
  10.     {
  11.        // Console.WriteLine("Press any key to start the WebSocketServer!");
  12.  
  13.         //Console.ReadKey();
  14.        // Console.WriteLine();
  15.  
  16.         var appServer = new WebSocketServer();
  17.       
  18.  
  19.         //Setup the appServer
  20.         if (!appServer.Setup(2012)) //Setup with listening port
  21.         {
  22.             Console.WriteLine("Failed to setup!");
  23.             Console.ReadKey();
  24.             return;
  25.         }
  26.  
  27.         appServer.NewSessionConnected += delegate (WebSocketSession session)
  28.         {
  29.           //  Console.WriteLine("新玩家加入: " + session.SessionID);
  30.           //  session.Send("新玩家加入: " + session.SessionID);
  31.         };
  32.  
  33.         appServer.SessionClosed += delegate (WebSocketSession session, CloseReason value)
  34.         {
  35.             
  36.             for (int i = 0; i < clientControllerList.Count; i++)
  37.             {
  38.                 if (session.SessionID == clientControllerList[i].session.SessionID)
  39.                 {
  40.                     ClientController client = clientControllerList[i];
  41.                  client .SendMessageDataToAllClientWithOutSelf(client.nickName + "离开聊天室");
  42.                     Console.WriteLine(client.nickName+ "离开聊天室");
  43.                     clientControllerList.Remove(clientControllerList[i]);
  44.                     return ;
  45.                 }
  46.             }
  47.           
  48.        
  49.         };
  50.         appServer.NewMessageReceived += delegate (WebSocketSession session, string value)
  51.         {
  52.              MessageData data = LitJson.JsonMapper.ToObject<MessageData>(value);
  53.             ClientController clientController =GetClient(session);
  54.  
  55.             string msg = "";
  56.              switch (data.msgType)
  57.              {
  58.  
  59.                  case MessageType.Login://如果是登陆消息
  60.                     clientController.nickName = data.nickname;
  61.                    
  62.                   //   session.Send("玩家加入: " + data.name);
  63.                      clientControllerList.Add(clientController);
  64.                     msg = clientController.nickName + "加入聊天室";
  65.                      Console.WriteLine(clientController.nickName + "加入聊天室");
  66.                     break;
  67.                  case MessageType.Chat://如果是聊天消息
  68.                      Console.WriteLine(clientController.nickName + "说: " + data.msg);
  69.                     data.nickname = clientController.nickName;
  70.                     msg = LitJson.JsonMapper.ToJson(data);
  71.                     break;
  72.                  case MessageType.LogOut://客户端请求退出
  73.  
  74.                      Console.WriteLine(clientController.nickName + "离开聊天室");
  75.                     clientControllerList.Remove(clientController);
  76.                     msg = clientController.nickName + "离开聊天室";
  77.  
  78.                     break;
  79.              }
  80.             clientController.SendMessageDataToAllClientWithOutSelf(msg);
  81.  
  82.         };
  83.         Console.WriteLine();
  84.  
  85.         //Try to start the appServer
  86.         if (!appServer.Start())
  87.         {
  88.             Console.WriteLine("Failed to start!");
  89.             Console.ReadKey();
  90.             return;
  91.         }
  92.  
  93.         Console.WriteLine("The server started successfully, press key 'q' to stop it!");
  94.  
  95.         while (Console.ReadKey().KeyChar != 'q')
  96.         {
  97.             Console.WriteLine();
  98.             continue;
  99.         }
  100.  
  101.         //Stop the appServer
  102.         appServer.Stop();
  103.  
  104.         Console.WriteLine();
  105.         Console.WriteLine("The server was stopped!");
  106.         Console.ReadKey();
  107.     }
  108.  
  109.     public static ClientController GetClient(WebSocketSession session)
  110.     {
  111.         for (int i = 0; i < clientControllerList.Count; i++)
  112.         {
  113.             if (session.SessionID == clientControllerList[i].session.SessionID)
  114.             {
  115.                 return clientControllerList[i];
  116.             }
  117.         }
  118.         return new ClientController(session);
  119.     }
  120. }
  1. using SuperWebSocket;
  2. using System;
  3.  
  4. class ClientController
  5. {
  6.     /// <summary>
  7.     /// 用户链接的通道
  8.     /// </summary>
  9.     public WebSocketSession session;
  10.     /// <summary>
  11.     /// 昵称
  12.     /// </summary>
  13.     public string nickName;
  14.     //接收的线程
  15.  
  16.     public ClientController(WebSocketSession  socket)
  17.     {
  18.         session= socket;
  19.        
  20.     }
  21.     
  22.  
  23.     /// <summary>
  24.     /// 广播消息，排除掉自己
  25.     /// </summary>
  26.     /// <param name="data"></param>
  27.    public  void SendMessageDataToAllClientWithOutSelf(string data)
  28.     {
  29.         //5   i=3
  30.         for (int i = 0; i < Program.clientControllerList.Count; i++)
  31.         {
  32.             if (Program.clientControllerList[i] != this)
  33.             {
  34.                 Program.clientControllerList[i].SendToClient(data);
  35.             }
  36.           
  37.  
  38.         }
  39.     }
  40.  
  41.  
  42.     void SendToClient(string data)
  43.     {
  44.         session.Send(data);
  45.     }
  46.  
  47.    
  48. }
  1. /// <summary>
  2. /// 简单的协议类型
  3. /// </summary>
  4. public enum MessageType
  5. {
  6.     Chat = 0,//聊天
  7.     Login = 1,//登陆
  8.     LogOut = 2,//登出
  9. }
  10. /// <summary>
  11. /// 消息体
  12. /// </summary>
  13. public class MessageData
  14. {
  15.     /// <summary>
  16.     /// 消息类型
  17.     /// </summary>
  18.     public MessageType msgType;
  19.     /// <summary>
  20.     /// 消息内容
  21.     /// </summary>
  22.     public string msg;
  23.     public string nickname;
  24. }

此时点击运行，即可运行服务端

 

 4.客户端代码

新建类WebSocketTest，MessageData，ChatItem，代码如下：

  1. using LitJson;
  2. /// <summary>
  3. /// 简单的协议类型
  4. /// </summary>
  5. public enum MessageType
  6. {
  7.     Chat = 0,//聊天
  8.     Login = 1,//登陆
  9.     LogOut = 2,//登出
  10. }
  11. /// <summary>
  12. /// 消息体
  13. /// </summary>
  14. public class MessageData
  15. {
  16.     /// <summary>
  17.     /// 消息类型
  18.     /// </summary>
  19.     public MessageType msgType;
  20.     /// <summary>
  21.     /// 消息内容
  22.     /// </summary>
  23.     public string msg;
  24.     public string nickname;
  25. }
  1. using System;
  2. using UnityEngine;
  3. using BestHTTP;
  4. using BestHTTP.WebSocket;
  5. using UnityEngine.UI;
  6. using BestHTTP.Examples.Helpers;
  7.  
  8. namespace BestHTTP.Examples.Websockets
  9. {
  10.     public class WebSocketTest : BestHTTP.Examples.Helpers.SampleBase
  11.     {
  12.         // [SerializeField]
  13.         //  [Tooltip("The WebSocket address to connect")]
  14.         private string address = "ws://192.168.2.50:2012";
  15.  
  16.         [SerializeField]
  17.         private InputField name_input;
  18.         [SerializeField]
  19.         private InputField content_input;
  20.  
  21.         [SerializeField]
  22.         private ScrollRect _scrollRect;
  23.  
  24.         [SerializeField]
  25.         private RectTransform _contentRoot;
  26.  
  27.         [SerializeField]
  28.         private TextListItem _listItemPrefab;
  29.  
  30.         [SerializeField]
  31.         private int _maxListItemEntries = 100;
  32.        
  33.  
  34.  
  35.  
  36. #pragma warning restore
  37.  
  38.         /// <summary>
  39.         /// Saved WebSocket instance
  40.         /// </summary>
  41.         WebSocket.WebSocket webSocket;
  42.         public GameObject loginGo;
  43.         public GameObject chatGo;
  44.  
  45.         protected override void Start()
  46.         {
  47.             base.Start();
  48.         }
  49.         public void LoginIn()
  50.         {
  51.             if (name_input.text == "" || name_input.text == null)
  52.                 return;
  53.             // Create the WebSocket instance
  54.             this.webSocket = new WebSocket.WebSocket(new Uri(address));
  55.  
  56. #if !UNITY_WEBGL
  57.             this.webSocket.StartPingThread = true;
  58.  
  59. #if !BESTHTTP_DISABLE_PROXY
  60.             if (HTTPManager.Proxy != null)
  61.                 this.webSocket.InternalRequest.Proxy = new HTTPProxy(HTTPManager.Proxy.Address, HTTPManager.Proxy.Credentials, false);
  62. #endif
  63. #endif
  64.  
  65.             // Subscribe to the WS events
  66.             this.webSocket.OnOpen += OnOpen;
  67.             this.webSocket.OnMessage += OnMessageReceived;
  68.             this.webSocket.OnClosed += OnClosed;
  69.             this.webSocket.OnError += OnError;
  70.  
  71.             // Start connecting to the server
  72.             this.webSocket.Open();
  73.          //   AddText("Connecting...");
  74.  
  75.         }
  76.         public void Chat()
  77.         {
  78.             if (content_input.text == "" || content_input.text == null)
  79.                 return;
  80.             MessageData data = new MessageData();
  81.             data.msgType = MessageType.Chat;
  82.             data.msg = content_input.text;
  83.             string json = JsonUtility.ToJson(data);
  84.             webSocket.Send(json);
  85.           ChatItem chatItem  =  (ChatItem)AddText(string.Format(" <color=yellow>我：</color>\n{0}",data.msg));
  86.                chatItem.AddLeftPadding(20);
  87.               chatItem.SetTextAlignment(TextAnchor.MiddleRight);
  88.  
  89.         }
  90.  
  91.  
  92.         public void LoginOut()
  93.         {
  94.             MessageData data = new MessageData();
  95.             data.msgType = MessageType.LogOut;
  96.             data.msg = "退出";
  97.             string json = JsonUtility.ToJson(data);
  98.             webSocket.Send(json);
  99.             webSocket.Close(1000, "Bye!");
  100.  
  101.             webSocket.OnOpen -= OnOpen;
  102.             webSocket.OnMessage -= OnMessageReceived;
  103.             webSocket.OnClosed -= OnClosed;
  104.             webSocket = null;
  105.             AddText("Closing!");
  106.             loginGo.SetActive(true);
  107.             chatGo.SetActive(false);
  108.  
  109.         }
  110.  
  111.  
  112.         #region WebSocket Event Handlers
  113.  
  114.         /// <summary>
  115.         /// Called when the web socket is open, and we are ready to send and receive data
  116.         /// </summary>
  117.         void OnOpen(WebSocket.WebSocket ws)
  118.         {
  119.             AddText("WebSocket Open!");
  120.             MessageData data = new MessageData();
  121.             data.msgType = MessageType.Login;
  122.             data.nickname = name_input.text;
  123.             string json = JsonUtility.ToJson(data);
  124.             webSocket.Send(json);
  125.             loginGo.SetActive(false);
  126.             chatGo.SetActive(true);
  127.         }
  128.  
  129.  
  130.  
  131.         /// <summary>
  132.         /// Called when we received a text message from the server
  133.         /// </summary>
  134.         void OnMessageReceived(WebSocket.WebSocket ws, string message)
  135.         {
  136.             try
  137.             {
  138.                  MessageData data = JsonUtility.FromJson<MessageData>(message);
  139.             AddText(string.Format(" <color=yellow>{0}:</color>\n{1}", data.nickname,data.msg))
  140.                 .AddLeftPadding(20);
  141.             }
  142.             catch (System.Exception ex)
  143.             {
  144.                  AddText(string.Format(" <color=yellow>{0}</color>", message))
  145.                 .AddLeftPadding(20);
  146.             }
  147.             
  148.         }
  149.  
  150.         /// <summary>
  151.         /// Called when the web socket closed
  152.         /// </summary>
  153.         void OnClosed(WebSocket.WebSocket ws, UInt16 code, string message)
  154.         {
  155.             AddText(string.Format("WebSocket closed! Code: {0} Message: {1}", code, message));
  156.  
  157.             webSocket = null;
  158.  
  159.  
  160.         }
  161.  
  162.         /// <summary>
  163.         /// Called when an error occured on client side
  164.         /// </summary>
  165.         void OnError(WebSocket.WebSocket ws, string error)
  166.         {
  167.             AddText(string.Format("An error occured: <color=red>{0}</color>", error));
  168.  
  169.             webSocket = null;
  170.  
  171.  
  172.         }
  173.  
  174.         #endregion
  175.  
  176.  
  177.  
  178.         private TextListItem AddText(string text)
  179.         {
  180.             return GUIHelper.AddText(this._listItemPrefab, this._contentRoot, text, this._maxListItemEntries, this._scrollRect);
  181.         }
  182.  
  183.         void OnDestroy()
  184.         {
  185.             if (this.webSocket != null)
  186.             {
  187.                 this.webSocket.Close();
  188.                 this.webSocket = null;
  189.             }
  190.         }
  191.     }
  192. }
  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using UnityEngine.UI;
  5. namespace BestHTTP.Examples.Helpers
  6. {
  7. public class ChatItem : TextListItem
  8. {
  9.   
  10.     public void SetTextAlignment(TextAnchor textAnchor){
  11.         _text.alignment=textAnchor;
  12.     }    
  13. }
  14. }

5.UI绑定功能

先复制一个“TextListItem”预制件，插件BestHttp里面有，然后去除它本身的脚本，挂上ChatItem脚本，成为一个新的预制件，供后面使用。

挂载脚本并赋值

 将登陆按钮绑定登陆方法，发送按钮绑定发送方法

 

 最后我们复制两个聊天系统，运行查看结果

 

 打包web同样适用

demo：unitywebsocket聊天室案例-Unity3D文档类资源-CSDN下载

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/菜鸟追梦旅行/article/detail/83010
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号