devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

unity使用Socket进行文件上传_byte[]连接 unity

作者：我家自动化 | 2024-02-18 13:57:01

赞

踩

byte[]连接 unity

一、制作思路

1.首先大家要先了解一下、socket一些接口的使用

https://blog.csdn.net/qq_42345116/article/details/122185529

2.思路

2.1首先 我们知道Socket之间传输的数据是Byte数组，所以我们客户端要上传的文件必须是byte数组文件

使用这个方法将文件转换为byte[]数组

  1. #region 将文件转换成byte[] 数组
  2.  
  3.     /// <summary>
  4.     /// 将文件转换成byte[] 数组
  5.     /// </summary>
  6.     /// <param name="fileUrl">文件路径文件名称</param>
  7.     /// <returns>byte[]</returns>
  8.     protected byte[] GetFileData(string fileUrl)
  9.     {
  10.         FileStream fs = new FileStream(fileUrl, FileMode.Open, FileAccess.Read);
  11.         lock (fs)
  12.         {
  13.             try
  14.             {
  15.                 byte[] buffur = new byte[fs.Length];
  16.                 fs.Read(buffur, 0, (int)fs.Length);
  17.  
  18.                 return buffur;
  19.             }
  20.             catch (Exception ex)
  21.             {
  22.                 return null;
  23.             }
  24.             finally
  25.             {
  26.                 if (fs != null)
  27.                 {
  28.                     //关闭资源
  29.                     fs.Close();
  30.                 }
  31.             }
  32.         }
  33.     }
  34.     #endregion

2.2相应的服务器接收到客户端的byte数组文件后要将其反转成文件进行保存

  1.     #region 将byte数组转换为文件并保存到指定地址
  2.     /// <summary>
  3.     /// 将byte数组转换为文件并保存到指定地址
  4.     /// </summary>
  5.     /// <param name="buff">byte数组</param>
  6.     /// <param name="savepath">保存地址</param>
  7.     public static void Bytes2File(byte[] buff, string savepath)
  8.     {
  9.         if (File.Exists(savepath))
  10.         {
  11.             File.Delete(savepath);
  12.         }
  13.  
  14.         FileStream fs = new FileStream(savepath, FileMode.CreateNew);
  15.         BinaryWriter bw = new BinaryWriter(fs);
  16.         bw.Write(buff, 0, buff.Length);
  17.         bw.Close();
  18.         fs.Close();
  19.     }
  20.     #endregion

2.3但是保存文件需要地址（F:/）+文件名称（XXX文件名）+文件类型 （.png）而我们客户端传过来的byte数组没有这些信息，所以这里我用了Json数据进行组合传输

  1. //1.Json数据类
  2. [Serializable]
  3. public class JsonData
  4. {
  5.     public string flieName;      //文件名称(文件名称)
  6.     public byte[] fileData;      //文件byte[]数据
  7. }
  8.  
  9. //2.获取文件名称 类型
  10.  string[] splitData=path.Slip('/'); //将文件路径拆分 为了获取文件名和文件类型
  11.  jsonData = new JsonData()
  12.  {
  13.     flieName = splitData[splitData.Length - 1], //拆分的最后一个一定是文件名.文件类型
  14.     fileData = GetFileData(filePath) //将文件转换为byte[]
  15.  };
  16.  
  17. string data=JsonMapper.ToJson(jsonData);//转换成json
  18. byte[] sendData = Encoding.UTF8.GetBytes(data)//将string转换成byte数组

这样我们就获取到一个json的byte数组数据。

2.4这还没完，要知道在网络中数据是用包来传输的，每个包能存放的byte数量只有那么多，超出了就要分包发送，文件总是很大的，肯定要分包发送，但是我们服务器没有办法判断是否已经接收完客户端的所有文件数据，所以我们客户端需要在服务器接收数据前先发送一个byte数组（这个数组信息代表了文件的总大小），服务器知道了文件大小以后就开始整合数据，直到接收数据大小等于发送的数据大小后，开始转换byte数据

  1. //1.接上文sendData就是我们要发送的json byte数组，我们获取他的长度通过Send发送给服务器
  2. clientSocket.Send(Encoding.UTF8.GetBytes(sendData.Length.ToString()));
  3.

