1.实现思路

要实现文件传输功能，需要在基础的 TCP 通信的代码上进行修改。

主要有两个要处理的点：文件的读写，TCP 收发。

对于文件的读写，每次只读取部分数据进行发送，然后 seek 到紧邻的位置便于下次读取；接收端写文件更简单，收到文件数据写文件就行了（准备传输的时候会把文件名和文件长度发到接收端）。

要实现 TCP 发送和接收文件，需要拟定通信协议，用于从字节流中取出数据帧（多次发送的数据连在一起，或者一次发送的分多次收到，就需要我们先把接收的数据缓存起来，根据协议逐帧解析和校验）。我写了个很简陋的协议：

传输协议
帧结构：帧头4+帧长2+帧类型1+帧数据N+帧尾2（没有校验段，懒得写）
帧头：4字节定值 0x0F 0xF0 0x00 0xFF
帧长：2字节数据段长度值 arr[4]*0x100+arr[5] 前面为高位后面为低位
帧类型：1字节
- 0x01 [S/C]准备发送文件，后跟四字节文件长度和N字节utf8文件名，长度计算同帧长一样前面为高位后面为低位
- 0x02 [C]文件数据
- 0x03 [S/C]发送结束，客户端无数据段，服务端接收返回1字节数据段：成功=1，失败=0，可扩展失败原因枚举
- 0x04 [S/C]取消发送
（服务端收到0x01 0x03开始和结束发送两个命令要进行应答，回同样的命令码无数据段）
帧尾：2字节定值 0x0D 0x0A

发送数据时在命令或数据的头尾加上帧头帧尾即可：

//帧头+长度+类型
char frameHead[7] = { 0x0F, (char)0xF0, 0x00, (char)0xFF, 0x00, 0x00, 0x00 };
//帧尾
char frameTail[2] = { 0x0D, 0x0A };void ServerOperate::sendData(char type, const QByteArray &data)
{if(!socket->isValid())return;frameHead[6]=type;const quint64 data_size=data.count();frameHead[5]=data_size%0x100;frameHead[4]=data_size/0x100;//发送头+数据+尾socket->write(frameHead,7);socket->write(data);socket->write(frameTail,2);
}

对于数据的解析，校验帧头帧长帧尾（这里偷懒没有设计校验字段）之后，通过帧类型字段分别处理。以接收端为例：

//dataTemp为QByteArray成员变量
void ServerOperate::operateReceiveData(const QByteArray &data)
{static QByteArray frame_head=QByteArray(frameHead,4);//这里只是简单的处理，所以用了QByteArray容器做缓存dataTemp+=data;//处理数据while(true){//保证以帧头为起始while(!dataTemp.startsWith(frame_head)&&dataTemp.size()>4){dataTemp.remove(0,1); //左边移除一字节}//小于最小帧长if(dataTemp.size()<7+2)return;//取数据段长度，这里没有判断长度有效性const int data_size=uchar(dataTemp[4])*0x100+uchar(dataTemp[5]);if(dataTemp.size()<7+2+data_size)return;//帧尾不一致，无效数据--这里懒得写校验位了if(memcmp(dataTemp.constData()+7+data_size,frameTail,2)!=0){dataTemp.clear();return;}//取数据类型const char type=dataTemp[6];switch(type){case 0x01: //开始发送数据//do somethingbreak;case 0x02: //数据传输//do somethingbreak;case 0x03: //发送数据完成//do somethingbreak;case 0x04: //客户端取消发送//do somethingbreak;default: break;}//移除处理完的字节dataTemp.remove(0,7+2+data_size);}
}

目前想到的一些待改进的地方：

帧没有数据校验字段
没有流量控制
没有错误数据段重发机制
没有确认返回超时机制
没有流程状态记录，如果当前正在发送却收到开始发送的错误命令，就乱套了

2.示例代码

完整代码链接（TcpFileTransfer 子项目）：

https://github.com/gongjianbo/HelloQtNetwork

运行效果：

主要实现代码（只贴了 TCP 处理部分，Ui 没贴）：

