QT的tcp通信和本地通信（QTcpSocket和QLocalSocket）

在qt中TCP通信是使用QTcpSocket和QTcpServer来实现的。
本地通信是使用QLocalSocket和QlocalServer来实现的。

tcp通信：
服务器：
1、创建服务器对象QTcpServer。
2、配置服务器对象的信号槽newConnection()，捕获客户端连接。
3、listen监听客户端（监听参数ip和端口）。
4、如果有客户端连接，创建QTcpSocket来获取客户端对象。
5、配置客户端对象的信号槽readyRead()，捕获客户端发送数据。
客户端：
1、创建客户端对象QTcpSocket。
2、connectToHost连接服务器（参数IP和端口）。
3、配置客户端对象的信号槽readyRead()，捕获服务器发送的数据。

本地通信
服务器：
1、创建服务器对象QLocalSocket。
2、配置服务器对象的信号操newConnection()，捕获客户端连接。
3、listen监听客户端（监听参数键值）。
4、如果有客户端连接，创建QLocalSocket来获取客户端对象。
5、配置客户端对象的信号槽readyRead()，捕获客户端发送数据。
客户端：
1、创建客户端对象QLocalSocket。
2、connctToserver连接服务器（参数键值和QIODevice）。
3、配置客户端对象的信号槽readyRead()，捕获服务器发送的数据。

上面两组流程是不是特别相似，唯一的区别就是tcp监听的ip和端口，连接的ip和端口，本地通信监听的键值，连接的键值。其实除了这个不一样外还有一个函数removeserver删除已有的连接。这个TCP没有，但是本地通信有。

查看完整代码
参考实例：
服务器：

#include "widget.h"
#include "ui_widget.h"
#include <QDebug>
#include <QMessageBox>

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

    //创建本地服务器对象
    m_server = new QLocalServer(this);
    //捕获客户端连接
    connect(m_server,SIGNAL(newConnection()),this,SLOT(slotnewConnection()));

    //创建tcp服务器对象
    m_tcpserver = new QTcpServer(this);
    //捕获客户端连接
    connect(m_tcpserver,SIGNAL(newConnection()),this,SLOT(slottcpNewConnection()));
}

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

//开启监听状态
void Widget::on_locallistenbtn_clicked()
{
    QLocalServer::removeServer("yjd");    //删除已有的连接
    m_server->listen("yjd");              //监听客户端
}

//捕获客户端连接
void Widget::slotnewConnection()
{
    QMessageBox::information(this,"title","本地服务器有新连接");
    if (m_server->hasPendingConnections())
    {
        //获取新的连接对象
        m_socket = m_server->nextPendingConnection();
        //捕获客户端发送数据的信号
        connect(m_socket,SIGNAL(readyRead()),this,SLOT(slotreadData()));
        //捕获客户端断开的信号
        connect(m_socket,SIGNAL(disconnected()),this,SLOT(slotdisconnect()));
        //捕获连接中的错误信息
        connect(m_socket,SIGNAL(error(QLocalSocket::LocalSocketError)),this,SLOT(sloterror(QLocalSocket::LocalSocketError)));
        m_socketlist.append(m_socket);
    }
}

//客户端断开连接
void Widget::slotdisconnect()
{
    QMessageBox::information(this,"title","客户端断开连接");
}

//连接中的错误信息
void Widget::sloterror(QLocalSocket::LocalSocketError error)
{
    QMessageBox::warning(this,"错误",QString::number(error));
}

//接收客户端发送的数据
void Widget::slotreadData()
{
    QLocalSocket* socket = qobject_cast<QLocalSocket*>(sender());
    QString val = socket->readAll();
    ui->local_textEdit->append("接收消息："+val);
}

//发送信息
void Widget::on_sendlocalbtn_clicked()
{
    //向所有客户端发送信息
    for (int i = 0; i < m_socketlist.size(); ++i)
        m_socketlist.at(i)->write(ui->local_lineEdit->text().toLocal8Bit());
}