服务器接收处理

  1. //2.这里是服务器要处理
  2.  
  3.   private byte[] result = new byte[1024]; //1.存入的byte值 最大数量1024
  4.     private byte[] subpackageData; //1.分包数据存入信息
  5.  
  6.     int dataLength;     //要接收信息总的长度
  7.     bool isEndData = false; //是否接收到信息总长度
  8.     //开启线程接收数据 （将Socket作为值传入）
  9.     private void ReceiveMessage(object clientSocket)
  10.     {
  11.         Socket myClientSocket = (Socket)clientSocket; //2.转换传入的客户端Socket
  12.         while (true)
  13.         {
  14.             try
  15.             {
  16.                 //接收数据  
  17.                 int receiveNumber = myClientSocket.Receive(result); //3.将客户端得到的byte值写入
  18.  
  19.                 //没有接收信息总长度
  20.                 if (!isEndData)
  21.                 {
  22.                     //接收
  23.                     dataLength = int.Parse(Encoding.UTF8.GetString(result));
  24.                     subpackageData = new byte[0]; //初始化缓冲区
  25.                     Debug.Log("1.接收到信息的总长度： " + dataLength);
  26.                     isEndData = true;
  27.                 }
  28.                 else
  29.                 {
  30.                     //有数据 并且 接收到信息长度后执行
  31.                     if (receiveNumber > 0 && isEndData)
  32.                     {
  33.                         //1.整合数据
  34.                         byte[] newResult = new byte[(subpackageData.Length + receiveNumber)];
  35.                         Array.Copy(subpackageData, 0, newResult, 0, subpackageData.Length); //将上一次分包数据赋值给容器
  36.                         Array.Copy(result, 0, newResult, subpackageData.Length, receiveNumber); //将当前收到的数据赋值给容器
  37.  
  38.                         subpackageData = newResult;
  39.                         Debug.Log("整合后数据长度： " + subpackageData.Length);
  40.  
  41.  
  42.                         //整合的数据超出 或等于数据
  43.                         if (subpackageData.Length >= dataLength)
  44.                         {
  45.                             isEndData = false; //设置没有接收到信息总长度
  46.                             //数据解析
  47.                             string data = Encoding.UTF8.GetString(subpackageData);
  48.                             Debug.Log(data);
  49.                             DisposeData(data);
  50.  
  51.                             myClientSocket.Send(Encoding.UTF8.GetBytes("文件转换成功" + DateTime.Now));
  52.                         }
  53.                     }
  54.                     else
  55.                     {
  56.                         Debug.Log("client： " + ((IPEndPoint)myClientSocket.RemoteEndPoint).Address.ToString() + "断开连接");
  57.                         threadDic[((IPEndPoint)myClientSocket.RemoteEndPoint).Address.ToString()].Abort(); //清除线程
  58.                     }
  59.                 }
  60.  
  61.             }
  62.             catch (Exception ex)
  63.             {
  64.                 //myClientSocket.Shutdown(SocketShutdown.Both); //出现错误 关闭Socket
  65.                 Debug.Log(" 错误信息" + ex); //打印错误信息
  66.                 break;
  67.             }
  68.         }
  69.     }