#ifndef CLIENTOPERATE_H
#define CLIENTOPERATE_H#include <QObject>
#include <QMutex>
#include <QMutexLocker>
#include <QTcpSocket>
#include <QHostAddress>
#include <QFile>
#include <QTimer>//客户端socket处理--客户端作为发送
//帧没有数据校验字段
//没有流量控制
//没有错误数据段重发机制
//没有确认返回超时机制
//没有流程状态记录，如果当前正在发送却收到开始发送的错误命令，就乱套了
class ClientOperate : public QObject
{Q_OBJECT
public:explicit ClientOperate(QObject *parent = nullptr);~ClientOperate();//get/set 文件路径、连接状态等变量，使用了互斥锁QString getFilePath() const;void setFilePath(const QString &path);bool isConnected() const;void setConnected(bool connected);signals://操作记录发送到ui显示void logMessage(const QString &msg);//连接状态改变void connectStateChanged(bool isConnect);//接收进度0-100void progressChanged(int value);public slots://连接void connectTcp(const QString &address,quint16 port);//断开连接void disconnectTcp();//传输文件void startFileTransfer();//取消文件传输void cancelFileTransfer();private://初始化void initOperate();//把槽对应的实际操作分离出来是为了复用，这样便于组合void doDisconnect();void doCloseFile();void doCancel();void sendData(char type,const QByteArray &data);void sendFile(const char *data,int size);void operateReceiveData(const QByteArray &data);private://用来锁文件路径、连接状态等mutable QMutex dataMutex;//文件存储路径QString filePath;//地址和端口QString address;quint16 port;//连接状态bool connectState = false;//套接字QTcpSocket *socket = nullptr;//文件操作QFile *file = nullptr;//发送数据的定时器QTimer *timer = nullptr;//发送的字节数，因为Qt接口是int64，本来想用无符号类型qint64 sendSize=0;//文件大小qint64 fileSize=0;//接收数据的缓存，实际操作时还是用char*好点QByteArray dataTemp;//读取文件到缓冲区char fileBuffer[4096]={0};//帧头+长度+类型char frameHead[7] = { 0x0F, (char)0xF0, 0x00, (char)0xFF, 0x00, 0x00, 0x00 };//帧尾char frameTail[2] = { 0x0D, 0x0A };
};#endif // CLIENTOPERATE_H

