Android P解决Socket通信Tcp粘包问题

EasySocket一款轻量级的Android端Socket框架 源码地址:https://github.com/jiusetian/EasySocket EasySocket的初衷是希望使Socket编程变得更加简单、快捷,因此项目在实现了Socket基本功能的基础上,还实现了TCP层面的请求回调功能。传统的Socket框架客户端发出一个请求信息,然后服务器返回一个应答信息,但是我们无法识别这个应答信息是对应哪个请求的,而EasySocket实现了将每个请求... 阅读详情

TCP协议是一个面向流的协议,所以他会出现粘包的问题。

TCP和UDP的调查请参考:
《Android中关于TCP socket通信数据大小,内存缓冲区和数据可靠性的一点调查》

一、TCP服务端和客户端代码实现

客户端代码实现
连接服务器的代码:

protected void connectServerWithTCPSocket() {
   boolean bRun = true;
   try {
       // 创建一个Socket对象,并指定服务端的IP及端口号
       // 本地回路ip:127.0.0.0
       mSocket = new Socket("127.0.0.1", 9897);
   } catch (UnknownHostException e) {
       e.printStackTrace();
   } catch (IOException e) {
       e.printStackTrace();
   }
}

服务端代码实现
在服务端实现对数据的接收:

public void createTcpServerSocket() {
  // 声明一个ServerSocket对象
  ServerSocket serverSocket = null;
  boolean bRun = true;

  try {
      // 创建一个ServerSocket对象,并让这个Socket在8919端口监听
      Log.i(TAG,"new ServerSocket");
      serverSocket = new ServerSocket(9897);
      Log.i(TAG,"new ServerSocket,serverSocket=" + serverSocket);

      // 调用ServerSocket的accept()方法,接受客户端所发送的请求,
      // 如果客户端没有发送数据,那么该线程就停滞不继续
      Socket socket = serverSocket.accept();
      Log.i("sunxiaolin ServerSocket","serverSocket receive data");

      //文本传输
      // 从Socket当中得到InputStream对象
      InputStream inputStream = socket.getInputStream();
      byte buffer[] = new byte[1024];
      int temp = 0;
      int length = 0;
      // 从InputStream当中读取客户端所发送的数据,阻塞状态
      // 从缓冲区读出客户端发送的数据
      while ((temp = inputStream.read(buffer)) != -1) {
          //System.out.println(new String(buffer, 0, temp));
          length += temp;
          Log.i("tcp socket server","recevie buffer=" + printHexBinary(buffer));
      }
  } catch (IOException e) {
      e.printStackTrace();
  }
}

二、TCP粘包问题重现

粘包只有在快速发送多个包的时候才会出现。

循环发送20次数据:

for(int i=0; i<20; i++){
    String title;
    if(i%2 == 0){
        title = "aaa";
    }else{
        title = "bbb";
    }
    //发送字符串的数据
    sendMusicData(0x01,title.getBytes());
}

发送数据的代码:

public static void sendMusicData(int frameId,byte[] data) {
    if( mSocket != null){
		//size为长度
        int size = size = data.length;
        byte buffer[] = new byte[8 + size];
        buffer[0] = (byte)0xA6;
        buffer[1] = 0x6A;
        buffer[2] = 0x03;
        buffer[3] = (byte)((size & 0xff000000) >> 24);
        buffer[4] = (byte)((size & 0x00ff0000) >> 16);
        buffer[5] = (byte)((size & 0x0000ff00) >> 8);
        buffer[6] = (byte)((size & 0x000000ff));
        buffer[7] = (byte)frameId;

        System.arraycopy(data, 0, buffer, 8, size);
        Log.i("tcp socket client","send buffer=" + printHexBinary(buffer));

        try {
        	//发送一段buffer,对buffer包进行了特定协议的封包
            DataOutputStream outputStream = new DataOutputStream(mSocket.getOutputStream());
            outputStream.write(buffer);
            outputStream.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }else{

    }
}

//打印字符数组的代码
private static final char[] hexCode = "0123456789ABCDEF".toCharArray();
public static String printHexBinary(byte[] data) {
    StringBuilder r = new StringBuilder(data.length * 2);
    for (byte b : data) {
        r.append(hexCode[(b >> 4) & 0xF]);
        r.append(hexCode[(b & 0xF)]);
    }
    return r.toString();
}

运行程序,根据打印发现,出现了粘包的问题,即把两个包读到了一个buffer中:

socket client: send buffer=A66A030000000A01476F696E6720486F6D65
socket client: send buffer=A66A0300000008014E657720536F756C
socket client: send buffer=A66A030000000A01476F696E6720486F6D65
socket client: send buffer=A66A0300000008014E657720536F756C
socket client: send buffer=A66A030000000A01476F696E6720486F6D65
socket client: send buffer=A66A0300000008014E657720536F756C
socket client: send buffer=A66A030000000A01476F696E6720486F6D65
socket client: send buffer=A66A0300000008014E657720536F756C
socket client: send buffer=A66A030000000A01476F696E6720486F6D65
socket client: send buffer=A66A0300000008014E657720536F756C
socket client: send buffer=A66A030000000A01476F696E6720486F6D65
socket server: recevie buffer=A66A0300000008014E657720536F756CA66A030000000A01476F696E6720486F6D65A66A0300000008014E657720536F756CA66A030000000A01476F696E6720486F6D65
socket client: send buffer=A66A0300000008014E657720536F756C
socket client: send buffer=A66A030000000A01476F696E6720486F6D65
socket server: recevie buffer=A66A0300000008014E657720536F756CA66A030000000A01476F696E6720486F6D65A66A0300000008014E657720536F756CA66A030000000A01476F696E6720486F6D65
socket client: send buffer=A66A0300000008014E657720536F756C
socket client: send buffer=A66A030000000A01476F696E6720486F6D65
socket client: send buffer=A66A0300000008014E657720536F756C
socket server: recevie buffer=A66A030000000A01476F696E6720486F6D65A66A0300000008014E657720536F756CA66A030000000A01476F696E6720486F6D65A66A0300000008014E657720536F756CA66A030000000A01476F696E6720486F6D65A66A0300000008014E657720536F756CA66A030000000A01476F696E6720486F6D65
socket client: send buffer=A66A030000000A01476F696E6720486F6D65

三、TCP粘包问题原因分析

理想状态:服务端先接受一个package1,在接受一个package2,…,一次一个包一个包的接收,则这样无问题。

粘包的三种情况:
1、先读取到package1的部分数据,然后读取package1的余下数据和package2的全部数据;
2、先读取到package1的全部数据和package2的部分数据,然后读到package2的余下数据;
3、同时一次读取到package1和package2的全部数据。

很明显,我们这个Demo中,一次读取到了两包或者多包数据,属于这里面的第三种情况。

粘包原因:
1、客户端write()时发送的数据大于socket缓冲区的数据,导致需要多次write()才能把数据写入到缓冲去,这样导致read()数据的时候,一次read()的数据不完整。需要read()多次才能将数据读完;
2、发送端write()数据的速度太快,而接收端read()数据的太慢,导致接收方来不及接收每一包数据,造成了一次读取到多包数据的情况。我们这里也是属于这种情况。

四、TCP粘包问题解决方法

1、增加一个自己定义的传输协议,即增加一个包头,将帧头信息,长度信息包含在里面。包头长度固定,接收端根据包头中的长度去解析一个完整的包数据。

在我们的demo中,定好的协议为:

     byte buffer[] = new byte[8 + size];
     buffer[0] = (byte)0xA6;
     buffer[1] = 0x6A;
     buffer[2] = 0x03;
     buffer[3] = (byte)((size & 0xff000000) >> 24);
     buffer[4] = (byte)((size & 0x00ff0000) >> 16);
     buffer[5] = (byte)((size & 0x0000ff00) >> 8);
     buffer[6] = (byte)((size & 0x000000ff));
     buffer[7] = (byte)frameId;
     System.arraycopy(data, 0, buffer, 8, size);

我们的帧头固定为8个字节。其中buffer[3]-buffer[6]为数据的长度,所以根据这个调整一下接收端数据解析思路。接收端在服务端,修改服务端解析数据代码如下:

            //文本传输
            // 从Socket当中得到InputStream对象
            InputStream inputStream = socket.getInputStream();
            byte buffer[] = new byte[1024];
            int frameSize = 0;
            byte[] mRecvBuffer = {0};
            int mActualReadSize = 0;
            int readSize = 0;
            // 从InputStream当中读取客户端所发送的数据,阻塞状态
            while ((readSize = inputStream.read(buffer)) != -1) {
                Log.i("TcpSocketServer","read totalSize=" + readSize );
                Log.i("TcpSocketServer","read buffer=" + printHexBinary(buffer) );
                mActualReadSize = 0;

                if( readSize > 8 ){
                    frameSize = ( (buffer[3] & 0xff) << 24 | (buffer[4] & 0xff) << 16 | (buffer[5] & 0xff) << 8 | (buffer[6] & 0xff) );
                }

                while( readSize >= frameSize + 8 ){
                    mRecvBuffer = new byte[frameSize + 8];
                    System.arraycopy(buffer, mActualReadSize, mRecvBuffer, 0, frameSize + 8);
                    mActualReadSize += frameSize + 8;
                    Log.i("TcpSocketServer","read mRecvBuffer=" + printHexBinary(mRecvBuffer) );

                    int surplusLength = readSize - (frameSize + 8);
                    readSize -=  (frameSize + 8);
                    if( surplusLength >= 8 ){
                        int head = ((buffer[mActualReadSize] & 0xff) << 8) | buffer[mActualReadSize + 1];
                        if( head == 0xA66A ){
                            frameSize = 0;
                            frameSize = ( (buffer[mActualReadSize + 3] & 0xff) << 24 | (buffer[ mActualReadSize + 4] & 0xff) << 16 | (buffer[ mActualReadSize + 5] & 0xff) << 8 | (buffer[ mActualReadSize + 6] & 0xff) );
                        }else{
                            break;
                        }
                    }
                }
            }

打印如下:
在这里插入图片描述

可以看到mRecvBuffer可以读出了单个的包。

当然这里只解决了粘包的第三种情况,这种情况byte buffer[] = new byte[1024];,读出的缓冲区尽量要大些,这里设为1024,远远比我发送的测试数据要大。所以不会产生第一种和第二种粘包的情况。

这种增加固定的协议,解析帧头和长度,应该是最为灵活的方法。

Android Java+TCP客戶端+粘包处理 前言 19年那会我还是用java去写的tcp,当然是另一个项目,也没有做沾包处理,今天重新把原来的项目给加上了粘包处理,当然还是选择用java语言.直接在原先的类上直接修改的. class TcpService implements Runnable 创建一个TCP连接类,该类实现Runnable,连接的过程中需要在子线程中去处理,所以我直接让该类实现接口. public TcpService(OnListenerIndustrialObject objectCallBack) { th 阅读详情

相关推荐

Android Kotlin语言实现+TCP客户端开发+粘包处理

不喜勿喷,个人不足的地方还有很多,有问题及解决思路的直接在留言方留言,或者私信给我,一起解决问题. 情景: 连接硬件板块,和硬件进行通信 讲解TCP机制什么的去找别的博客把,概念理解的没那么透彻,属实不敢乱讲.直接上代码把 // 定义一个类来继承协程使整个类拥有协程的上下文. internal class TransparentTcp : CoroutineScope{ private val job = Job() override val coroutineContext: Corout

ggy_yao的博客 2110

android socket第三方,GitHub - Blankeer/XAndroidSocket: Socket封装,支持TCP/UDP客户端和服务端,支持自定义粘包处理、验证处理、解析处理。...

XAndroidSocketSocket封装,支持TCP/UDP客户端和服务端,支持自定义粘包处理、验证处理、解析处理。##使用详见目录TCP/UDP使用demo下的例子,使用简单。其中只有TCP才支持支持粘包处理、验证处理、解析处理。Step 1. Add the JitPack repository to your build fileAdd it in your root build.gra...

weixin_42113456的博客 472

安卓Socket与pc端c#服务器的通信 附完整代码

一、前言小生不才,学习安卓socke通信打了很多滚,遇到过很多问题,也翻过前辈们关于socket的讲解,很杂各有见解,案例也不是很完整,于是特地将此安卓Socket与pc端c#服务器的通信代码讲解与socket的资料整理一遍加深理解,希望能有所帮助,小生没写过几次博客,欢迎各位大佬提出宝贵意见。安卓客户端项目源代码与pc端C#服务器与客户端的资源已经上传:安卓Socket与pc端c#服务器的通信完...

Zengpengqing1204的博客 5596

Android Socket 发送与接收数据问题: 发送后的数据接收到总是粘包

先说明一下粘包的概念: 发送时是两个单独的包、两次发送,但接收时两个包连在一起被一次接收到。 在以前 WinCE 下 Socket 编程,确实也要处理粘包的问题,没想到在 Android 下也遇到了。 首先想从发送端能否避免这样的问题,例如: (1) 调用强制刷数据完成发送的函数;(2) 设置发送超时。 1 先试了调用 flush() 函数,但运行后现象依旧 2 设置发送超时是 Windows 平台的做法,但在 Android 平台下是否有类似的设置呢? 查看 Socket 类的实现代码:java.net.

碎火流荧的博客 1661

Android基于TCP的局域网聊天通信

在同一局域网内,两台设备通过TCP进行通信聊天。

findhappy117的博客 3477

android TCP客户端通过socket与服务器通信

需要注意的是android4.0版本以上者,其socket通信都不能直接放在活动的主线程中,需要另起一个线程进行数据通信;另外,需要获得网络权限<uses-permission android:name="android.permission.INTERNET" />;还有就是要细心加耐心吧!

VIPEngineer的博客 982

粘包问题

一两个简单概念长连接与短连接:1.长连接    Client方与Server方先建立通讯连接,连接建立后不断开, 然后再进行报文发送和接收。2.短连接    Client方与Server每进行一次报文收发交易时才进行通讯连接,交易完毕后立即断开连接。此种方式常用于一点对多点 通讯

2665

socket的粘包处理

当前在网络传输应用中,广泛采用的是TCP/IP通信协议及其标准的socket应用开发编程接口(API)。TCP/IP传输层有两个并列的协议:TCP和UDP。其中TCP(transport control protocol,传输控制协议)是面向连接的,提供高可靠性服务。UDP(user datagram protocol,用户数据报协议)是无连接的,提供高效率服务。在实际工程应用中,对可靠性和效率的选择取决于应用的环境和需求。一般情况下,普通数据的网络传输采用高效率的udp,重要数据的网络传输采用高可靠性的TCP。

Android中关于Socket通信数据大小,内存缓冲区和数据可靠性的一点调查

关于TCP和UDP Socket通信的区别: 应用场景: UDP传输协议效率高,但不可靠; TCP传输效率低,但可靠。 传输数据大小: UDP传输数据限定在64K以下; TCP传输数据无大小限制,可进行大数据传输。 TCP/IP协议: 应用层、传输层、网络层、链路层 TCP和UDP都是基于TCP/IP的协议。 1、查看TCP/UDP数据占用内存大小 cat /proc/net/sockst...

Sunxiaolin2016的博客 5427

LSTM 怎么进行二维数据的输入呢

尽管LSTM并不天然地适用于处理图像、视频等二维数据,但通过时间序列化、卷积特征提取和双向LSTM等方法,我们可以将二维数据转化为适合LSTM输入的形式,从而利用LSTM的强大记忆能力和长期依赖学习能力对二维数据进行建模。未来的研究方向可以考虑将LSTM与其他模型结合,例如将LSTM与卷积神经网络(Convolutional Neural Network, CNN)结合,利用CNN提取图像的空间特征,然后利用LSTM学习时间序列的长期依赖;

xiamu_CDA的博客 1039

普通开普勒式望远镜光学设计1-初始结构设计选型与物镜像差校正

普通开普勒式望远镜光学设计1: 完成了望远镜的总体结构设计,确定其物镜与目镜的初始结构选型,使用Zemax软件完成望远镜的双胶合物镜的像差校正。

faust_cao的博客 1万+

Socket 套接字和解决粘包问题

---恢复内容开始--- Socket 套接字: 什么是socket: Socket是应用层与TCP/IP协议族通信的中间软件抽象层,它是一组接口。在设计模式中,Socket其实 就是一个门面模式,它把复杂的TCP/IP协议族隐藏在Socket接口后面,对用户来说,一组简单的接口 就是全部,让Socket去组织数据,以符合指定的协议。 socket在OSI模型中的位置 ...

weixin_30307267的博客 191

VFIO框架源码分析(二十二)- IOMMUFD 的脏页跟踪与 Dirty Bits 读取

在虚拟化热迁移(Live Migration)的场景中,脏页追踪(Dirty Page Tracking)是最具挑战性的环节之一。它的核心任务是实时捕获设备(DMA)对内存的写操作,以便 VMM(如 QEMU)知道哪些内存页需要被重新传输到目标主机。在强耦合与粗粒度:脏页追踪是绑定在 Container 上的。这意味着,如果一个 Container 内有多个设备,哪怕只有一个设备在写内存,脏页追踪也会影响 Container 内的所有设备。软件模拟开销大。

qq_36071928的博客 1046

什么是粘包,如何解决?

小的知识点 s1 = 'q' s2 = b'q' print(type(s1),type(s2)) print(s1.encode('utf-8')) #<class 'str'> <class 'bytes'> # b'q' bytes 类型: ASCII 字符,在字符前面 b " " 非 ASCII 类型,比如中文,先转化为字符串,然后再转为 bytes 类型...

weixin_30810239的博客 912

安装了anaconda,pycharm导入numpy时提示没有该包(模块)?

**问题详情:**我安装了anaconda,在利用Pycharm学习numpy这个库的时候,导入numpy这个包的时候提示我没有nummpy这个模块:No module named numpy.如下图所示。 应该说安装了Anaconda,里边就自带了numpy这个库,就应该能够使用。我一个新手怎么搞得懂呢?于是网上查了查找到了一个解决办法,说是我项目的解释器应该设置为Anaconda安装目录下的python.exe,而不应该是系统自带的:https://blog.youkuaiyun.com/aanndd77/art

qq_39820505的博客 1万+

Windows 11 24H2 系统下,保姆级安装华为 eNSP 模拟器(含依赖软件下载与避坑指南)

本文提供Windows 11 24H2系统下华为eNSP模拟器的完整安装指南,涵盖系统配置调整、依赖软件安装及常见问题解决方案。特别针对新版系统的兼容性问题,提供详细的避坑步骤和优化建议,帮助网络工程师顺利完成eNSP模拟器的部署与使用。

weixin_42567752的博客 431

socket编程实战+TCP粘包解决方案

在socket编程的道路上,TCP粘包问题宛如一只拦路虎,让无数开发者头疼不已。它隐蔽又棘手,导致数据传输混乱,程序运行异常。不过别担心,本文将为你全面剖析socket编程实战细节,并奉上超硬核的TCP粘包解决方案,一次性帮你解决所有难题,带你突破网络编程瓶颈,赶紧跟着文章开启这场技术之旅吧!!!加油!!!

qq_40170041的博客 171

基于ADS的低噪声放大电路设计

1. 低噪声放大器设计理论基础 1.1 低噪声放大器在通信系统中的作用 低噪声放大器的主要作用是放大天线从空中接收到的微弱信号,减小噪声干扰,以供系统解调出所需的信息数据。当今,人们对于各种无线通信工具的要求越来越高,如功率辐射要小、作用距离要远、覆盖范围要广等,这就对系统的接收灵敏度提出了更高的要求,系统接收灵敏度的计算公式为: Smin⁡=−144(dBmHz)+NF+10lg⁡BW(MHz)+SN(dB) {S_{\min }} = - 144\left( {\frac{{{\rm{dBm}}}}{

ASH_GUARDIAN的博客 4万+

“深入浅出”系列之Linux篇:(13)socket编程实战+TCP粘包解决方案

从日常使用的APP,到背后支撑的各类服务器,网络通信无处不在,而socket作为实现网络通信的关键技术,更是开发者们必须掌握的核心知识。但在socket编程的道路上,TCP粘包问题宛如一只拦路虎,让无数开发者头疼不已。它隐蔽又棘手,导致数据传输混乱,程序运行异常。不过别担心,本文将为你全面剖析socket编程实战细节,并奉上超硬核的TCP粘包解决方案,一次性帮你解决所有难题,带你突破网络编程瓶颈,赶紧跟着文章开启这场技术之旅吧!!!加油!!!

weixin_65589140的博客 796

C#部署YOLO三种方案深度实测:OpenCV DNN vs ONNX Runtime vs TensorRT

在工业视觉项目落地阶段,C#生态下部署YOLO模型主要有三条技术路线。很多开发者仅凭经验选型,往往在部署后期踩中性能瓶颈、兼容故障、维护成本超标的坑。本文基于工控机常见硬件配置,针对YOLOv8系列模型做控制变量实测,从推理性能、部署难度、工业稳定性、综合成本等多个维度做横向对比,给出可直接落地的选型结论。

这里只有干货:从 Modbus 通信到 MES 对接,从 YOLO 训练到工控机部署,带你搞定工业软件开发全流程。 470

Python量化- Black-Litterman 模型

​​​​​​​Black-Litterman 模型由 Fischer Black 和 Robert Litterman 于 1992 年开发,采用贝叶斯方法进行资产配置。该模型通过结合先前的回报估计(可以从多个来源得出)并结合投资者对未来回报的独特预期来优化分配权重。

探索人工智能领域 1030

基于Android语言的通信调试助手实现(TCP协议+Socket编程)

在Android开发中经常会遇到Android通信的问题,比如物联网开发,实现Android上位机和下位机的通信,但是在没有硬件设备的配合之下,又不知道此次开发是否正确,发送数据是否达到要求。于是,此篇文章就是讲述Android通信调试助手的开发,方便Android通信的验证和数据对比,就是利用Android开发一个数据端和Windows数据端进行通信。效果如下图。 Windows端是NetAssist助手,后面我会给出下载地址。Android端就是今天的重点。 接下来就是讲述Androi.

北风 2460

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

【Android学习】socket长连接,数据粘包问题

1,问题再现之前的socket连接,都是每次使用的时候,重新new socket。根据实际需求,需要进行长连接,即:socket连接后不断开,每次使用的时候也不重新new新的socket。此时出现新的问题:第一次发送数据还好,第二次接收到的数据出现粘包问题,导致json解析数据无法成功。2,问题解决上网搜了无数帖子,发现socket的粘包问题始终无法避免。最后我们采用了http来进行登录、任务的接收

午后阳光 3872

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

Android P的Socket通信实现

android通过网络协议TCP进行socket的通信的Demo。 测试可用。 一、创建客户端 protected void connectSocket() { Socket socket; try { // 创建一个Socket对象,并指定服务端的IP及端口号 socket = new Socket("10....

Sunxiaolin2016的博客 703

安卓与ESP8266串口WIFI模块的通信实现

软件简介 结合一个控制实例,简要介绍一下安卓客户端软件。 主界面非常简洁,左边一个方向控制盘,和右边4个Button。方向盘是一个自定义的View,可以转动任意角度,程序里只响应4个方向,已经足够。四个Button分别对应相应的功能键。 通信实现原理 使用基于tcp协议的socket通信。串口WiFi模块配置成tcp Service模式,然后安卓连接串口wifi模块的热点,客...

redflyfan 1万+

Uniapp: 原生Android插件开发调试打包详细历程 --- 不再为付费插件买单(例:安卓原生 TCPSocket 连接通信插件实现)

原生Android插件开发调试打包详细历程 --- 不再为付费插件买单!

Specif1c的博客 1万+
上一篇: Android中关于Socket通信数据大小,内存缓冲区和数据可靠性的一点调查
下一篇: Android P实现Tcp socket心跳包机制 保证socket断开重连
sunxiaolin2016
博客等级 码龄10年 221粉丝 205原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

sunxiaolin2016

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

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

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

打赏作者

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

抵扣说明:

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

余额充值