//关闭服务器
void Widget::on_closelocallistenbtn_clicked()
{
    //销毁所有接收到的客户端对象和信号槽
    for (int i = 0; i < m_socketlist.size(); ++i)
    {
        disconnect(m_socketlist.at(i),SIGNAL(readyRead()),this,SLOT(slotreadData()));
        disconnect(m_socketlist.at(i),SIGNAL(disconnected()),this,SLOT(slotdisconnect()));
        disconnect(m_socketlist.at(i),SIGNAL(error(QLocalSocket::LocalSocketError)),this,SLOT(sloterror(QLocalSocket::LocalSocketError)));
        m_socketlist.at(i)->abort();                  //断开连接
        m_socketlist.at(i)->deleteLater();
    }
    //关闭服务器
    m_server->close();
    m_socketlist.clear();
}

/*------------------------------------------tcp---------------------------------------------*/
//开启监听
void Widget::on_listentcpbtn_clicked()
{
    m_tcpserver->listen(QHostAddress::Any,8888);
}

void Widget::slottcpNewConnection()
{
    QMessageBox::information(this,"title","tcp服务器有新连接");
    //获取新的连接对象
    m_tcpsocket = m_tcpserver->nextPendingConnection();
    //捕获客户端发送数据的信号
    connect(m_tcpsocket,SIGNAL(readyRead()),this,SLOT(slotTcpreadData()));
    //捕获客户端断开的信号
    connect(m_tcpsocket,SIGNAL(disconnected()),this,SLOT(slottcpdisconnect()));
    //捕获连接中的错误信息
    connect(m_tcpsocket,SIGNAL(error(QAbstractSocket::SocketError)),this,SLOT(slottcperror(QAbstractSocket::SocketError)));

    m_tcpsocketlist.append(m_tcpsocket);
}

//接收客户端发送的数据
void Widget::slotTcpreadData()
{
    QTcpSocket* socket = qobject_cast<QTcpSocket*>(sender());
    QString val = socket->readAll();
    ui->tcp_textEdit->append("接收消息："+val);
}

//发送信息
void Widget::on_sendtcpbtn_clicked()
{
    //向所有客户端发送信息
    for (int i = 0; i < m_tcpsocketlist.size(); ++i)
        m_tcpsocketlist.at(i)->write(ui->tcp_lineEdit->text().toLocal8Bit());
}

//客户端断开连接
void Widget::slottcpdisconnect()
{
    QMessageBox::information(this,"title","客户端断开连接");
}

//连接中的错误信息
void Widget::slottcperror(QAbstractSocket::SocketError error)
{
    QMessageBox::warning(this,"错误",QString::number(error));
}

//关闭服务器
void Widget::on_closetcpbtn_clicked()
{
    //销毁所有接收到的客户端对象和信号槽
    for (int i = 0; i < m_tcpsocketlist.size(); ++i)
    {
        disconnect(m_tcpsocketlist.at(i),SIGNAL(readyRead()),this,SLOT(slotTcpreadData()));
        disconnect(m_tcpsocketlist.at(i),SIGNAL(disconnected()),this,SLOT(slottcpdisconnect()));
        disconnect(m_tcpsocketlist.at(i),SIGNAL(error(QAbstractSocket::SocketError)),this,SLOT(slottcperror(QAbstractSocket::SocketError)));
        m_tcpsocketlist.at(i)->abort();
        m_tcpsocketlist.at(i)->deleteLater();
    }
    //关闭服务器
    m_tcpserver->close();
    m_tcpsocketlist.clear();
}

客户端

#include "widget.h"
#include "ui_widget.h"
#include <QMessageBox>
#include <QDebug>

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

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