#include "ClientOperate.h"#include <QFileInfo>ClientOperate::ClientOperate(QObject *parent): QObject(parent)
{initOperate();
}ClientOperate::~ClientOperate()
{doDisconnect();
}QString ClientOperate::getFilePath() const
{QMutexLocker locker(&dataMutex);return filePath;
}void ClientOperate::setFilePath(const QString &path)
{QMutexLocker locker(&dataMutex);filePath=path;
}bool ClientOperate::isConnected() const
{QMutexLocker locker(&dataMutex);return connectState;
}void ClientOperate::setConnected(bool connected)
{QMutexLocker locker(&dataMutex);connectState=connected;
}void ClientOperate::connectTcp(const QString &address, quint16 port)
{if(socket->state()==QAbstractSocket::UnconnectedState){//连接服务器socket->connectToHost(QHostAddress(address),port);}else{emit logMessage("socket->state() != QAbstractSocket::UnconnectedState");}
}void ClientOperate::disconnectTcp()
{doDisconnect();
}void ClientOperate::startFileTransfer()
{//之前如果打开了先释放doCloseFile();if(!socket->isValid())return;const QString file_path=getFilePath();//无效路径if(file_path.isEmpty() || !QFile::exists(file_path)){emit logMessage("无效的文件路径"+file_path);return;}file=new QFile(this);file->setFileName(file_path);//打开失败if(!file->open(QIODevice::ReadOnly)){doCloseFile();emit logMessage("打开文件失败"+file_path);return;}sendSize=0;fileSize=file->size();if(fileSize<0)fileSize=0;//大小高位字节顺序在前char file_size[4]={0};const quint64 data_size=fileSize; //有符号转无符号，会被截断file_size[3]=data_size>>0%0x100;file_size[2]=data_size>>8%0x100;file_size[1]=data_size>>16%0x100;file_size[0]=data_size>>24;//把文件大小和文件名发送给服务端，然后等待确认命令的返回QFileInfo info(file_path);sendData(0x01,QByteArray(file_size,4)+info.fileName().toUtf8());
}void ClientOperate::cancelFileTransfer()
{//关闭文件doCancel();//发送停止传输指令sendData(0x04,QByteArray());
}void ClientOperate::initOperate()
{socket=new QTcpSocket(this);//收到数据，触发readyReadconnect(socket,&QTcpSocket::readyRead,[this]{//没有可读的数据就返回if(socket->bytesAvailable()<=0)return;//读取数据operateReceiveData(socket->readAll());});//连接状态改变connect(socket,&QTcpSocket::connected,[this]{setConnected(true);emit connectStateChanged(true);emit logMessage(QString("已连接服务器 [%1:%2]").arg(socket->peerAddress().toString()).arg(socket->peerPort()));});connect(socket,&QTcpSocket::disconnected,[this]{setConnected(false);emit connectStateChanged(false);emit logMessage(QString("与服务器连接已断开 [%1:%2]").arg(socket->peerAddress().toString()).arg(socket->peerPort()));});timer=new QTimer(this);//通过定时器来控制数据发送connect(timer,&QTimer::timeout,[this]{if(!socket->isValid()){doCancel();emit logMessage("Socket不可操作，发送终止");return;}if(!file||!file->isOpen()){doCancel();emit logMessage("文件操作失败，发送终止");return;}const qint64 read_size=file->read(fileBuffer,4096);//socket->write(fileBuffer,read_size);sendFile(fileBuffer,read_size);sendSize+=read_size;file->seek(sendSize);if(!socket->waitForBytesWritten()){doCancel();emit logMessage("文件发送超时，发送终止");return;}//避免除零if(fileSize>0){emit progressChanged(sendSize*100/fileSize);}if(sendSize>=fileSize){doCancel();emit logMessage("文件发送完成");emit progressChanged(100);sendData(0x03,QByteArray());return;}});
}void ClientOperate::doDisconnect()
{//断开socket连接，释放资源socket->abort();doCloseFile();
}void ClientOperate::doCloseFile()
{if(file){file->close();delete file;file=nullptr;}
}void ClientOperate::doCancel()
{timer->stop();if(file){//关闭文件doCloseFile();}
}void ClientOperate::sendData(char type,const QByteArray &data)
{//传输协议//帧结构：帧头4+帧长2+帧类型1+帧数据N+帧尾2（没有校验段，懒得写）//帧头：4字节定值 0x0F 0xF0 0x00 0xFF//帧长：2字节数据段长度值 arr[4]*0x100+arr[5] 前面为高位后面为低位//帧类型：1字节//- 0x01 准备发送文件，后跟四字节文件长度和N字节utf8文件名，长度计算同帧长一样前面为高位后面为低位//- 0x02 文件数据//- 0x03 发送结束//- 0x04 取消发送//（服务端收到0x01 0x03开始和结束发送两个命令要进行应答，回同样的命令码无数据段）//帧尾：2字节定值 0x0D 0x0Aif(!socket->isValid())return;frameHead[6]=type;const quint64 data_size=data.count();frameHead[5]=data_size%0x100;frameHead[4]=data_size/0x100;//发送头+数据+尾socket->write(frameHead,7);socket->write(data);socket->write(frameTail,2);
}void ClientOperate::sendFile(const char *data, int size)
{if(!socket->isValid())return;frameHead[6]=(char)0x02;const quint64 data_size=size;frameHead[5]=data_size%0x100;frameHead[4]=data_size/0x100;//发送头+数据+尾socket->write(frameHead,7);socket->write(data,size);socket->write(frameTail,2);
}void ClientOperate::operateReceiveData(const QByteArray &data)
{static QByteArray frame_head=QByteArray(frameHead,4);//这里只是简单的处理，所以用了QByteArray容器做缓存dataTemp+=data;//处理数据while(true){//保证以帧头为起始while(!dataTemp.startsWith(frame_head)&&dataTemp.size()>4){dataTemp.remove(0,1); //左边移除一字节}//小于最小帧长if(dataTemp.size()<7+2)return;//取数据段长度，这里没有判断长度有效性const int data_size=uchar(dataTemp[4])*0x100+uchar(dataTemp[5]);if(dataTemp.size()<7+2+data_size)return;//帧尾不一致，无效数据--这里懒得写校验位了if(memcmp(dataTemp.constData()+7+data_size,frameTail,2)!=0){dataTemp.clear();return;}//取数据类型const char type=dataTemp[6];switch(type){case 0x01: //开始发送数据应答timer->start(0);emit logMessage("服务器已准备号接收数据，开始发送");break;case 0x03: //发送数据完成应答{//1成功，0失败const bool result=(dataTemp[7]==(char)0x01);emit logMessage(QString("服务器文件接收完毕，发送")+(result?"成功":"失败"));}break;case 0x04: //服务端取消发送doCancel();emit logMessage("服务器取消发送，发送终止");break;default: break;}//移除处理完的字节dataTemp.remove(0,7+2+data_size);}
}

#ifndef SERVEROPERATE_H
#define SERVEROPERATE_H#include <QObject>
#include <QMutex>
#include <QMutexLocker>
#include <QTcpServer>
#include <QTcpSocket>
#include <QHostAddress>
#include <QFile>//服务端socket处理--服务端作为接收
class ServerOperate : public QObject
{Q_OBJECT
public:explicit ServerOperate(QObject *parent = nullptr);~ServerOperate();//get/set 文件路径、监听状态等变量，使用了互斥锁QString getFilePath() const;void setFilePath(const QString &path);bool isListening() const;signals://操作记录发送到ui显示void logMessage(const QString &msg);//服务端监听状态void listenStateChanged(bool isListen);//接收进度0-100void progressChanged(int value);public slots://server监听void listen(const QString &address,quint16 port);//server取消监听void dislisten();//取消文件传输void cancelFileTransfer();private://初始化void initOperate();//把槽对应的实际操作分离出来是为了复用，这样便于组合void doDislisten();void doCloseFile();void doCancel();bool readyReceiveFile(qint64 size,const QString &filename);void onReceiveFile(const char *data,qint64 size);void sendData(char type,const QByteArray &data);void operateReceiveData(const QByteArray &data);private://用来锁文件路径、监听状态等变量mutable QMutex dataMutex;//文件存储路径QString filePath;//地址和端口QString address;quint16 port;//套接字，本demo只允许一个客户端连接QTcpServer *server = nullptr;QTcpSocket *socket = nullptr;//文件操作QFile *file = nullptr;//文件长度qint64 fileSize = 0;//已接收文件长度qint64 receiveSize = 0;//接收缓存，实际操作时还是用char*好点QByteArray dataTemp;//帧头+长度+类型char frameHead[7] = { 0x0F, (char)0xF0, 0x00, (char)0xFF, 0x00, 0x00, 0x00 };//帧尾char frameTail[2] = { 0x0D, 0x0A };
};#endif // SERVEROPERATE_H

#include "ServerOperate.h"#include <QApplication>ServerOperate::ServerOperate(QObject *parent): QObject(parent)
{initOperate();
}ServerOperate::~ServerOperate()
{dislisten();
}QString ServerOperate::getFilePath() const
{QMutexLocker locker(&dataMutex);return filePath;
}void ServerOperate::setFilePath(const QString &path)
{QMutexLocker locker(&dataMutex);filePath=path;
}bool ServerOperate::isListening() const
{QMutexLocker locker(&dataMutex);//这个锁没啥用，毕竟设置不是我控制的，待修改return server->isListening();
}void ServerOperate::listen(const QString &address, quint16 port)
{if(server->isListening())doDislisten();//启动监听const bool result=server->listen(QHostAddress(address),port);emit listenStateChanged(result);emit logMessage(result?"服务启动成功":"服务启动失败");
}void ServerOperate::dislisten()
{doDislisten();emit listenStateChanged(false);emit logMessage("服务关闭");
}void ServerOperate::cancelFileTransfer()
{//关闭文件doCancel();//发送停止传输指令sendData(0x04,QByteArray());
}void ServerOperate::initOperate()
{server=new QTcpServer(this);//监听到新的客户端连接请求connect(server,&QTcpServer::newConnection,this,[this]{//如果有新的连接就取出while(server->hasPendingConnections()){//nextPendingConnection返回下一个挂起的连接作为已连接的QTcpSocket对象QTcpSocket *new_socket=server->nextPendingConnection();emit logMessage(QString("新的客户端连接 [%1:%2]").arg(new_socket->peerAddress().toString()).arg(new_socket->peerPort()));//demo只支持一个连接，多余的释放掉if(socket){new_socket->abort();new_socket->deleteLater();emit logMessage("目前已有客户端连接，新连接已释放");continue;}else{socket=new_socket;}//收到数据，触发readyReadconnect(socket,&QTcpSocket::readyRead,[this]{//没有可读的数据就返回if(socket->bytesAvailable()<=0)return;//读取数据operateReceiveData(socket->readAll());});//连接断开，销毁socket对象connect(socket,&QTcpSocket::disconnected,[this]{emit logMessage(QString("客户端连接已断开 [%1:%2]").arg(socket->peerAddress().toString()).arg(socket->peerPort()));socket->deleteLater();socket=nullptr;});}});
}void ServerOperate::doDislisten()
{//关闭服务，断开socket连接，释放资源server->close();if(socket){socket->abort();}if(file){file->close();}
}void ServerOperate::doCloseFile()
{if(file){file->close();delete file;file=nullptr;}
}void ServerOperate::doCancel()
{if(file){//关闭文件doCloseFile();}
}bool ServerOperate::readyReceiveFile(qint64 size, const QString &filename)
{//重置状态fileSize=size;receiveSize=0;if(file){doCloseFile();}//创建qfile用于写文件file=new QFile(this);QString file_path=getFilePath();if(file_path.isEmpty())file_path=QApplication::applicationDirPath();file->setFileName(file_path+"/"+filename);//Truncate清掉原本内容if(!file->open(QIODevice::WriteOnly)){emit logMessage("创建文件失败，无法进行接收"+file->fileName());return false;}emit logMessage("创建文件成功，准备接收"+file->fileName());return true;
}void ServerOperate::onReceiveFile(const char *data, qint64 size)
{if(!file||!file->isOpen()){doCancel();//发送停止传输指令sendData(0x04,QByteArray());emit logMessage("文件操作失败，取消接收");return;}if(size>0){const qint64 write_size = file->write(data,size);//感觉这个waitForBytesWritten没啥用啊if(write_size!=size && !file->waitForBytesWritten(3000)){doCancel();//发送停止传输指令sendData(0x04,QByteArray());emit logMessage("文件写入超时，取消接收");return;}}receiveSize+=size;//避免除零if(fileSize>0){emit progressChanged(receiveSize*100/fileSize);}if(receiveSize>=fileSize){doCancel();emit logMessage("文件接收完成");emit progressChanged(100);return;}
}void ServerOperate::sendData(char type, const QByteArray &data)
{//传输协议//帧结构：帧头4+帧长2+帧类型1+帧数据N+帧尾2（没有校验段，懒得写）//帧头：4字节定值 0x0F 0xF0 0x00 0xFF//帧长：2字节数据段长度值 arr[4]*0x100+arr[5] 前面为高位后面为低位//帧类型：1字节//- 0x01 准备发送文件，后跟四字节文件长度和N字节utf8文件名，长度计算同帧长一样前面为高位后面为低位//- 0x02 文件数据//- 0x03 发送结束//- 0x04 取消发送//（服务端收到0x01 0x03开始和结束发送两个命令要进行应答，回同样的命令码无数据段）//帧尾：2字节定值 0x0D 0x0Aif(!socket->isValid())return;frameHead[6]=type;const quint64 data_size=data.count();frameHead[5]=data_size%0x100;frameHead[4]=data_size/0x100;//发送头+数据+尾socket->write(frameHead,7);socket->write(data);socket->write(frameTail,2);
}void ServerOperate::operateReceiveData(const QByteArray &data)
{static QByteArray frame_head=QByteArray(frameHead,4);//这里只是简单的处理，所以用了QByteArray容器做缓存dataTemp+=data;//处理数据while(true){//保证以帧头为起始while(!dataTemp.startsWith(frame_head)&&dataTemp.size()>4){dataTemp.remove(0,1); //左边移除一字节}//小于最小帧长if(dataTemp.size()<7+2)return;//取数据段长度，这里没有判断长度有效性const int data_size=uchar(dataTemp[4])*0x100+uchar(dataTemp[5]);if(dataTemp.size()<7+2+data_size)return;//帧尾不一致，无效数据--这里懒得写校验位了if(memcmp(dataTemp.constData()+7+data_size,frameTail,2)!=0){dataTemp.clear();return;}//取数据类型const char type=dataTemp[6];switch(type){case 0x01: //开始发送数据{//这里也可以做个弹框，询问是否接收数据doCloseFile();if(data_size<5){//无效帧，没有长度和文件名break;}//解析长度和文件名qint64 file_size=0;//file_size+=uchar(dataTemp[7]);//file_size<<=8;//file_size+=uchar(dataTemp[8]);//file_size<<=8;//file_size+=uchar(dataTemp[9]);//file_size<<=8;//file_size+=uchar(dataTemp[10]);file_size=uchar(dataTemp[7])*0x1000000+uchar(dataTemp[8])*0x10000+uchar(dataTemp[9])*0x100+uchar(dataTemp[10]);QString file_name=QString::fromUtf8(dataTemp.constData()+7+4,data_size-4);if(readyReceiveFile(file_size,file_name)){emit logMessage("准备好接收客户端文件");//应答sendData(0x01,QByteArray());}else{emit logMessage("准备接收客户端文件失败");}}break;case 0x02: //数据传输onReceiveFile(dataTemp.constData()+7,data_size);break;case 0x03: //发送数据完成{doCloseFile();emit logMessage("客户端文件发送完毕");//应答sendData(0x03,QByteArray(1,(char)((receiveSize==fileSize)?0x01:0x00)));}break;case 0x04: //客户端取消发送doCancel();emit logMessage("客户端取消发送，发送终止");break;default: break;}//移除处理完的字节dataTemp.remove(0,7+2+data_size);}
}