Unity局域网传输图片等文件

最新推荐文章于 2024-05-13 20:43:36 发布
最新推荐文章于 2024-05-13 20:43:36 发布
阅读量2.6k 收藏 19
点赞数 3
文章标签： unity3d 网络通信 局域网
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32688843/article/details/114840593
版权

使用Unity实现局域网下传输各种文件，这里我传输图片为例，放上关键代码：

客户端代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using UnityEngine;
using System.IO;
using UnityEngine.SocialPlatforms;
//using LitJson;

namespace SocketServer
{
    class Client
    {
        private const int BufferSize = 1024;
        private static byte[] result = new byte[1024];
        static IPAddress ip = IPAddress.Parse("192.168.1.10");//192.168.1.10
        static Socket clientSocket = null;
        static IPEndPoint endPoint = new IPEndPoint(ip, 8885);

        public static void StartSendFile(string path)
        {
            Thread myThread = new Thread(new ParameterizedThreadStart(SendFile));
            myThread.Start(path);
        }

        static void SendFile(object absPath)
        {
            string path = (string)absPath;
            if(clientSocket == null || !clientSocket.Connected)
            {
                clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                try
                {
                    clientSocket.Connect(endPoint); //配置服务器IP与端口
                    ClientManager.Instance.AddMessage("连接服务器成功");
                    Debug.Log("连接服务器成功");
                }
                catch
                {
                    ClientManager.Instance.AddMessage("连接服务器失败");
                    Debug.Log("连接服务器失败");
                    return;
                }
            }

            try
            {
                FileStream reader = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.None);
                long send = 0L, length = reader.Length;
                string fileName = Path.GetFileName(path);
                string sendStr = "Sending File," + fileName + "," + length.ToString();
                Debug.Log(sendStr);
                //ClientManager.Instance.AddMessage(sendStr);
                clientSocket.Send(EncoderToByte(sendStr));

                int BufferSize = 1024;
                byte[] buffer = new byte[1024];
                clientSocket.Receive(buffer);
                string message = DecoderToString(buffer);

                if (message.Contains("Ready for sending"))
                {
                    Debug.Log("Sending File:" + fileName + ".Plz wait...");
                    ClientManager.Instance.AddMessage("Sending File:" + fileName + ".Plz wait...");
                    byte[] fileBuffer = new byte[BufferSize];
                    int read, sent;
                    while ((read = reader.Read(fileBuffer, 0, BufferSize)) != 0)
                    {
                        sent = 0;
                        while ((sent += clientSocket.Send(fileBuffer, sent, read, SocketFlags.None)) < read)
                        {
                            send += (long)sent;
                        }
                    }
                    Debug.Log(fileName + " Send Finish");
                    ClientManager.Instance.AddMessage(fileName + " Send Finish");
                }
                else
                {
                    Debug.Log(message);
                }

                reader.Flush();
                reader.Close();
            }
            catch (Exception ex)
            {
                Debug.Log(ex.Message);
            }
            return;
        }

        public static List<ClientManager.FileInfomation> GetFileList()
        {
            if (clientSocket == null || !clientSocket.Connected)
            {
                clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                try
                {
                    clientSocket.Connect(endPoint); //配置服务器IP与端口
                    ClientManager.Instance.AddMessage("连接服务器成功");
                    Debug.Log("连接服务器成功");
                }
                catch
                {
                    ClientManager.Instance.AddMessage("连接服务器失败");
                    Debug.Log("连接服务器失败");
                    return null;
                }
            }
            clientSocket.Send(EncoderToByte("GetFileList"));
            Debug.Log("Send Get List Request");
            ClientManager.Instance.AddMessage("Send Get List Request");
            byte[] buffer = new byte[1024];

            clientSocket.Receive(buffer);
            string message1 = DecoderToString(buffer);

            Debug.Log(message1);

            if(message1.Contains("FileListNull"))
            {
                Debug.Log("FileListNull");
                ClientManager.Instance.AddMessage("File list is null");
                return null;
            }
            else if(message1.Contains("Sending List"))
            {
                byte[] buffer2 = new byte[1024];
                clientSocket.Receive(buffer2);
                string message2 = DecoderToString(buffer2);
                Debug.Log(message2);
                //Debug.Log(message);
                return StringToList(message2);
            }
            else
            {
                return null;
            }
        }