void Widget::on_openlocalbtn_clicked()
{
    m_local = new QLocalSocket(this);
    m_local->connectToServer("yjd",QIODevice::ReadWrite);                      //按照键值连接服务器
    connect(m_local,SIGNAL(readyRead()),this,SLOT(slotReadData()));
    connect(m_local,SIGNAL(disconnected()),this,SLOT(slotdisconnect()));
    connect(m_local,SIGNAL(error(QLocalSocket::LocalSocketError)),this,SLOT(sloterror(QLocalSocket::LocalSocketError)));

    m_locallist.append(m_local);
}

void Widget::slotdisconnect()
{
    QMessageBox::information(this,"title","服务端断开连接");
}


void Widget::sloterror(QLocalSocket::LocalSocketError error)
{
    QMessageBox::warning(this,"错误",QString::number(error));
}

void Widget::slotReadData()
{
    QLocalSocket* socket = qobject_cast<QLocalSocket*>(sender());
    QString val = socket->readAll();
    ui->local_textEdit->append("接受消息："+val);
}

void Widget::on_localsendbtn_clicked()
{
    for (int i = 0; i < m_locallist.size(); ++i)
    {
        m_locallist.at(i)->write(ui->local_lineEdit->text().toLocal8Bit());
    }
}

void Widget::on_closelocal_btn_clicked()
{
    for (int i = 0; i < m_locallist.size(); ++i)
    {
        disconnect(m_locallist.at(i),SIGNAL(readyRead()),this,SLOT(slotReadData()));
        disconnect(m_locallist.at(i),SIGNAL(disconnected()),this,SLOT(slotdisconnect()));
        disconnect(m_locallist.at(i),SIGNAL(error(QLocalSocket::LocalSocketError)),this,SLOT(sloterror(QLocalSocket::LocalSocketError)));
        m_locallist.at(i)->abort();                  //断开连接
        m_locallist.at(i)->deleteLater();
    }
    m_locallist.clear();
}

/*-----------------------------------tcp------------------------------------------*/
void Widget::on_opentcpbtn_clicked()
{
    m_tcpsocket = new QTcpSocket(this);
    connect(m_tcpsocket,SIGNAL(readyRead()),this,SLOT(slottcpReadData()));
    connect(m_tcpsocket,SIGNAL(disconnected()),this,SLOT(slottcpdisconnect()));
    connect(m_tcpsocket,SIGNAL(error(QAbstractSocket::SocketError)),this,SLOT(slottcperror(QAbstractSocket::SocketError)));
    m_tcpsocket->connectToHost("192.168.27.89",8888);
    m_tcpsocketlist.append(m_tcpsocket);
}

void Widget::on_closetcpbtn_clicked()
{
    for (int i = 0; i < m_tcpsocketlist.size(); ++i)
    {
        disconnect(m_tcpsocketlist.at(i),SIGNAL(readyRead()),this,SLOT(slottcpReadData()));
        disconnect(m_tcpsocketlist.at(i),SIGNAL(disconnected()),this,SLOT(slottcpdisconnect()));
        disconnect(m_tcpsocketlist.at(i),SIGNAL(error(QAbstractSocket::SocketError)),this,SLOT(slottcperror(QAbstractSocket::SocketError)));
        m_tcpsocketlist.at(i)->abort();
        m_tcpsocketlist.at(i)->deleteLater();
    }
    m_tcpsocketlist.clear();
}

void Widget::on_sendtcpbtn_clicked()
{
    for (int i = 0; i < m_tcpsocketlist.size(); ++i)
        m_tcpsocketlist.at(i)->write(ui->tcp_lineEdit->text().toLocal8Bit());
}

void Widget::slottcpReadData()
{
    QTcpSocket* socket = qobject_cast<QTcpSocket*>(sender());
    QString val = socket->readAll();
    ui->tcp_textEdit->append("接收消息："+val);
}

void Widget::slottcpdisconnect()
{
    QMessageBox::information(this,"title","服务端断开连接");
}

void Widget::slottcperror(QAbstractSocket::SocketError error)
{
    QMessageBox::warning(this,"错误",QString::number(error));
}