基于QTcpSocket和QTcpServer的Tcp通讯以及QDataStream序列化数据

最近要在QT下开发Tcp通讯，发送序列化数据以便于接收。

这里涉及到几个问题：

1.QTcpSocket、QTcpServer的通讯

2.QDataStream序列化数据

多的不说，直接上干货！！！

客户端：

tcpclient.h

 #ifndef TCPCLIENT_H
 #define TCPCLIENT_H

 #include <QMainWindow>
 #include <qt4/Qt/qtcpsocket.h>
 #include <Qt/qhostinfo.h>
 #include <QDataStream>
 #include <QtNetwork>

 struct Control_Motor
 {
     int length;
     int command;
     QString data;
 };

 class Motor
 {
 public:
     Motor(){}
     Motor(int speed,int accele_speed,int p_some)
     {
         m_speed = speed;
         m_accele_speed = accele_speed;
         m_p_some = p_some;
     }

 public:
     int getV(){return m_speed;}
     int getA(){return m_accele_speed;}
     int getP(){return m_p_some;}

     void setV(const int v){m_speed = v;}
     void setA(const int a){m_accele_speed = a;}
     void setP(const int p){m_p_some = p;}

 public:
     //friend QDataStream & operator <<(QDataStream &out,const Motor &motor);
     //friend QDataStream & operator >>(QDataStream &in,Motor &motor);
     /*
     friend QDataStream & operator <<(QDataStream &out,Motor &motor)
     {
         out << motor.m_speed<<motor.m_p_some<<motor.m_accele_speed;
         qDebug()<< motor.m_speed<<motor.m_p_some<<motor.m_accele_speed<<"Enter in this";
         return out;
     }
     */
 public:
     int m_speed;
     int m_accele_speed;
     int m_p_some;

 };

 namespace Ui {
 class TcpClient;
 }

 class TcpClient : public QMainWindow
 {
     Q_OBJECT

 public:
     explicit TcpClient(QWidget *parent = );
     ~TcpClient();

 private:
     Ui::TcpClient *ui;
     QTcpSocket *tcpClient;

 private slots:
     void slotConnect();
     void readMessage();
     void displayError(QAbstractSocket::SocketError);
     void sendMessage();

 public:
     Control_Motor control_Motor;

     Motor *m_motor;

 };

 #endif // TCPCLIENT_H 

tcpclient.cpp

 #include "tcpclient.h"
 #include "ui_tcpclient.h"
 #include <QFile>
 #include <QDataStream>

 QDataStream & operator<<(QDataStream &out,const Motor &motor)
 {
     //qDebug()<< motor.m_speed<<motor.m_p_some<<motor.m_accele_speed<<"Enter in";
     out << motor.m_speed<<motor.m_p_some<<motor.m_accele_speed;
     //qDebug()<< motor.m_speed<<motor.m_p_some<<motor.m_accele_speed<<"Enter in this";
     return out;
 }

 QDataStream &operator >>(QDataStream &in,Motor &motor)
 {
     int speed = ;
     int accele_speed =;
     int p_some = ;

     in >> speed >> p_some >> accele_speed;

     motor.setV(speed);
     motor.setP(p_some);
     motor.setA(accele_speed);

     return in;
 }
 Q_DECLARE_METATYPE(Motor)

 TcpClient::TcpClient(QWidget *parent) :
     QMainWindow(parent),
     ui(new Ui::TcpClient)
 {
     ui->setupUi(this);

     qRegisterMetaType<Motor>("Motor");

     tcpClient = new QTcpSocket(this);
     connect(ui->Connect_Btn,SIGNAL(clicked()),this,SLOT(slotConnect()));
     connect(ui->Send_Btn,SIGNAL(clicked()),this,SLOT(sendMessage()));
     connect(tcpClient, SIGNAL(readyRead()), this, SLOT(readMessage()));
     connect(tcpClient, SIGNAL(error(QAbstractSocket::SocketError)), this,
                 SLOT(displayError(QAbstractSocket::SocketError)));
 }

 TcpClient::~TcpClient()
 {
     delete ui;
 }

 void TcpClient::slotConnect()
 {
     //QString stringAddress = ui->ldt_IP->text();
     //QString stringPort = ui->ldt_Port->text();
     QString stringAddress = "192.168.154.128";
     QString stringPort = "";
     int port = stringPort.toInt();
     QHostAddress address;
     address.setAddress(stringAddress);
     tcpClient->abort();
     tcpClient->connectToHost(address,port);
     ui->Connect_Btn->setEnabled(false);
 }

 void TcpClient::readMessage()
 {

 }

 void TcpClient::displayError(QAbstractSocket::SocketError)
 {
    qDebug() << tcpClient->errorString();
 }

 void TcpClient::sendMessage()
 {
     QString stringMotor = ui->ldt_Motor->text();
     QString stringData = ui->ldt_data->text();
     control_Motor.command = stringMotor.toInt();
     int dataLength = stringData.length();
     control_Motor.length =  + dataLength;
     control_Motor.data = stringData;
     QString data = stringMotor+stringData;

     m_motor = new Motor(,,);

     //Motor m_motor(20,40,60);

     //用于暂存要发送的数据
     QByteArray block;
     //使用数据流写入数据
     QDataStream out(&block,QIODevice::WriteOnly);
     //设置数据流的版本，客户端和服务器端使用的版本要相同
     out.setVersion(QDataStream::Qt_4_6);
     out<<(quint32) ;
     //设置发送长度初始值为0
     //out << control_Motor.length<<control_Motor.command<<control_Motor.data;

     //qDebug() << control_Motor.length<<control_Motor.command<<control_Motor.data;
     //out
     out << control_Motor.command;
     qDebug()<<"Start out"<<endl;
     out << *m_motor;
     qDebug()<<"End out"<<endl;
     qDebug() << control_Motor.command<< m_motor->getA()<<m_motor->getP()<<m_motor->getV();
     //回到字节流起始位置
     out.device()->seek();
     //重置字节流长度
     //out << (quint16) (block.size()-sizeof(quint16));
     out << (quint32)(block.size()- sizeof(quint32));
     qDebug() << "block.size()"<<block.size();

     //往套接字缓存中写入数据，并发送
     tcpClient->write(block,block.size());
     tcpClient->disconnectFromHost();
     tcpClient->waitForDisconnected();

     block.resize();
     this->close();
     //tcpClient->write(data.toLatin1(),data.size());
 }