        public static void StartReceiveFile(ThreadHelper helper)
        {
            Thread myThread = new Thread(new ParameterizedThreadStart(ReceiveFile));
            myThread.Start(helper);
        }

        static void ReceiveFile(object helper)
        {
            ThreadHelper myHelper = (ThreadHelper)helper;
            string savePath = myHelper.savePath;
            string requestName = myHelper.requestName;

            if(File.Exists(Path.Combine(savePath, requestName)))
            {
                Debug.Log("There already has a same file");
                ClientManager.Instance.AddMessage("There already has a same file");
                return;
            }

            if (clientSocket == null || !clientSocket.Connected)
            {
                clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                try
                {
                    clientSocket.Connect(endPoint); //配置服务器IP与端口
                    Debug.Log("连接服务器成功");
                    ClientManager.Instance.AddMessage("连接服务器成功");
                }
                catch
                {
                    Debug.Log("连接服务器失败");
                    ClientManager.Instance.AddMessage("连接服务器失败");
                }
            }

            string request = "Download File" + "," + requestName + "," + requestName.Length;
            Debug.Log(request);
            clientSocket.Send(EncoderToByte(request));

            byte[] buffer = new byte[1024];
            clientSocket.Receive(buffer);
            string message = DecoderToString(buffer);


            string[] command = message.Split(',');
            string fileName = command[1];
            long length;
            fileName = command[1];
            length = Convert.ToInt64(command[2]);

            clientSocket.Send(EncoderToByte("Ready for sending"));
            long receive = 0L;
            Debug.Log("Receiveing file:" + fileName + ".Plz wait...");
            ClientManager.Instance.AddMessage("Receiveing file:" + fileName + ".Plz wait...");
            FileStream writer = new FileStream(Path.Combine(savePath, fileName), FileMode.Create, FileAccess.Write, FileShare.None);
            int received;
            while (receive < length)
            {
                received = clientSocket.Receive(result);
                writer.Write(result, 0, received);
                writer.Flush();
                receive += (long)received;
            }
            writer.Flush();
            writer.Close();
            ClientManager.Instance.AddMessage(fileName + " Receive Finish");
            Debug.Log(fileName + " Receive Finish");
        }

        static void CloseSocket(Socket socket)
        {
            socket.Disconnect(true);
            //socket.Shutdown(SocketShutdown.Both);
            //socket.Close();
            Debug.Log("Close Socket " + socket.RemoteEndPoint.ToString());
        }

        static string DecoderToString(byte[] bytes)
        {
            char[] chs = new char[1024];
            Decoder decoder = Encoding.UTF8.GetDecoder();
            decoder.GetChars(bytes, 0, bytes.Length, chs, 0);
            return new string(chs);
        }

        static byte[] EncoderToByte(string sendStr)
        {
            Encoder encoder = Encoding.UTF8.GetEncoder();
            char[] sendChar = sendStr.ToCharArray();
            byte[] bytes = new byte[encoder.GetByteCount(sendChar, 0, sendChar.Length, true)];
            encoder.GetBytes(sendChar, 0, sendChar.Length, bytes, 0, true);
            return bytes;
        }

        static List<ClientManager.FileInfomation> StringToList(string str)
        {
            string[] keys = str.Split(',');
            List<ClientManager.FileInfomation> list = new List<ClientManager.FileInfomation>();
            int i = 0;
            while (i < keys.Length - 1)
            {
                list.Add(new ClientManager.FileInfomation(keys[i], keys[i + 1]));
                i += 2;
            }

            return list;
        }
    }

    public struct ThreadHelper
    {
        public string savePath;
        public string requestName;

        public ThreadHelper(string path, string name)
        {
            savePath = path;
            requestName = name;
        }
    }
}