二、服务器最终代码

  1. using LitJson;
  2. using System;
  3. using System.Collections;
  4. using System.Collections.Generic;
  5. using System.IO;
  6. using System.Net;
  7. using System.Net.Sockets;
  8. using System.Text;
  9. using System.Threading;
  10. using UnityEngine;
  11.  
  12. //Json数据
  13. [Serializable]
  14. public class JsonData
  15. {
  16.     public string operationType; //服务器事件类型（选择服务器要执行的方法）
  17.     public string clientIP;      //客户端本地ip
  18.     public string flieName;      //文件名称(文件名称)
  19.     public byte[] fileData;      //文件byte[]数据
  20. }
  21.  
  22. public class SocketServer : MonoBehaviour
  23. {
  24.     private string myip;
  25.     private int myPort;   //端口  
  26.     string saveFilePath;  //保存地址
  27.     JsonData jsonData;
  28.  
  29.     static Socket serverSocket;
  30.     Thread myThread;
  31.     Dictionary<string, Thread> threadDic = new Dictionary<string, Thread>();//存储线程，程序结束后关闭线程
  32.     private void Start()
  33.     {
  34.         myip = ConfigFile.LoadString("Server");
  35.         myPort = int.Parse(ConfigFile.LoadString("port"));
  36.         saveFilePath = Application.streamingAssetsPath + "/"; //文件保存路径
  37.  
  38.  
  39.         //服务器IP地址  ，127.0.0.1 为本机IP地址
  40.         IPAddress ip = IPAddress.Parse(myip);
  41.         //IPAddress ip = IPAddress.Any; //本机地址
  42.         Debug.Log(ip.ToString());
  43.         serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
  44.  
  45.         IPEndPoint iPEndPoint = new IPEndPoint(ip, myPort);
  46.         serverSocket.Bind(iPEndPoint);  //绑定IP地址：端口  
  47.         serverSocket.Listen(10);        //最多10个连接请求  
  48.                                         //Console.WriteLine("creat service {0} success",
  49.                                         //    serverSocket.LocalEndPoint.ToString());
  50.  
  51.         myThread = new Thread(ListenClientConnect);
  52.         myThread.Start();
  53.         Debug.Log("服务器启动...........");
  54.  
  55.     }
  56.  
  57.     // 监听客户端是否连接  
  58.     private void ListenClientConnect()
  59.     {
  60.         while (true)
  61.         {
  62.             Socket clientSocket = serverSocket.Accept(); //1.创建一个Socket 接收客户端发来的连接请求 没有时堵塞
  63.             string clientIp = ((IPEndPoint)clientSocket.RemoteEndPoint).Address.ToString();
  64.  
  65.             Debug.Log("客户端连接成功：" + clientIp);
  66.             clientSocket.Send(Encoding.UTF8.GetBytes("连接成功")); //2.向客户端发送 连接成功 消息
  67.             Thread receiveThread = new Thread(ReceiveMessage); //3.为已经连接的客户端创建一个线程 此线程用来处理客户端发送的消息
  68.             receiveThread.Start(clientSocket); //4.开启线程
  69.  
  70.             //将已经连接的客户端添加到字典中
  71.             if (!threadDic.ContainsKey(clientIp))
  72.             {
  73.                 threadDic.Add(clientIp, receiveThread);
  74.             }
  75.         }
  76.     }
  77.  
  78.  
  79.     private byte[] result = new byte[1024]; //1.存入的byte值 最大数量1024
  80.     private byte[] subpackageData; //1.分包数据存入信息
  81.  
  82.     int dataLength;     //要接收信息总的长度
  83.     bool isEndData = false; //是否接收到信息总长度
  84.     //开启线程接收数据 （将Socket作为值传入）
  85.     private void ReceiveMessage(object clientSocket)
  86.     {
  87.         Socket myClientSocket = (Socket)clientSocket; //2.转换传入的客户端Socket
  88.         while (true)
  89.         {
  90.             try
  91.             {
  92.                 result = new byte[1024]; //接收前要清空 否则写入时会保留后面的数值
  93.                 //接收数据  
  94.                 int receiveNumber = myClientSocket.Receive(result); //3.将客户端得到的byte值写入
  95.  
  96.                 //没有接收信息总长度
  97.                 if (!isEndData)
  98.                 {
  99.                     //接收
  100.                     dataLength = int.Parse(Encoding.UTF8.GetString(result));
  101.                     subpackageData = new byte[0]; //初始化缓冲区
  102.                     Debug.Log("1.接收到信息的总长度： " + dataLength);
  103.                     isEndData = true;
  104.                 }
  105.                 else
  106.                 {
  107.                     //有数据 并且 接收到信息长度后执行
  108.                     if (receiveNumber > 0 && isEndData)
  109.                     {
  110.                         //1.整合数据
  111.                         byte[] newResult = new byte[(subpackageData.Length + receiveNumber)];
  112.                         Array.Copy(subpackageData, 0, newResult, 0, subpackageData.Length); //将上一次分包数据赋值给容器
  113.                         Array.Copy(result, 0, newResult, subpackageData.Length, receiveNumber); //将当前收到的数据赋值给容器
  114.  
  115.                         subpackageData = newResult;
  116.                         Debug.Log("整合后数据长度： " + subpackageData.Length);
  117.  
  118.  
  119.                         //整合的数据超出 或等于数据
  120.                         if (subpackageData.Length >= dataLength)
  121.                         {
  122.                             isEndData = false; //设置没有接收到信息总长度
  123.                             //数据解析
  124.                             string data = Encoding.UTF8.GetString(subpackageData);
  125.                             Debug.Log(data);
  126.                             DisposeData(data);
  127.  
  128.                             myClientSocket.Send(Encoding.UTF8.GetBytes("文件转换成功" + DateTime.Now));
  129.                         }
  130.                     }
  131.                     else
  132.                     {
  133.                         Debug.Log("client： " + ((IPEndPoint)myClientSocket.RemoteEndPoint).Address.ToString() + "断开连接");
  134.                         threadDic[((IPEndPoint)myClientSocket.RemoteEndPoint).Address.ToString()].Abort(); //清除线程
  135.                     }
  136.                 }
  137.  
  138.             }
  139.             catch (Exception ex)
  140.             {
  141.                 //myClientSocket.Shutdown(SocketShutdown.Both); //出现错误 关闭Socket
  142.                 Debug.Log(" 错误信息" + ex); //打印错误信息
  143.                 break;
  144.             }
  145.         }
  146.     }
  147.  
  148.     #region 数据处理
  149.     private void DisposeData(string data)
  150.     {
  151.         //UTF8Encoding m_utf8 = new UTF8Encoding(false); //这是不带有BOM的UTF-8 使用带有BOM的UTF-8转换Json容易失败
  152.         jsonData = JsonMapper.ToObject<JsonData>(data);
  153.  
  154.         string savePath = saveFilePath + jsonData.flieName;
  155.         Debug.Log(savePath);
  156.         //上传附件 判断是否存在
  157.         if (File.Exists(savePath))
  158.         {
  159.             //文件存在 重命名新文件
  160.             savePath = saveFilePath + "(Colon)"+jsonData.flieName;
  161.         }
  162.  
  163.         Bytes2File(jsonData.fileData, savePath); //将byte数据转换为文件
  164.     }
  165.     #endregion
  166.  
  167.     #region 将byte数组转换为文件并保存到指定地址
  168.     /// <summary>
  169.     /// 将byte数组转换为文件并保存到指定地址
  170.     /// </summary>
  171.     /// <param name="buff">byte数组</param>
  172.     /// <param name="savepath">保存地址</param>
  173.     public static void Bytes2File(byte[] buff, string savepath)
  174.     {
  175.         if (File.Exists(savepath))
  176.         {
  177.             File.Delete(savepath);
  178.         }
  179.  
  180.         FileStream fs = new FileStream(savepath, FileMode.CreateNew);
  181.         BinaryWriter bw = new BinaryWriter(fs);
  182.         bw.Write(buff, 0, buff.Length);
  183.         bw.Close();
  184.         fs.Close();
  185.     }
  186.     #endregion
  187.  
  188.     void OnApplicationQuit()
  189.     {
  190.         //结束线程必须关闭 否则下次开启会出现错误 （如果出现的话 只能重启unity了）
  191.         myThread.Abort();
  192.  
  193.         //关闭开启的线程
  194.         foreach (string item in threadDic.Keys)
  195.         {
  196.             Debug.Log(item);//de.Key对应于key/value键值对key
  197.             //item.Value.GetType()
  198.             threadDic[item].Abort();
  199.         }
  200.     }
  201.  
  202. }