服务器端：

tcpserver.h

 ifndef TCPSERVER_H
 #define TCPSERVER_H

 #include <QMainWindow>
 #include <qt4/Qt/qhostinfo.h>
 #include "server.h"

 namespace Ui {
 class TcpServer;
 }

 class TcpServer : public QMainWindow
 {
     Q_OBJECT

 public:
     explicit TcpServer(QWidget *parent = );
     ~TcpServer();

 private:
     Ui::TcpServer *ui;
     int port;
     Server *server;

 protected slots:
     void slotCreateServer();
     void updateServer(QString,int);

 };

 #endif // TCPSERVER_H

tcpserver.cpp

 #include "tcpserver.h"
 #include "ui_tcpserver.h"
 #include <QtNetwork/QNetworkInterface>

 TcpServer::TcpServer(QWidget *parent) :
     QMainWindow(parent),
     ui(new Ui::TcpServer)
 {
     ui->setupUi(this);
     port = ;
     QString address = QNetworkInterface::allAddresses().first().toString();
     QList<QHostAddress> list2 = QNetworkInterface::allAddresses();
     foreach (QHostAddress address, list2)
     {
         if(address.protocol() == QAbstractSocket::IPv4Protocol)
             ui->ldt_IP->setText(address.toString());
     }
     ui->ldt_Port->setText(QString::number(port));
     connect(ui->Connect_Btn,SIGNAL(clicked()),this,SLOT(slotCreateServer()));
 }

 TcpServer::~TcpServer()
 {
     delete ui;
 }

 void TcpServer::slotCreateServer()
 {
     server = new Server(this,port);
     connect(server,SIGNAL(updateServer(QString,int)),this,SLOT(updateServer(QString,int)));
     ui->Connect_Btn->setEnabled(false);
 }

 void TcpServer::updateServer(QString msg, int length)
 {
     ui->lwt_Text->addItem(msg.left(length));
 }

server.h

 #ifndef SERVER_H
 #define SERVER_H

 #include <qt4/Qt/qtcpserver.h>
 #include <qt4/Qt/qtcpsocket.h>

 struct Control_Motor
 {
     int length;
     int command;
     QString data;
 };

 class Motor
 {
 public:
     Motor(int speed,int accele_speed,int p_some)
     {
         m_speed = speed;
         m_accele_speed = accele_speed;
         m_p_some = p_some;
     }

     Motor(){m_speed = ;}

 public:
     int getV(){return m_speed;}
     int getA(){return m_accele_speed;}
     int getP(){return m_p_some;}

     void setV(const int v){m_speed = v;}
     void setA(const int a){m_accele_speed = a;}
     void setP(const int p){m_p_some = p;}

 private:
     int m_speed;
     int m_accele_speed;
     int m_p_some;

 };

 class Server : public QTcpServer
 {
     Q_OBJECT

 public:
     Server(QObject *parents=,int port=);
     QList<QTcpSocket*>TcpClientSocketList;
     QTcpSocket *tcpClientSocket;
 signals:
     void updateServer(QString,int);

 public slots:
     void slotUpdateClient(QString,int);
     void slotDisconnect(int);
 //    void slotnewconnection();
 protected:
     void incomingConnection(int socketDescriptor);

 signals:
     void updateClients(QString,int);
     void disconnected(int);

 protected slots:
     void dataReceive();
     void slotDisconnected();

 public:
     Control_Motor control_motor;
     Motor m_mtor;
 };

 #endif // SERVER_H