服务端代码：

```csharp
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Net;
using System.Threading;
using UnityEngine;
using System.IO;
//using LitJson;
using UnityEngine.UI;

namespace SocketServer
{
    class Server
    {
        private static byte[] result = new byte[1024];
        private static int myProt = 8885;   //端口
        static Socket serverSocket;
        private const int BufferSize = 1024;

        //public const string savePath = @"C:\Users\Administrator\Desktop\学习\面向对象\Socket\Save";
        public static Thread StartServer()
        {
            //服务器IP地址
            IPAddress ip = IPAddress.Parse("192.168.1.10");//192.168.1.10
            serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            serverSocket.Bind(new IPEndPoint(ip, myProt));  //绑定IP地址：端口
            serverSocket.Listen(10);    //设定最多10个排队连接请求
            Debug.Log("启动监听成功" + serverSocket.LocalEndPoint.ToString());
            ServerManager.Instance.AddMessage("启动监听成功" + serverSocket.LocalEndPoint.ToString());
            //通过Clientsoket发送数据
            Thread myThread = new Thread(ListenClientConnect);
            myThread.Start();
            return myThread;
        }

        /// <summary>
        /// 监听客户端连接
        /// </summary>
        private static void ListenClientConnect()
        {
            //Socket clientSocket = serverSocket.Accept();
            //ReceiveMessage(clientSocket);
            while (true)
            {
                Socket clientSocket = serverSocket.Accept();
                if (clientSocket.Connected)
                {
                    Thread receiveThread = new Thread(ReceiveMessage);
                    receiveThread.Start(clientSocket);
                }
            }

        }

        /// <summary>
        /// 接收消息
        /// </summary>
        /// <param name="clientSocket"></param>
        static void ReceiveMessage(object clientSocket)
        {
            Socket myClientSocket = (Socket)clientSocket;
            string clientName = myClientSocket.RemoteEndPoint.ToString();

            while (true)
            {
                try
                {
                    //通过clientSocket接收数据
                    byte[] buffer = new byte[1024];
                    myClientSocket.Receive(buffer);
                    string message = DecoderToString(buffer);
                    Debug.Log("接收消息：" + message);
                    if (message.Contains("Sending File"))
                    {
                        ReceiveFile(message, myClientSocket);
                    }
                    else if(message.Contains("GetFileList"))
                    {
                        SendFileList(myClientSocket);
                    }
                    else if(message.Contains("Download File"))
                    {
                        SendFile(message, myClientSocket);
                    }
                    //else 
                    //{
                    //    Debug.Log("接收客户端消息" + myClientSocket.RemoteEndPoint.ToString() + message);
                    //}
                }
                catch (Exception ex)
                {
                    Debug.Log(clientName + "disconnect (" + ex.Message  + ")");
                    //if(myClientSocket.Connected)
                    //{
                    //    myClientSocket.Shutdown(SocketShutdown.Both);
                    //    myClientSocket.Close();
                    //}
                    return;
                }
            }
        }

        static void SendFileList(Socket myClientSocket)
        {
            if(ServerManager.Instance.FileList.Count == 0)
            {
                myClientSocket.Send(EncoderToByte("FileListNull"));
            }
            else
            {
                myClientSocket.Send(EncoderToByte("Sending List"));
            }

            string fileListStr = ListToString(ServerManager.Instance.FileList);
            Debug.Log(fileListStr);
            myClientSocket.Send(EncoderToByte(fileListStr));
            ServerManager.Instance.AddMessage("Send File List Finish");
            Debug.Log("Send File List Finish");
        }

        static void ReceiveFile(string message, Socket myClientSocket)
        {
            Debug.Log("接收文件");
            string[] command = message.Split(',');
            string fileName = command[1];
            long length;
            fileName = command[1];
            length = Convert.ToInt64(command[2]);

            //if (File.Exists(Path.Combine(ServerManager.Instance.savePath, fileName)))
            //{
            //    myClientSocket.Send(EncoderToByte("There has already a file named " + fileName));
            //    Debug.Log("There has already a file named " + fileName + ", stop receiving");
            //    ServerManager.Instance.AddMessage("There has already a file named " + fileName + ", stop receiving");
            //    //CloseSocket(myClientSocket);
            //    return;
            //}

            myClientSocket.Send(EncoderToByte("Ready for sending"));
            long receive = 0L;
            Debug.Log("Receiveing file:" + fileName + ".Plz wait...");
            ServerManager.Instance.AddMessage("Receiveing file:" + fileName + ".Plz wait...");
            FileStream writer = new FileStream(Path.Combine(ServerManager.Instance.savePath, fileName), FileMode.Create, FileAccess.Write, FileShare.None);
            int received;
            while (receive < length)
            {
                received = myClientSocket.Receive(result);
                writer.Write(result, 0, received);
                writer.Flush();
                receive += (long)received;
            }

            writer.Flush();
            writer.Close();

            ServerManager.Instance.FileList.Add(new ServerManager.FileInfomation(fileName, (length / 1024).ToString()));
            Debug.Log(fileName + " Receive Finish");

           // LoadImage.instance.LoadTexture(Path.Combine(ServerManager.Instance.savePath, fileName));
            ServerManager.Instance.AddMessage(fileName + " Receive Finish");

            Main.instance.message = "上传";
        }

        static void SendFile(string request, Socket clientSocket)
        {
            string[] command = request.Split(',');

            string requestName = command[1].Substring(0, int.Parse(command[2]));

            string path = Path.Combine(ServerManager.Instance.savePath, command[1].Substring(0, int.Parse(command[2])));

            FileStream reader = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.None);


            long send = 0L, length = reader.Length;
            string fileName = requestName;
            string sendStr = "Sending File," + fileName + "," + length.ToString();
            Debug.Log(sendStr);
            ServerManager.Instance.AddMessage(sendStr);
            clientSocket.Send(EncoderToByte(sendStr));

            int BufferSize = 1024;
            byte[] buffer = new byte[1024];
            clientSocket.Receive(buffer);
            string message = DecoderToString(buffer);
            Debug.Log(message);

            if (message.Contains("Ready for sending"))
            {
                ServerManager.Instance.AddMessage("Sending File:" + fileName + ".Plz wait...");
                Debug.Log("Sending File:" + fileName + ".Plz wait...");
                byte[] fileBuffer = new byte[BufferSize];
                int read, sent;
                while ((read = reader.Read(fileBuffer, 0, BufferSize)) != 0)
                {
                    sent = 0;
                    while ((sent += clientSocket.Send(fileBuffer, sent, read, SocketFlags.None)) < read)
                    {
                        send += (long)sent;
                    }
                }
                Debug.Log(fileName + " Send Finish");
                ServerManager.Instance.AddMessage(fileName + " Send Finish");
            }
            else
            {
                Debug.Log(message);
            }

            reader.Flush();
            reader.Close();
            return;
        }


        static void CloseSocket(Socket socket)
        {
            socket.Shutdown(SocketShutdown.Both);
            socket.Close();
            Debug.Log("Close Socket " + socket.RemoteEndPoint.ToString());
        }

        static string DecoderToString(byte[] bytes)
        {
            char[] chs = new char[1024];
            Decoder decoder = Encoding.UTF8.GetDecoder();
            decoder.GetChars(bytes, 0, bytes.Length, chs, 0);
            return new string(chs);
        }

        static byte[] EncoderToByte(string sendStr)
        {
            Encoder encoder = Encoding.UTF8.GetEncoder();
            char[] sendChar = sendStr.ToCharArray();
            byte[] bytes = new byte[encoder.GetByteCount(sendChar, 0, sendChar.Length, true)];
            encoder.GetBytes(sendChar, 0, sendChar.Length, bytes, 0, true);
            return bytes;
        }

        static string ListToString(List<ServerManager.FileInfomation> list)
        {
            string str = "";
            foreach (var fileInfo in list)
            {
                str += fileInfo.fileName;
                str += ",";
                str += fileInfo.fileSize;
                str += ",";
            }

            return str;
        }
    }
}

欢迎讨论Q 1390659165
小姑娘不爱写代码
关注
  • 3
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
unity 上传文件到服务器,Unity3D与Web服务器交互之图片数据的传输 - Unity3d技术 - 泰课在线 - 国内专业的Unity在线学习平台|Unity3d培训|Unity教程|Uni...
weixin_39548438的博客
07-31 1082
本篇文章讲解Unity3d与Apache服务器交互时图片数据的传输，服务端语言使用php，关于apache和php的配置请参考Unity3D与Web服务器交互之Apache，PHP和Mysql配置，此处图片传输使用的是Post请求方式，关于post请求和get请求请参考：Unity3D与Web服务器交互之Get请求和Post请求示例，图片的传输需要把图片数据转换成byte[](字节数组)后进行传输...
unity局域网socket传输图片tcp
weixin_39341958的博客
11-27 1899
https://www.bilibili.com/video/bv1iD4y1X7e8 首先打开服务器，然后打开客户端，修改StreamingAssets的ip地址，然后打开客户端，在服务器里面输入图片的本地路径，输入完成后，点下enter键就能通过服务器传送大客户端里面了 using System.Collections; using System.Collections.Generic; using System.IO; using UnityEngine; using UnityEngine.UI;
UNITY-网络通信（TCP/UDP)
最新发布
m0_65357206的博客
05-13 1349
学习笔记 以后复习使用
Unity实现安卓局域网内文件发送和接收
09-27
Unity实现安卓局域网内文件发送和接收，使用Unity2018.1.9，完整工程打包可直接使用
Unity的画面高质量传输（ FMETP STREAM 实时画面传输案例）
Chj1319261607的博客
11-25 3091
Unity的画面高质量传输（ FMETP STREAM 实时画面传输案例）
Unity使用Socket发送安卓端摄像机的内容
赵某人
10-21 802
使用Socket发送安卓端摄像机的内容其实也就是相当于发送一张图片，不同的是，这里是调用安卓的摄像机然后在进行实时发送。 发送流程是：点对点的发送， 发送方： 捕获摄像机的数据 将数据显示在纹理上 将数据编程字节流 将字节流发送出去 接收方 接收字节流 切换到主线程 将字节流转换为图片 把图片显示出来 首先创建两个RawImage，用来当做显示面板，一个用来做发送端一个用来做接收端。 这...
unity socket传输图片_视频结构化海量小图片存储架构
weixin_39551462的博客
12-06 167
问题描述在视频结构化和人脸识别项目中前端视频流源源不断地进入深度学习模型，目标检测后得到的图片需要存储在硬盘中用于检索回溯。经小编统计，在W市100路人脸识别视频流一天的图片抓拍量大约为15万，如果将如此多的图片直接存在硬盘或某些存储盘阵中，存储机的索引节点将随着时间推移逐渐占满，检索的速度越来越慢，另外图片的删除也成为一个头疼的问题。经项目实践，1000路视频流截取的图片在一月内足以让我司1PB...
Unity局域网传输文件功能源码.rar
03-16
"Unity局域网传输文件功能源码.rar"是一个包含服务端和客户端代码的压缩包，它提供了在局域网环境中交换文件的能力。 首先，我们需要理解局域网通信的基本原理。局域网是一种让多台设备在有限地理范围内的网络连接...
Unity画面传输技术，局域网，公网，网页
06-14
在本文中，我们将深入探讨Unity中的画面传输技术，这是一项允许用户在局域网、公网和网页环境中实时分享和传输游戏画面的关键功能。 1. **Unity画面传输基础** - **画面捕获**：Unity引擎提供了内置的渲染管线，...
Unity同局域网下socket,udp坐标传输，包含客户端和服务端
04-09
Unity同局域网下坐标传输，包含客户端和服务端，分为客户端和服务端两个工程，服务端采集坐标信息，传输到客户端。
Untiy Udp局域网通信整理
03-16
以上就是Unity UDP局域网通信的基本知识和应用，实际开发中还需要结合具体项目需求进行优化和扩展，例如增加心跳机制、处理丢包重传、多线程优化等。提供的资源包含了服务端和客户端示例，可以作为学习和参考的基础...
unity通过http上传图片到服务器
03-15
unity通过http上传图片到服务器，上传截屏图片到tomcat服务器
Unity3D上传图片以及解析二进制流
11-20
Unity3d点击打开Windos资源文件夹选择要上传的图片并显示在Ngui上，保存图片到指定的文件夹下。
unity——通过网络传图片
Wmayy_123的博客
12-17 387
我尝试用网络传图片去其他客户端，但是出现了客户端的图片不显示和出现？？ public Texture2D MyTexture; public byte[] receivedBytes; public byte[] N; public Texture2D texi; void Start () { texi = new Texture2D...
Unity3D UDP传输大文件怎么提高速度详解
2301_80135027的博客
12-25 343
在Unity3D中，我们可以使用Unity的Network类来实现UDP传输。在发送端，我们可以使用Network类的Send方法将小包发送给接收端。本文介绍了如何通过使用UDP协议来提高大文件传输的速度，并给出了相应的技术详解和代码实现。通过分包和组包、UDP传输和文件完整性校验等技术手段，可以在Unity3D中实现高效的大文件传输。本文将详细介绍如何通过使用UDP协议来提高大文件传输的速度，并给出相应的技术详解和代码实现。在接收端，我们可以使用MD5等校验算法对接收到的文件进行校验，确保文件的完整性。
Unity实现将图片上传到服务器功能
波波斯维奇
03-02 7370
Unity实现将图片上传到服务器功能 前言
C# 实现超大文件传输、断点续传等功能
热门推荐
若汝棋茗 的博客
09-04 1万+
经常有小伙伴在开发控制台、winform、WPF等C/S软件时，会有文件传输的需求。正好RRQMSocket.RPC完美支持这个，所以给大家介绍一波。文档首页Nuget安装即可，具体步骤详看链接博客。VS、Unity安装和使用Nuget包RRQM文件传输使用的是特殊传输协议，与FTP，HTTP等协议完全不兼容，所以如果使用文件传输，则服务器与客户端必须均使用RRQM组件。因为RRQM使用的是特殊协议，所以性能、功能上要远强于FTP，且搭建简单，支持多通道传输等。演示： 可以看到，下图正在上传一个Window
Unity3D TCP图片传输
qq_31668269的博客
08-22 3375
参考 https://blog.csdn.net/qq_34818497/article/details/79464675 发送端代码如下： using UnityEngine; using System.Collections; using System.Net; using System.Net.Sockets; using System.IO; using System; pub...
【Unity3D日常开发】Unity3D中实现向Web服务器上传图片以及下载图片功能
CSDN博客专家，Unity3D高级软件工程师，《Unity 3D从入门到实战》作者。
01-07 7882
推荐阅读 CSDN主页 GitHub开源地址 Unity3D插件分享 简书地址 我的个人博客 QQ群：1040082875 大家好，我是佛系工程师☆恬静的小魔龙☆，不定时更新Unity开发技巧，觉得有用记得一键三连哦。 一、前言 今天分享一下从搭建web服务器，到向服务器发送图片，以及加载图片的整体实现。 因为是Demo演示，所以尽可能的简单、详细且实用，有什么错误敬请指正。 先看一下效果图： 文章参考：Unity向Web服务器上传和下载图片 二、搭建PHP服务器 搭建PHP服务器还是很简单的，只.
unity 局域网传输文件
08-03
总结起来，Unity 的局域网传输文件需要借助网络编程的知识和方法，在服务器和客户端之间建立连接，定义传输协议和消息格式，并实现文件的拆分、发送和接收等操作。这样，就可以实现局域网内的文件传输功能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小姑娘不爱写代码

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

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

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

打赏作者

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

抵扣说明：

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

余额充值