精华内容
下载资源
问答
  • 作者:郭无心链接:...首先,TCP是可靠的数据连接,send过去的数据,一定会被对方接收到,除非连接断开。TCP和上层应用之间是网络层和应用层之间的关系,TCP收到的ACK只能表明对端TCP收到了相应的数据在...
    作者:郭无心
    链接:https://www.zhihu.com/question/25016042/answer/73785738
    来源:知乎
    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

    首先,TCP是可靠的数据连接,send过去的数据,一定会被对方接收到,除非连接断开。
    TCP和上层应用之间是网络层和应用层之间的关系,TCP收到的ACK只能表明对端TCP收到了相应的数据在内核缓存中,对端应用是否读取到了这条消息,是不能判断的,这点赞同

    的答案。
    ------------------------------------------------------------------------------------
    题主可能对TCP中的send recv 和应用层的发送与消息接收之间的关系不是很清楚

     

    先明确一个概念:每个TCP socket在内核中都有一个发送缓冲区和一个接收缓冲区,TCP的全双工的工作模式以及TCP的滑动窗口便是依赖于这两个独立的buffer以及此buffer的填充状态。接收缓冲区把数据缓存入内核,应用进程一直没有调用read进行读取的话,此数据会一直缓存在相应 socket的接收缓冲区内。再啰嗦一点,不管进程是否读取socket,对端发来的数据都会经由内核接收并且缓存到socket的内核接收缓冲区之中。 read所做的工作,就是把内核缓冲区中的数据拷贝到应用层用户的buffer里面,仅此而已。进程调用send发送的数据的时候,最简单情况(也是一般情况),将数据拷贝进入socket的内核发送缓冲区之中,然后send便会在上层返回(也就是说send的返回值不能表明数据已经发送到了对端并被接收)。换句话说,send返回之时,数据不一定会发送到对端去(和 write写文件有点类似),send仅仅是把应用层buffer的数据拷贝进socket的内核发送buffer中。后续我会专门用一篇文章介绍 read和send所关联的内核动作。每个UDP socket都有一个接收缓冲区,没有发送缓冲区,从概念上来说就是只要有数据就发,不管对方是否可以正确接收,所以不缓冲,不需要发送缓冲区。

    接收缓冲区被TCP和UDP用来缓存网络上来的数据,一直保存到应用进程读走为止。对于TCP,如果应用进程一直没有读取,buffer满了之后,发生的动作是:通知对端TCP协议中的窗口关闭。这个便是滑动窗口的实现。保证TCP套接口接收缓冲区不会溢出,从而保证了TCP是可靠传输。因为对方不允许发出超过所通告窗口大小的数据。 这就是TCP的流量控制,如果对方无视窗口大小而发出了超过窗口大小的数据,则接收方TCP将丢弃它。 UDP:当套接口接收缓冲区满时,新来的数据报无法进入接收缓冲区,此数据报就被丢弃。UDP是没有流量控制的;快的发送者可以很容易地就淹没慢的接收者,导致接收方的UDP丢弃数据报。

    综上 :对方接收成功后给返回一个消息,发送方收到这个消息后就认为对方接收成功。

    发送端是不管对方接收是否成功的,你是无法判断的。只有让对方接受成功后,给你发一个通知
    (TCP只要发送出去了,就已经发送到对方环境中了,如果是有操作的请求,那应该等待返回处理成功消息,如果是QQ这样的应用,发送出去的消息要保证对方收到,对方客户端收到后会给回应我收到了某某的哪条消息,TCP全部发送到服务器之后就确认发送过去了,但是应用层可以给个回应),已读这类功能肯定就是接受方主动发送的消息,告知我读了

    转载于:https://www.cnblogs.com/fire909090/p/7649232.html

    展开全文
  • //成功接收一段数据会信号通知 connect(msocket,SIGNAL(bytesRead(qint64)),this, SLOT(send_file_content())); } Client::~Client() { delete ui; } //接收数据槽函数 void Client::read_data() { if(file...
  • 具体的功能就是:android 我给你打电话,我不说话我都是播放我本地的录音文件你听到的都是我播放的手机上的文件的声音
  • Qt实现tcp发送和接收文件

    千次阅读 2020-11-30 17:08:30
    serverwidget.h #ifndef SERVERWIDGET_H #define ... } //弹出对话框,显示接收文件的信息 QString str1 = QString("接收文件:[%1:%2kb]").arg(fileName).arg(fileSize/1024); ui->textEdit->append(str1); ...

    serverwidget.h

    #ifndef SERVERWIDGET_H
    #define SERVERWIDGET_H
    #ifdef WIN32
    #pragma execution_character_set("utf-8")
    #endif
    
    #include <QWidget>
    #include <QTcpServer>//监听套接字
    #include <QTcpSocket>//通信套接字
    #include <QFile>
    #include<QTimer>
    namespace Ui {
    class serverWidget;
    }
    class serverWidget : public QWidget
    {
        Q_OBJECT
    public:
        explicit serverWidget(QWidget *parent = nullptr);
        ~serverWidget();
        void sendData();
    private slots:
        void on_buttonFile_clicked();
        void on_buttonSend_clicked();
    private:
        Ui::serverWidget *ui;
        QTcpServer *tcpServer;//监听套接字
        QTcpSocket *tcpSocket;//通信套接字
        QFile file;//文件对象
        QString fileName;//文件名字
        qint64 fileSize;//文件大小
        qint64 sendSize;//已经发送文件的大小
    
        QTimer timer;//定时器
    };
    #endif // SERVERWIDGET_H
    
    

    serverwidget.cpp

    #include "serverwidget.h"
    #include "ui_serverwidget.h"
    #include<QFileDialog>
    #include<QDebug>
    #include<QFileInfo>
    
    serverWidget::serverWidget(QWidget *parent) :
        QWidget(parent),
        ui(new Ui::serverWidget)
    {
        ui->setupUi(this);
    
        //监听套接字
        tcpServer = new QTcpServer(this);
        //监听
        tcpServer->listen(QHostAddress::Any,8888);
        setWindowTitle("服务器端口为:8888");
    
        //刚开始,两个按钮都不能按,显示灰色
        ui->buttonFile->setEnabled(false);
        ui->buttonSend->setEnabled(false);
    
        //如果客户端成功和服务器连接
        //tcpServer会自动触发newconnection()
        connect(tcpServer,&QTcpServer::newConnection,
                [=]()
        {
            //取出建立好连接的套接字
            tcpSocket = tcpServer->nextPendingConnection();
            //获取对方的IP和端口
            QString ip = tcpSocket->peerAddress().toString();
            quint16 port = tcpSocket->peerPort();
    
            QString str = QString("[%1:%2] 成功连接到服务器").arg(ip).arg(port);
            //显示到编辑区
            ui->textEdit->setText(str);
    
            //成功连接后,才能按选择文件
            ui->buttonFile->setEnabled(true);
    
            connect(tcpSocket,&QTcpSocket::readAll,
                    [=]()
                        {
                            //取出客户端信息
                            QByteArray buf = tcpSocket->readAll();
                            if(QString(buf) == "file done")
                            {
                                ui->textEdit->append("文件发送完毕");
    
                                file.close();
                                //断开客户端端口
                                tcpSocket->disconnectFromHost();
                                tcpSocket->close();
                            }
                        }
    
                    );
        }
                );
        connect(&timer,&QTimer::timeout,
                [=]()
                    {
                        //关闭定时器
                        timer.stop();
    
                        //发送文件
                        sendData();
                    }
                );
    }
    
    serverWidget::~serverWidget()
    {
        delete ui;
    }
    //选择文件按钮
    void serverWidget::on_buttonFile_clicked()
    {
        QString filePath = QFileDialog::getOpenFileName(this,"打开","../");
        //判断,如果打开的路径有效
        if(false == filePath.isEmpty())
        {
            fileName.clear();
            fileSize = 0 ;
    
            //获取文件信息
            QFileInfo info(filePath);
            fileName = info.fileName();//获取文件名字
            fileSize = info.size();//获取文件大小
    
            sendSize = 0 ; //已发送文件的大小,初始化为0
    
            //只读方式打开文件
            //指定文件的名字
            file.setFileName(filePath);
            //打开文件
            bool isOK = file.open(QIODevice::ReadOnly);
            if(false == isOK)
            {
                qDebug() << "只读方式打开文件失败 72";
            }
    
            //提示打开文件的路径
            ui->textEdit->append(filePath);
    
            ui->buttonFile->setEnabled(false);
            ui->buttonSend->setEnabled(true);
        }
        else
        {
            qDebug()<<"打开的路径错误:58";
        }
    }
    //发送文件按钮
    void serverWidget::on_buttonSend_clicked()
    {
        //先发送文件头信息   文件名##文件大小
        QString head = QString("%1##%2").arg(fileName).arg(fileSize);
        //发送头部信息
        qint64 len = tcpSocket->write( head.toUtf8() );
        if(len > 0)//如果头部信息发送成功
        {
            //发送真正的文件信息
            //防止TCP黏包文件,需要通过定时器延时20ms
            timer.start(20);
        }
        else
        {
            qDebug() << "头部文件发送失败 101";
            file.close();
            ui->buttonFile->setEnabled(true);
            ui->buttonSend->setEnabled(false);
        }
    }
    
    void serverWidget::sendData()
    {
        qint64 len = 0;
        do
        {
            //每次发送数据的大小,4k
            char buf[4*1024] = {0};
            len= 0;
    
            //往文件中读数据
            len = file.read(buf,sizeof (buf));
            //发送数据,读多少,发多少
            len = tcpSocket->write(buf,len);
    
            //发送的数据累加
            sendSize += len;
    
        }while(len >0);
        if(sendSize == fileSize)
        {
            ui->textEdit->append("文件发送完毕");
            file.close();
    
            //把客户端断开
            tcpSocket->disconnectFromHost();
            tcpSocket->close();
        }
    }
    

    clientwidget.h

    #ifndef CLIENTWIDGET_H
    #define CLIENTWIDGET_H
    #ifdef WIN32
    #pragma execution_character_set("utf-8")
    #endif
    
    #include <QWidget>
    #include<QTcpSocket>
    #include<QFile>
    
    namespace Ui {
    class ClientWidget;
    }
    
    class ClientWidget : public QWidget
    {
        Q_OBJECT
    
    public:
        explicit ClientWidget(QWidget *parent = nullptr);
        ~ClientWidget();
    
    private slots:
        void on_buttonConnect_clicked();
    
    private:
        Ui::ClientWidget *ui;
    
        QTcpSocket *tcpSocket;
    
        QFile file;//文件对象
        QString fileName;//文件名字
        qint64 fileSize;//文件大小
        qint64 receiveSize;//已经收到文件的大小
    
        bool isStart;//定义一个标识位
    };
    
    #endif // CLIENTWIDGET_H
    
    

    clientwidget.cpp

    #include "clientwidget.h"
    #include "ui_clientwidget.h"
    #include<QDebug>
    #include<QMessageBox>
    #include<QHostAddress>
    #include<QProgressBar>
    
    ClientWidget::ClientWidget(QWidget *parent) :
        QWidget(parent),
        ui(new Ui::ClientWidget)
    {
        ui->setupUi(this);
    
        tcpSocket = new QTcpSocket(this);
        isStart = true;
    
        //进度条设置当前值0
        ui->progressBar->setValue(0);
    
        connect(tcpSocket,&QTcpSocket::readyRead,
                [=]()
                    {
                        //取出接收的内容
                        QByteArray buf = tcpSocket->readAll();
                        if(true == isStart)
                        {
                            //接收头
                            isStart = false;
    
                            //解析头部信息,拆包,类似数组取下标的方式
                            //QString str = "hello##1024##mike"
                            //str.section("##",0,0)
    
                            //初始化
                            fileName = QString(buf).section("##",0,0);
                            fileSize = QString(buf).section("##",1,1).toInt();
                            receiveSize = 0;
    
                            //打开文件
                            file.setFileName(fileName);
                            bool isOK = file.open(QIODevice::WriteOnly);
                            if(false == isOK)
                            {
                                qDebug() << "WriteOnly error 38";
                            }
    
                            //弹出对话框,显示接收文件的信息
                            QString str1 = QString("接收的文件:[%1:%2kb]").arg(fileName).arg(fileSize/1024);
                            ui->textEdit->append(str1);
                            //QMessageBox::information(this,"文件信息",str1);
    
                            //设置进度条
                            ui->progressBar->setMinimum(0);//最小值
                            ui->progressBar->setMaximum(fileSize/1024);//最大值
                            ui->progressBar->setValue(0);//当前值
    
                        }
                        //读文件信息
                        else
                        {
                            qint64 len = file.write(buf);
                            receiveSize += len;
    
                            //客户端接收了多少,反馈给服务器
                            //QString str = QString::number(receiveSize);
                            //tcpSocket->write(str.toUtf8().data());
    
                            //更新进度条
                            ui->progressBar->setValue(receiveSize/1024);
    
                            if(receiveSize == fileSize)
                            {
                                //给服务器发送(接收文件完成)
                                //tcpSocket->write("file done");
    
                                file.close();
                                QMessageBox::information(this,"完成","文件接收完成");
    
                                tcpSocket->disconnectFromHost();
                                tcpSocket->close();
                            }
                        }
                    }
                );
    }
    
    ClientWidget::~ClientWidget()
    {
        delete ui;
    }
    
    void ClientWidget::on_buttonConnect_clicked()
    {
        //获取服务器的ip和端口
        QString ip = ui->lineEditIp->text();
        quint16 port = ui->lineEditPort->text().toInt();
    
        tcpSocket->connectToHost(QHostAddress(ip),port);
    }
    
    
    展开全文
  • 用JAVA SOCKET发送和接收文件

    千次阅读 2012-07-29 20:57:54
    /*服务器端接收文件*/  import java.io.File;  import java.io.IOException;  import java.io.InputStream;  import java.io.RandomAccessFile;  import java.net.ServerSocket;  import java.n
    Java代码   收藏代码
    1. /*服务器端接收文件*/  
    2. import java.io.File;  
    3. import java.io.IOException;  
    4. import java.io.InputStream;  
    5. import java.io.RandomAccessFile;  
    6. import java.net.ServerSocket;  
    7. import java.net.Socket;  
    8.   
    9. import javax.swing.JFileChooser;  
    10.   
    11. /** 
    12. * 该类用到的绑定端口初始为10000,如果绑定不成功则试另外的端口; 
    13. * 绑定次数用tryBindTimes变量,表示如果绑定失败会对它加一; 
    14. * 当前绑定端口由DefaultBindPort+tryBindTimes决定; 
    15. * 外界系统(调用此程序的对象)可以获取当前的帮定端口; 
    16. * 并告诉客户端服务的端口号以使其能正确连接到该端口上; 
    17. * @author 
    18. * 
    19. */  
    20. public class GetFile extends Thread {  
    21.   
    22.     // 服务套接字等待对方的连接和文件发送  
    23.     ServerSocket serSocket;  
    24.     // 由服务套接字产生的 套接字  
    25.     Socket tempSocket;  
    26.     // 用于读取  
    27.     InputStream inSocket;  
    28.     // 随机访问文件  
    29.     RandomAccessFile inFile = null;  
    30.     // 临时缓寸区  
    31.     byte byteBuffer[] = new byte[1024];  
    32.     // 默认用10000端口监听请求  
    33.     int defaultBindPort = 10000;  
    34.     // 初始的绑定端口次数为0  
    35.     int tryBindTimes = 0;  
    36.     // 当前绑定的端口号是10000默认端口  
    37.     int currentBindPort = defaultBindPort + tryBindTimes;  
    38.   
    39.     /** 
    40.     * @构造方法 
    41.     * @抛出异常的原因是无法绑定服务的端口 
    42.     * */  
    43.     public GetFile(int port) throws Exception {  
    44.         try {  
    45.             // 绑定服务的端口  
    46.             this.bindToServerPort();  
    47.   
    48.         } catch (Exception e) {  
    49.             e.printStackTrace();  
    50.             // 绑定不成功重试  
    51.             System.out.println(e.toString());  
    52.             throw new Exception("绑定端口不成功!");  
    53.   
    54.         }  
    55.         // 文件选择器以当前的目录打开  
    56.         JFileChooser jfc = new JFileChooser(".");  
    57.         jfc.showSaveDialog(new javax.swing.JFrame());  
    58.         // 获取当前的选择文件引用  
    59.         File savedFile = jfc.getSelectedFile();  
    60.   
    61.         // 已经选择了文件  
    62.         if (savedFile != null) {  
    63.             // 读取文件的数据,可以每次以快的方式读取数据  
    64.             inFile = new RandomAccessFile(savedFile, "rw");  
    65.   
    66.         }  
    67.     }  
    68.      
    69.    /** 
    70.     * @监控线程 
    71.     */  
    72.     public void run() {  
    73.         try {  
    74.             if (this.inFile == null) {  
    75.                 System.out.println("没有选择文件");  
    76.                 // 关闭服务方套接字  
    77.                 this.serSocket.close();  
    78.                 // 没有选择文件  
    79.                 return;  
    80.             }  
    81.              
    82.             System.out.println("wait for..." + '\n' + "等待对方接入");  
    83.             // 等待对方的连接  
    84.             tempSocket = serSocket.accept();  
    85.             // 五秒钟连不上将抛出异常  
    86.             this.serSocket.setSoTimeout(5000);  
    87.             // 获取输入流  
    88.             this.inSocket = tempSocket.getInputStream();  
    89.              
    90.         } catch (Exception ex) {  
    91.             System.out.println(ex.toString());  
    92.             ex.printStackTrace();  
    93.             return;  
    94.         }  
    95.          
    96.         // 以下为传送文件代码和 套接字清理工作  
    97.         int amount;  
    98.         try {  
    99.             while ((amount = inSocket.read(byteBuffer)) != -1) {  
    100.                 inFile.write(byteBuffer, 0, amount);  
    101.             }  
    102.             // 关闭流  
    103.             inSocket.close();  
    104.             javax.swing.JOptionPane.showMessageDialog(new javax.swing.JFrame(),  
    105.                     "已接收成功""提示!", javax.swing.JOptionPane.PLAIN_MESSAGE);  
    106.             System.out.println("Get OK");  
    107.             System.out.println("接收完毕!");  
    108.             // 关闭文件  
    109.             inFile.close();  
    110.             // 关闭临时套接字  
    111.             tempSocket.close();  
    112.             // 关闭服务方套接字  
    113.             this.serSocket.close();  
    114.              
    115.         } catch (IOException e) {  
    116.             System.out.println(e.toString());  
    117.             e.printStackTrace();  
    118.         }  
    119.   
    120.     }  
    121.   
    122.     /** 
    123.     * @绑定端口 
    124.     * @throws Exception 抛出异常的原因是无法绑定服务的端口 
    125.     */  
    126.     private void bindToServerPort() throws Exception {  
    127.         try {  
    128.             // 输出绑定的端口号到当前的控制台上  
    129.             System.out.println("试绑定的端口号是:" + this.currentBindPort);  
    130.             // 在自己的机器上开一个服务类套接字并等待发送者的连接  
    131.             serSocket = new ServerSocket(this.currentBindPort);  
    132.   
    133.         } catch (Exception e) {  
    134.             e.printStackTrace();  
    135.             // 绑定不成功重试  
    136.             System.out.println(e.toString());  
    137.             // 试了不止一次了  
    138.             this.tryBindTimes = this.tryBindTimes + 1;  
    139.            // 可查看试的次数getTryBindedTimes  
    140.             this.currentBindPort = this.defaultBindPort + this.tryBindTimes;  
    141.   
    142.             // 如果试的次数超过20次 退出  
    143.             if (this.tryBindTimes >= 20) {  
    144.                 throw new Exception("无法绑定到指定端口" + '\n' + "试了太多次了!");  
    145.   
    146.             }  
    147.             // 递归的绑定  
    148.             this.bindToServerPort();  
    149.         }  
    150.   
    151.         // 输出绑定的端口号到当前的控制台上  
    152.         System.out.println("成功绑定的端口号是: " + this.currentBindPort);  
    153.   
    154.     }  
    155.   
    156.     // 获取试绑定的端口  
    157.     public int getTryBindedTimes() {  
    158.         return this.tryBindTimes;  
    159.     }  
    160.   
    161.     // 获取已经绑定的端口  
    162.     public int getCurrentBindingPort() {  
    163.         return this.currentBindPort;  
    164.     }  
    165.      
    166.   
    167.     /** 
    168.     * @测试方法 
    169.     * @param args 
    170.     */  
    171.     public static void main(String args[]) {  
    172.         GetFile getFile = null;  
    173.         try {  
    174.   
    175.             getFile = new GetFile(10000);  
    176.   
    177.         } catch (Exception e) {  
    178.             e.printStackTrace();  
    179.             System.out.println("无法传送文件!");  
    180.             System.exit(1);  
    181.         }  
    182.         getFile.start();  
    183.   
    184.     }  
    185.   
    186. }  

     

    Java代码   收藏代码
    1. /*文件发送端*/  
    2. import java.io.File;  
    3. import java.io.IOException;  
    4. import java.io.OutputStream;  
    5. import java.io.RandomAccessFile;  
    6. import java.net.Socket;  
    7.   
    8. import javax.swing.JFileChooser;  
    9.   
    10. /** 
    11. * 在服务器端开启的情况下 实例化套接字 并发送文件 
    12. * 
    13. * @author  
    14. */  
    15. public class SendFile extends Thread {  
    16.   
    17.     // 远程的IP字符串  
    18.     String remoteIPString = null;  
    19.     // 远程的服务端口  
    20.     int port;  
    21.     // 临时套接字  
    22.     Socket tempSocket;  
    23.     // 发送文件用的输出流  
    24.     OutputStream outSocket;  
    25.     // 欲发送的文件  
    26.     RandomAccessFile outFile;  
    27.     // 发送文件用的临时缓存区  
    28.     byte byteBuffer[] = new byte[1024];  
    29.   
    30.     /** 
    31.     * 构造方法仅用于选择发送文件的位置 并从外部接收远程地址和端口 
    32.     * 
    33.     */  
    34.     public SendFile(String remoteIPString, int port) {  
    35.         try {  
    36.             this.remoteIPString = remoteIPString;  
    37.             this.port = port;  
    38.   
    39.            // 选择发送的文件位置  
    40.             JFileChooser jfc = new JFileChooser(".");  
    41.             File file = null;  
    42.             int returnVal = jfc.showOpenDialog(new javax.swing.JFrame());  
    43.             if (returnVal == JFileChooser.APPROVE_OPTION) {  
    44.                 file = jfc.getSelectedFile();  
    45.   
    46.             }  
    47.   
    48.             outFile = new RandomAccessFile(file, "r");  
    49.   
    50.         } catch (Exception e) {  
    51.         }  
    52.     }  
    53.   
    54.     /** 
    55.     * 先决条件是服务器端先开启 
    56.     * 
    57.     */  
    58.     public void run() {  
    59.         try {  
    60.             this.tempSocket = new Socket(this.remoteIPString, this.port);  
    61.             System.out.println("与服务器连接成功!");  
    62.             outSocket = tempSocket.getOutputStream();  
    63.   
    64.             int amount;  
    65.             System.out.println("开始发送文件...");  
    66.             while ((amount = outFile.read(byteBuffer)) != -1) {  
    67.                 outSocket.write(byteBuffer, 0, amount);  
    68.                 System.out.println("文件发送中...");  
    69.             }  
    70.             System.out.println("Send File complete");  
    71.             javax.swing.JOptionPane.showMessageDialog(new javax.swing.JFrame(),  
    72.                     "已发送完毕""提示!", javax.swing.JOptionPane.PLAIN_MESSAGE);  
    73.             outFile.close();  
    74.             tempSocket.close();  
    75.   
    76.         } catch (IOException e) {  
    77.             System.out.println(e.toString());  
    78.             e.printStackTrace();  
    79.         }  
    80.   
    81.     }  
    82.   
    83.     /** 
    84.     * 测试方法 
    85.     * 
    86.     * @param args 
    87.     */  
    88.     public static void main(String args[]) {  
    89.         SendFile sf = new SendFile("127.0.0.1"10000);  
    90.         sf.start();  
    91.   
    92.     }  
    93. }  


    展开全文
  • 使用服务管理器中的“文件清除”功能清除离线文件,然后再在客户端看能否正常收发文件。 如果使用该功能后还是空间不足,则到服务器安装目录下Files 子目录下进行手工清除。 天气常如二三月,花枝不断四时春. ...
      检查是否磁盘硬件空间不足。使用服务管理器中的“文件清除”功能清除离线文件,然后再在客户端看能否正常收发文件。

    如果使用该功能后还是空间不足,则到服务器安装目录下Files 子目录下进行手工清除。

    天气常如二三月,花枝不断四时春.
    欢迎访问 俺滴博客.




    展开全文
  • 一开始项目是打算做成微信小程序的,所以基本都是在微信开发者工具上调试,因为项目功能越做越大,越来越复杂,微信小程序感觉不合适了,就打算转app...我是用django写的后台,但是后台一直收不到上传的文件,可是...
  • 文件尾添加一个结束标志(与接收方约定好),当接收方检测到这个结束标志,认为对方发送结束。该方法也称为协议法,具体实现可以如下: 在文件头加一个协议,包括三个数据,u8 a,b,c,a标识该文件是目标文件,b为...
  • 这篇文章主要介绍如何实现点对点单人聊天、多人的群聊、以及如何给对方发送文件,如何发送图片消息和语音消息等功能。 欢迎访问我的个人博客:http://ittiger.cn 1.单人聊天 首先创建聊天对象 /** * 创建...
  • 大多数程序都有接收拖放文件的功能,即是用鼠标把文件拖放到程序窗口上方,符合格式的文件就会自动被程序打开。最近自己对编写的程序增加了一个拖放文件的功能,在 Windows XP、Windows Server 2003 系统上拖放文件...
  • 目前的情况是:TCP,客户端连接成功后循环recv接收文件,服务端accept后循环send,直到发完整个文件,然后close socket。有概率出现客户端快接收完的时候recv返回0,(MSDN上说是对方已经优雅的关闭了)
  • C#实现文件的发送和接收

    千次阅读 2007-08-10 02:21:00
    为了把问题说清楚,把一些变量都直接附值了,并没有通过输入附值private string path = "F://SmartMovie.EXE"; //要发送的文件 private Socket s; private void listen() { 
  • 程序实现的是一个读取照片(可改为其文件类型)的服务端,可同时接受多个客户端连接,并且同时接受多张图片的数据。主要是通过多线程控制,每次检测到有请求连接,则开辟一个新线程,新线程的作用是接受图片, 通过...
  • 问题: 项目中有个功能模块是需要用到FTP协议传输文件,但发现传输成功文件比原文件大的情况。 首先我先修改了传输的代码,部分源代码如下: byte[] buffer = new byte[1024]; while (inputStream.read(buffer...
  • 软件介绍: 小巧而强大的文件传送工具,传输速度很快,支持批量文件传输,支持断点续传,支持整个文件夹的传输(包含文件夹下的所有文件以及子文件夹),支持多个批次的文件同时传输。...然后等待对方接收,就可以了。
  • 内网文件传输工具.rar

    2021-09-25 12:53:52
    软件介绍: 小巧而强大的文件传送工具,传输速度很快,支持批量文件传输,支持断点续传,支持整个文件夹的传输(包含文件夹下的所有文件以及子文件夹),支持多个批次的文件同时传输。...然后等待对方接收,就可以了。
  • recv.exe是接收端程序 serv.exe是发送端程序 必须先打开接收端程序再打开发送端程序方可成功连接,否则无法成功连接,提示错误 对方IP地址与端口号在发送端程序里设置成固定的,需修改源代码来修改接收方地址
  • 大多数程序都有接收拖放文件的功能,即是用鼠标把文件拖放到程序窗口上方,符合格式的文件就会自动被程序打开。最近自己对编写的程序增加了一个拖放文件的功能,在 Windows XP、Windows Server 2003 系统上拖放文件...
  • socket实现文件传输功能

    万次阅读 2017-06-03 21:12:11
    要实现的功能为:client 从 server 下载一个文件并保存到本地。 编写这个程序需要注意两...接收数据时也会遇到同样的情况。 要解决这个问题,可以使用 while 循环,例如: //Server 代码int nCount;while( (nCount
  • c#TCP传输文件

    千次阅读 2020-01-06 19:22:30
    本文转载自:https://www.cnblogs.com/bianlan/archive/2012/08/10/2632349.html 作者:bianlan 转载请注明该声明...一旦通信双方建立了TCP连接,连接中的任何一方都能向对方发送数据和接受对方发来的数据。TCP协议...
  • QTCpSocket文件传输

    千次阅读 2017-06-06 13:09:51
    而TCP由于其建立连接,具有可靠性强、能够保证不丢包,所以经常用于大文件的传输。但是由于TCP粘包,所以在使用TCP进行文件传输时,需要进行粘包问题的考虑。关于TCP/UDP用于聊天程序的应用可以参考:QTcpServer、...
  • 我的这个Socket是想保持一个长连接,文件可以循环传输 但是我的问题在于,不能抓住文件传输完成的这个时机,导致异常 我的文件发送代码 [code=java] public void sendFile(String filePath)  {  try  {
  • Bat文件编写

    千次阅读 2012-07-07 10:01:46
    首先批处理文件是一个文本文件,这个文件的每一行都是一条DOS命令(大部分时候就好象我们在DOS提示符下执行的命令行一样),你可以使用DOS下的Edit或者Windows的记事本(notepad)等任何文本文件编辑工具创建和修改...
  • HttpClient上传文件传入MultipartFile类型

    万次阅读 热门讨论 2019-05-27 21:05:40
    在近期的项目中有这样的一个需求,我需要通过httpclient去调用一个写好的文件上传的接口,接口中是使用MultipartFile 来接受文件类型参数的。在这种情况下我们就开辟一个HttpClient中的高级功能了。直接上代码,封装...
  • 文件锁的使用浅析

    万次阅读 2018-04-22 22:27:23
    在多数unix系统中,当多个进程/线程同时编辑一个文件时,该文件的最后状态取决于最后一个写该文件的进程。 对于有些应用程序,如数据库,各个进程需要保证它正在单独地写一个文件。这时就要用到文件锁。 文件锁...
  • 支持IPv4和IPv6双协议的文件传输工具

    热门讨论 2010-09-05 17:16:35
    首先接受方和发送方必须正常运行本程序,发送方在 接收方地址 栏 填入接收方的IP(也可以是IPv6)地址,打开要发送的文件,点击发送,等待对方回应即可 1.本软件同时支持IPv4和IPv6协议,只要双方主机有一种协议可...
  • 用python实现一个机遇tcp协议的服务器和客户端,服务器存储文件,客户端从服务器请求文件下载,互相通信。 1.tcp协议的服务器实现 from socket import * import sys def get_filecontent(file_name): '''方法...
  • (2)接收文件,当点击这个按钮时,则输入需要连接的主机ip地址,连接成功后输入需要传输的文件名。使用这个功能时,需要对方把正在运行服务器模块。 (3)视频聊天,当点击这个按钮时,输入需要聊天的主机ip地址...
  • 大多数程序都有接收拖放文件的功能,即是用鼠标把文件拖放到程序窗口上方,符合格式的文件就会自动被程序打开。最近自己对编写的程序增加了一个拖放文件的功能,在 Windows XP、Windows Server 2003 系统上拖放文件...
  • Linux-C 简单的TCP文件传输例子

    千次阅读 2019-03-22 22:23:21
    Linux-C 简单的TCP文件传输例子 一、简述 记--使用TCP协议进行端到端的文件传输 的简单例子。并利用该程序将Ubuntu将文件传输到开发板。 例子打包:链接: ... ...recv接收文件,send发送文件。 三、源...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 76,557
精华内容 30,622
关键字:

对方已经成功接收文件