2、TCP服务器搭建：QTcpServer的使用、监听与接受连接、信号与槽机制

好，咱们今天来聊聊TCP服务器搭建。说实话，很多初学者一上来就写客户端，觉得服务器端太复杂。其实不然。服务器端的核心逻辑反而更清晰——你只需要做好三件事：创建服务器、监听端口、处理连接。就这么简单。

我个人习惯把QTcpServer比作一个「前台接待员」。它不负责具体聊天，只负责把来访的客人（客户端）引导到对应的房间（QTcpSocket）。这个比喻你记住，后面就好理解了。

2.1 QTcpServer的核心职责

QTcpServer是Qt网络模块里的核心类。它的任务很纯粹：

• 在指定IP和端口上开启监听
• 接收来自客户端的连接请求
• 为每个新连接创建一个QTcpSocket实例
• 通过信号通知你：嘿，有人来了！

说白了，它就是个「连接分发器」。它自己不收发数据，只负责把连接交给你处理。

2.2 搭建服务器的标准流程

我带你走一遍标准流程。代码不多，但每一步都有讲究。

2.2.1 创建服务器对象

// 在头文件中声明
QTcpServer *m_server;

// 在构造函数中创建
m_server = new QTcpServer(this);

这里有个小细节：this作为父对象。嗯，这很重要。Qt的对象树机制会自动管理内存，你不需要手动delete。我在项目中见过有人忘了传父对象，结果程序退出时内存泄漏——虽然不大，但看着难受。

2.2.2 监听端口

// 监听所有网卡的8888端口
if (!m_server->listen(QHostAddress::Any, 8888)) {
    qDebug() << "服务器启动失败:" << m_server->errorString();
    return;
}
qDebug() << "服务器已启动，监听端口: 8888";

QHostAddress::Any表示监听所有网络接口。你想想看，如果你的服务器有多个IP地址（比如内网和外网），用Any就能同时接收来自所有网卡的连接。

我曾经踩过一个坑：在Linux下用QHostAddress::LocalHost监听，结果外网客户端死活连不上。排查了半天才发现是监听地址写死了。从那以后，我只要不是特殊需求，一律用Any。

2.2.3 连接信号与槽

这是最关键的一步。QTcpServer只有一个核心信号：newConnection()。当有客户端连接时，这个信号就会被触发。

// 连接信号与槽
connect(m_server, &QTcpServer::newConnection, 
        this, &MyServer::onNewConnection);

在槽函数里，你需要调用nextPendingConnection()来获取这个新连接的QTcpSocket对象：

void MyServer::onNewConnection()
{
    // 获取等待处理的连接
    QTcpSocket *clientSocket = m_server->nextPendingConnection();
    
    // 保存到列表（方便管理）
    m_clientList.append(clientSocket);
    
    qDebug() << "新客户端连接:" << clientSocket->peerAddress().toString();
    
    // 连接客户端的信号
    connect(clientSocket, &QTcpSocket::readyRead, 
            this, &MyServer::onReadyRead);
    connect(clientSocket, &QTcpSocket::disconnected, 
            this, &MyServer::onDisconnected);
}

这里有个容易忽略的点：nextPendingConnection()每次调用只返回一个连接。如果你在槽函数里只调用一次，但同一时刻有多个客户端连上来怎么办？Qt内部维护了一个等待队列，你每次调用都会取出一个。所以如果你需要批量处理，可以循环调用直到返回nullptr。

2.3 信号与槽机制的精髓

你可能会问：为什么Qt要用信号与槽？直接回调函数不行吗？

嗯，这里有个设计哲学的问题。回调函数是「你主动去问」，信号与槽是「它主动告诉你」。在服务器场景下，你根本不知道客户端什么时候发数据。用回调你得写死循环去轮询，用信号与槽你只需要坐着等通知就行。

我画了一张图，帮你理解整个流程：

你看这个流程，是不是很清晰？客户端发起连接，QTcpServer收到后发射信号，你的槽函数被调用，然后你取出socket开始处理。整个过程不需要你写一行轮询代码。

2.4 管理多个客户端连接

实际项目中，服务器通常要同时处理几十上百个客户端。你不能只保存一个socket。我建议用QList或QMap来管理：

// 用QMap保存，key可以是socket描述符或自定义ID
QMap<qintptr, QTcpSocket*> m_clients;