三、客户端最终代码

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using System.Net;
  4. using System.Net.Sockets;
  5. using System.Text;
  6. using UnityEngine.UI;
  7. using UnityEngine;
  8. using System;
  9. using System.IO;
  10. using LitJson;
  11.  
  12. //Json数据
  13. [Serializable]
  14. public class JsonData
  15. {
  16.     public string operationType = string.Empty; //服务器事件类型（选择服务器要执行的方法）
  17.     public string clientIP = string.Empty;      //客户端本地ip
  18.     public string flieName = string.Empty;      //文件名称(文件名称)
  19.     public byte[] fileData = new byte[] { };    //文件byte[]数据
  20. }
  21.  
  22. public class SocketClient : MonoBehaviour
  23. {
  24.     private string myip;
  25.     private int myPort;   //端口  
  26.     JsonData jsonData;    //整合的json数据
  27.  
  28.     public Button sendBtn;//发送
  29.     public InputField path;//信息
  30.     Socket clientSocket;
  31.  
  32.     byte[] sendData; //要发送的数据
  33.     private static byte[] result = new byte[1024]; //接收服务器的数据
  34.  
  35.     string filePath;
  36.     void Start()
  37.     {
  38.         myip = ConfigFile.LoadString("Server");
  39.         myPort = int.Parse(ConfigFile.LoadString("port"));
  40.  
  41.         //按钮监听
  42.         sendBtn.onClick.AddListener(delegate {
  43.  
  44.             //判断 路径不为空 并且 文件存在
  45.             if (!path.text.Equals(string.Empty)&& File.Exists(path.text)) 
  46.             {
  47.                
  48.                 //判断 文件是否存在\反斜杠
  49.                 filePath = path.text.Contains("\\") ? path.text.Replace('\\', '/') : path.text;
  50.                 Debug.Log(filePath);
  51.                 try
  52.                 {
  53.                     //获取文件名称 类型
  54.                     FieldSplit(filePath, '/');
  55.                     jsonData = new JsonData()
  56.                     {
  57.                         operationType = "上传附件",
  58.                         clientIP = GetLocalIP.GetIP(GetLocalIP.ADDRESSFAM.IPv4),
  59.                         flieName = splitData[splitData.Length - 1],
  60.                         fileData = GetFileData(filePath) //将文件转换为byte[]
  61.                     };
  62.  
  63.                     Debug.Log(jsonData.flieName);
  64.  
  65.                     sendData = Encoding.UTF8.GetBytes(JsonMapper.ToJson(jsonData)); //将json数据转换为byte
  66.  
  67.                     //1.先发送 数据长度
  68.                     clientSocket.Send(Encoding.UTF8.GetBytes(sendData.Length.ToString()));
  69.                     Debug.Log("byte数量：" + sendData.Length.ToString());
  70.                     //2.发送内容
  71.                     clientSocket.Send(sendData);//传送信息
  72.                 }
  73.                 catch (Exception ex)
  74.                 {
  75.                     Debug.Log("发送失败：" + ex);
  76.                 }
  77.  
  78.             }
  79.  
  80.         });
  81.  
  82.         //监听连接的客户端连接
  83.         ListeningClient();
  84.  
  85.     }
  86.  
  87.     #region 获取文件名称 类型
  88.     string[] splitData; 
  89.     private void FieldSplit(string field,char _value)
  90.     {
  91.         splitData = field.Split(_value);
  92.     }
  93.  
  94.     #endregion
  95.  
  96.     void Update()
  97.     {
  98.         if (Input.GetKeyDown(KeyCode.Escape))
  99.         {
  100.             Application.Quit();
  101.         }
  102.     }
  103.  
  104.     #region 监听连接的客户端连接
  105.     private void ListeningClient() 
  106.     {
  107.         //要连接的服务器IP地址  
  108.         IPAddress ip = IPAddress.Parse(myip);//本地IP地址
  109.         clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
  110.         try
  111.         {
  112.             clientSocket.Connect(new IPEndPoint(ip, myPort)); //配置服务器IP与端口 ，并且尝试连接
  113.         }
  114.         catch (Exception ex)
  115.         {
  116.             Debug.Log("Connect lose" + ex); //打印连接失败
  117.             return;
  118.         }
  119.  
  120.         int receiveLength = clientSocket.Receive(result);//接收服务器回复消息，成功则说明已经接通
  121.         Debug.Log("服务器消息长度：" + receiveLength);
  122.  
  123.         if (receiveLength > 1)
  124.         {
  125.             Debug.Log("接收服务器消息：" + Encoding.UTF8.GetString(result));
  126.         }
  127.     }
  128.  
  129.     #endregion
  130.  
  131.  
  132.     #region 将文件转换成byte[] 数组
  133.  
  134.     /// <summary>
  135.     /// 将文件转换成byte[] 数组
  136.     /// </summary>
  137.     /// <param name="fileUrl">文件路径文件名称</param>
  138.     /// <returns>byte[]</returns>
  139.     protected byte[] GetFileData(string fileUrl)
  140.     {
  141.         FileStream fs = new FileStream(fileUrl, FileMode.Open, FileAccess.Read);
  142.         lock (fs)
  143.         {
  144.             try
  145.             {
  146.                 byte[] buffur = new byte[fs.Length];
  147.                 fs.Read(buffur, 0, (int)fs.Length);
  148.  
  149.                 return buffur;
  150.             }
  151.             catch (Exception ex)
  152.             {
  153.                 return null;
  154.             }
  155.             finally
  156.             {
  157.                 if (fs != null)
  158.                 {
  159.                     //关闭资源
  160.                     fs.Close();
  161.                 }
  162.             }
  163.         }
  164.     }
  165.     #endregion
  166. }