server.cpp

 #include "server.h"

 QDataStream &operator <<(QDataStream &out,Motor &motor)
 {
     out << motor.getV()<<motor.getP()<<motor.getA();
     return out;
 }

 QDataStream &operator >>(QDataStream &in,Motor &motor)
 {
     int speed = motor.getV();
     int accele_speed =motor.getA();
     int p_some = motor.getP();

     in >> speed >> p_some >> accele_speed;

     motor.setV(speed);
     motor.setP(p_some);
     motor.setA(accele_speed);

     return in;
 }

 Server::Server(QObject *parent,int port) :
     QTcpServer(parent)
 {
     this->listen(QHostAddress::Any,port);
 }

 void Server::incomingConnection(int socketDescriptor)
 {
     tcpClientSocket = new QTcpSocket(this);
     //tcpClientSocket = this->nextPendingConnection();
     tcpClientSocket->setSocketDescriptor(socketDescriptor);
     TcpClientSocketList.append(tcpClientSocket);
     //connect(this,SIGNAL(updateClients(QString,int)),this,SLOT(slotUpdateClient(QString,int)));
     //connect(this,SIGNAL(updateClients(QString,int)),this,SLOT(slotUpdateClient(QString,int)));
     connect(this,SIGNAL(disconnected(int)),this,SLOT(slotDisconnect(int)));
     connect(tcpClientSocket,SIGNAL(readyRead()),this,SLOT(dataReceive()));
     connect(tcpClientSocket,SIGNAL(disconnected()),this,SLOT(slotDisconnected()));
     //connect(tcpClientSocket,SIGNAL(disconnected()),tcpClientSocket,SLOT(deleteLater()));

 }
 void Server::slotUpdateClient(QString msg,int length)
 {
     emit updateServer(msg,length);
     for (int i=;i<TcpClientSocketList.count();i++)
     {
         QTcpSocket *item=TcpClientSocketList.at(i);
         if (item->write(msg.toLatin1(),length)!=length)
             continue;
     }
 }
 void Server::slotDisconnect(int socketDescriptor)
 {
     qDebug()<<__FILE__<<__FUNCTION__<<__LINE__<<endl;
     for (int i=;i<TcpClientSocketList.count();i++)
      if (TcpClientSocketList.at(i)->socketDescriptor()==socketDescriptor)
      {
            TcpClientSocketList.removeAt(i);
             return;
      }
 }

 void Server::dataReceive()
 {
     qDebug()<<"QQWQW11111111111111";
     //quint32 size = 0;
     quint32 nextBlockSize = ;
     qDebug()<<"TcpClientSocketList.count()"<<TcpClientSocketList.count();
     //for(int i = 0; i < TcpClientSocketList.count();i++)
     //{
         QDataStream in(tcpClientSocket);
         in.setVersion(QDataStream::Qt_4_6);
        if(nextBlockSize == )
        {
            if(tcpClientSocket->bytesAvailable()<sizeof(quint32))
            {
                //break;
                return;
            }
            in>>nextBlockSize;
            qDebug()<<nextBlockSize;
        }
        if(nextBlockSize==0xFFFF)
        {
            //break;
            return;
        }
        if(tcpClientSocket->bytesAvailable()<nextBlockSize)
        {
            //break;
            return;
        }

        //in>>control_motor.length>>control_motor.command>>control_motor.data;

        //qDebug()<<control_motor.length<<control_motor.command<<control_motor.data;
        in >>control_motor.command >> m_mtor;
        qDebug()<<control_motor.command<< m_mtor.getA()<<m_mtor.getP()<<m_mtor.getV();

        //ui->SN_lineEdit_2->setText(QString("%1").arg(message_rev.SN));
        //ui->IP_lineEdit->setText(message_rev.IP);
        //ui->STATE_lineEdit_3->setText(message_rev.Condition);
     //}
 }

 void Server::slotDisconnected()
 {
     qDebug()<<__FILE__<<__FUNCTION__<<__LINE__<<endl;
     emit disconnected(tcpClientSocket->socketDescriptor());
 }

在这里要特别说明一下，在此遇到的几个问题，希望能帮到大家，也提醒一下自己。

1.在TcpClient.pro，TcpServer.pro里一定要注意加上QT += network，不然编译的时候QNetworkInterface、QHostAddress这些地方会报错误。

2.在QDataStream重载自定义的类的时候，一开始把重载写在.h文件里编译的时候总是报Tcp_DataStream/TcpServer/server.h:49: error: multiple definition of `operator<<(QDataStream&, Motor&)'这个错误，说实话这个问题真的困扰了我很久，然后把重载函数放到.cpp文件里,编译通过，简直是要命

3.QDataStream的nextBlock读取到的长度为发送的数据的长度（而不是整个包的长度out << (quint32)(block.size()- sizeof(quint32));），如果直接写out << (quint32)(block.size()），读的时候数据将会不正常。

4.重载的时候一定要正确。