void MyServer::onNewConnection()
{
    QTcpSocket *socket = m_server->nextPendingConnection();
    m_clients.insert(socket->socketDescriptor(), socket);
    
    // 连接信号
    connect(socket, &QTcpSocket::readyRead, this, [this, socket]() {
        // 处理这个socket的数据
        QByteArray data = socket->readAll();
        qDebug() << "收到来自" << socket->peerAddress().toString() 
                 << "的数据:" << data;
    });
    
    connect(socket, &QTcpSocket::disconnected, this, [this, socket]() {
        // 客户端断开，清理资源
        m_clients.remove(socket->socketDescriptor());
        socket->deleteLater();
        qDebug() << "客户端断开连接";
    });
}

这里我用Lambda表达式代替了传统的槽函数。我个人比较喜欢这种方式，代码更紧凑，逻辑更集中。但如果你需要复用槽函数，还是建议写成独立的成员函数。

2.5 避坑指南

我做了这么多年Qt网络开发，总结几个常见坑：

• 端口被占用：程序崩溃后端口没释放，重启时listen失败。解决方案：在listen前先调用m_server->close()，或者设置SO_REUSEADDR选项。
• 忘记调用nextPendingConnection：newConnection信号触发了，但你没取走socket。下次再来新连接时，之前的socket还在队列里。结果就是连接错乱。
• 主线程阻塞：如果你在槽函数里做耗时操作（比如写数据库），整个服务器会卡住。建议用线程池或QtConcurrent处理。

我曾经在一个项目中，服务器上线后频繁出现客户端连接超时。查了两天才发现，是有人在onNewConnection里做了文件IO操作，导致事件循环被阻塞。从那以后，我定了个规矩：槽函数里只做轻量操作，重活扔给线程。

2.6 完整示例代码

最后，给你一个完整的服务器类骨架。你可以直接拿去用：

// myserver.h
#include <QTcpServer>
#include <QTcpSocket>
#include <QList>

class MyServer : public QObject
{
    Q_OBJECT
public:
    explicit MyServer(QObject *parent = nullptr);
    bool start(quint16 port);
    void stop();

private slots:
    void onNewConnection();
    void onReadyRead();
    void onDisconnected();

private:
    QTcpServer *m_server;
    QList<QTcpSocket*> m_clients;
};

// myserver.cpp
#include "myserver.h"
#include <QDebug>

MyServer::MyServer(QObject *parent) : QObject(parent)
{
    m_server = new QTcpServer(this);
    connect(m_server, &QTcpServer::newConnection, 
            this, &MyServer::onNewConnection);
}

bool MyServer::start(quint16 port)
{
    if (!m_server->listen(QHostAddress::Any, port)) {
        qDebug() << "启动失败:" << m_server->errorString();
        return false;
    }
    qDebug() << "服务器已启动，端口:" << port;
    return true;
}

void MyServer::stop()
{
    // 关闭所有客户端连接
    for (auto socket : m_clients) {
        socket->disconnectFromHost();
        socket->deleteLater();
    }
    m_clients.clear();
    m_server->close();
}

void MyServer::onNewConnection()
{
    QTcpSocket *socket = m_server->nextPendingConnection();
    m_clients.append(socket);
    
    connect(socket, &QTcpSocket::readyRead, 
            this, &MyServer::onReadyRead);
    connect(socket, &QTcpSocket::disconnected, 
            this, &MyServer::onDisconnected);
    
    qDebug() << "新连接:" << socket->peerAddress().toString();
}

void MyServer::onReadyRead()
{
    QTcpSocket *socket = qobject_cast<QTcpSocket*>(sender());
    if (!socket) return;
    
    QByteArray data = socket->readAll();
    qDebug() << "收到数据:" << data;
    
    // 这里处理你的业务逻辑
    // 比如解析协议、回复消息等
}

void MyServer::onDisconnected()
{
    QTcpSocket *socket = qobject_cast<QTcpSocket*>(sender());
    if (!socket) return;
    
    m_clients.removeOne(socket);
    socket->deleteLater();
    qDebug() << "客户端断开";
}

这个代码虽然简单，但结构很清晰。你可以在onReadyRead里加上粘包拆包的处理逻辑——嗯，那就是下一节的内容了。

好了，关于QTcpServer的搭建就聊到这里。记住核心思路：监听、接收、分发。把这三点吃透了，服务器端你就掌握了八成。