四、其他脚本：

1.获取本地ip

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using System.Net.NetworkInformation;
  4. using System.Net.Sockets;
  5. using UnityEngine;
  6.  
  7. public class GetLocalIP 
  8. {
  9.     #region 获取本地IP地址
  10.     public enum ADDRESSFAM
  11.     {
  12.         IPv4, IPv6
  13.     }
  14.  
  15.     /// <summary>
  16.     /// 获取本机IP
  17.     /// </summary>
  18.     /// <param name="Addfam">要获取的IP类型</param>
  19.     /// <returns></returns>
  20.     public static string GetIP(ADDRESSFAM Addfam)
  21.     {
  22.         if (Addfam == ADDRESSFAM.IPv6 && !Socket.OSSupportsIPv6)
  23.         {
  24.             return null;
  25.         }
  26.  
  27.         string output = "";
  28.  
  29.         foreach (NetworkInterface item in NetworkInterface.GetAllNetworkInterfaces())
  30.         {
  31. #if UNITY_EDITOR_WIN || UNITY_STANDALONE_WIN
  32.             NetworkInterfaceType _type1 = NetworkInterfaceType.Wireless80211;
  33.             NetworkInterfaceType _type2 = NetworkInterfaceType.Ethernet;
  34.  
  35.             if ((item.NetworkInterfaceType == _type1 || item.NetworkInterfaceType == _type2) && item.OperationalStatus == OperationalStatus.Up)
  36. #endif 
  37.             {
  38.                 foreach (UnicastIPAddressInformation ip in item.GetIPProperties().UnicastAddresses)
  39.                 {
  40.                     //IPv4
  41.                     if (Addfam == ADDRESSFAM.IPv4)
  42.                     {
  43.                         if (ip.Address.AddressFamily == AddressFamily.InterNetwork)
  44.                         {
  45.                             output = ip.Address.ToString();
  46.                         }
  47.                     }
  48.  
  49.                     //IPv6
  50.                     else if (Addfam == ADDRESSFAM.IPv6)
  51.                     {
  52.                         if (ip.Address.AddressFamily == AddressFamily.InterNetworkV6)
  53.                         {
  54.                             output = ip.Address.ToString();
  55.                         }
  56.                     }
  57.                 }
  58.             }
  59.         }
  60.         return output;
  61.     }
  62.  
  63.     #endregion
  64. }

2.获取xml

  1. using System.Xml.Linq;
  2. using System.Collections;
  3. using System.Collections.Generic;
  4. using UnityEngine;
  5. using System;
  6.  
  7. public class ConfigFile
  8. {
  9.     static string path = Application.dataPath + "/StreamingAssets/ConfigFile.xml";
  10.  
  11.     public static string LoadString(string str)
  12.     {
  13.         XDocument document = XDocument.Load(path);
  14.         //获取到XML的根元素进行操作
  15.         XElement root = document.Root;
  16.         XElement ele = root.Element(str);
  17.         return ele.Value;
  18.     }
  19. }

3.ConfigFile.xml 配置文件 放到StreamingAssets文件夹下

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <Info>
  3.  
  4.   <!--服务器ip配置-->
  5.   <Server>127.0.0.1</Server>
  6.   <port>9999</port>
  7. </Info>

4.json插件

链接：https://pan.baidu.com/s/14SgSgrK14zdGURfXVjeyjg 
提取码：syq1

最终效果：

客户端：

 服务器：

 上传成功  我们看一下内容是否有问题

客户端发送的文件：

 服务器接收的文件：

内容没问题 成功。。。 

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

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

  

闽ICP备14008679号