Cliente de Fortune

Muestra cómo crear un cliente para un servicio de red.

Este ejemplo utiliza QTcpSocket y está pensado para ejecutarse junto con el ejemplo «Fortune Server » o el ejemplo «Threaded Fortune Server ».

Captura de pantalla del ejemplo de Fortune Client

Este ejemplo utiliza un protocolo sencillo de transferencia de datos basado en QDataStream para solicitar una línea de texto a un servidor Fortune (del ejemplo «Fortune Server» ). El cliente solicita una frase simplemente conectándose al servidor. A continuación, el servidor responde con un objeto QString que contiene el texto de la frase.

QTcpSocket admite dos enfoques generales para la programación en red:

  • El enfoque asíncrono (sin bloqueo). Las operaciones se programan y se ejecutan cuando el control vuelve al bucle de eventos de Qt. Cuando la operación finaliza, ` QTcpSocket ` emite una señal. Por ejemplo, ` QTcpSocket::connectToHost()` devuelve el resultado inmediatamente y, una vez establecida la conexión, ` QTcpSocket ` emite ` connected()`.
  • El enfoque síncrono (bloqueante). En aplicaciones sin interfaz gráfica de usuario y multihilo, se pueden llamar a las funciones de waitFor...() (por ejemplo, QTcpSocket::waitForConnected()) para suspender el hilo de llamada hasta que la operación haya finalizado, en lugar de conectarse a señales.

En este ejemplo, mostraremos el enfoque asíncrono. El ejemplo «Blocking Fortune Client» ilustra el enfoque síncrono.

Nuestra clase contiene algunos datos y unas cuantas ranuras privadas:

class Client : public QDialog
{
    Q_OBJECT

public:
    explicit Client(QWidget *parent = nullptr);

private slots:
    void requestNewFortune();
    void readFortune();
    void displayError(QAbstractSocket::SocketError socketError);
    void enableGetFortuneButton();

private:
    QComboBox *hostCombo = nullptr;
    QLineEdit *portLineEdit = nullptr;
    QLabel *statusLabel = nullptr;
    QPushButton *getFortuneButton = nullptr;

    QTcpSocket *tcpSocket = nullptr;
    QDataStream in;
    QString currentFortune;
};

Además de los widgets que componen la interfaz gráfica de usuario, los miembros de datos incluyen un puntero a ` QTcpSocket `, un objeto ` QDataStream ` que opera sobre el socket y una copia del texto de la frase de la fortuna que se muestra actualmente.

El socket se inicializa en el constructor de Client. Pasaremos el widget principal como padre, para no tener que preocuparnos de eliminar el socket:

Client::Client(QWidget *parent)
    : QDialog(parent)
    , hostCombo(new QComboBox)
    , portLineEdit(new QLineEdit)
    , getFortuneButton(new QPushButton(tr("Get Fortune")))
    , tcpSocket(new QTcpSocket(this))
{
    ...
    in.setDevice(tcpSocket);
    in.setVersion(QDataStream::Qt_6_5);

El protocolo se basa en QDataStream, por lo que configuramos el dispositivo de flujo en el socket recién creado. A continuación, establecemos explícitamente la versión del protocolo del flujo en QDataStream::Qt_6_5 para asegurarnos de que estamos utilizando la misma versión que el servidor de «fortune», independientemente de la versión de Qt que utilicen el cliente y el servidor.

Las únicas señales de QTcpSocket que necesitamos en este ejemplo son QTcpSocket::readyRead(), que indica que se han recibido datos, y QTcpSocket::errorOccurred(), que utilizaremos para detectar cualquier error de conexión:

    ...
    connect(tcpSocket, &QIODevice::readyRead, this, &Client::readFortune);
    connect(tcpSocket, &QAbstractSocket::errorOccurred,
    ...
}

Al hacer clic en el botón « Get Fortune », se invocará la ranura « requestNewFortune() »:

void Client::requestNewFortune()
{
    getFortuneButton->setEnabled(false);
    tcpSocket->abort();
    tcpSocket->connectToHost(hostCombo->currentText(),
                             portLineEdit->text().toInt());
}

Dado que permitimos que el usuario haga clic en « Get Fortune » antes de que se haya cerrado la conexión anterior, comenzamos por interrumpir dicha conexión llamando a ` QTcpSocket::abort()`. (En un socket no conectado, esta función no hace nada.) A continuación, procedemos a conectarnos al servidor de «fortune» llamando a ` QTcpSocket::connectToHost()`, pasando como argumentos el nombre de host y el puerto proporcionados desde la interfaz de usuario.

Al llamar a ` connectToHost()`, pueden ocurrir dos cosas:

  • Se establece la conexión. En este caso, el servidor nos enviará una «fortune». QTcpSocket emitirá readyRead() cada vez que reciba un bloque de datos.
  • Se produce un error. Debemos informar al usuario de si la conexión ha fallado o se ha interrumpido. En este caso, ` QTcpSocket ` emitirá ` errorOccurred()` y se llamará a ` Client::displayError() `.

Veamos primero el caso de errorOccurred():

void Client::displayError(QAbstractSocket::SocketError socketError)
{
    switch (socketError) {
    case QAbstractSocket::RemoteHostClosedError:
        break;
    case QAbstractSocket::HostNotFoundError:
        QMessageBox::information(this, tr("Fortune Client"),
                                 tr("The host was not found. Please check the "
                                    "host name and port settings."));
        break;
    case QAbstractSocket::ConnectionRefusedError:
        QMessageBox::information(this, tr("Fortune Client"),
                                 tr("The connection was refused by the peer. "
                                    "Make sure the fortune server is running, "
                                    "and check that the host name and port "
                                    "settings are correct."));
        break;
    default:
        QMessageBox::information(this, tr("Fortune Client"),
                                 tr("The following error occurred: %1.")
                                 .arg(tcpSocket->errorString()));
    }

    getFortuneButton->setEnabled(true);
}

Mostramos todos los errores en un cuadro de diálogo mediante QMessageBox::information(). QTcpSocket::RemoteHostClosedError se ignora silenciosamente, ya que el protocolo del servidor Fortune finaliza con el cierre de la conexión por parte del servidor.

Ahora veamos la alternativa de ` readyRead()`. Esta señal está conectada a ` Client::readFortune()`:

void Client::readFortune()
{
    in.startTransaction();

    QString nextFortune;
    in >> nextFortune;

    if (!in.commitTransaction())
        return;

    if (nextFortune == currentFortune) {
        QTimer::singleShot(0, this, &Client::requestNewFortune);
        return;
    }

    currentFortune = nextFortune;
    statusLabel->setText(currentFortune);
    getFortuneButton->setEnabled(true);
}

Ahora bien, TCP se basa en el envío de un flujo de datos, por lo que no podemos esperar recibir la «fortune» completa de una sola vez. Especialmente en una red lenta, los datos pueden recibirse en varios fragmentos pequeños. QTcpSocket almacena en búfer todos los datos entrantes y emite readyRead() por cada nuevo bloque que llega, y es nuestra tarea asegurarnos de que hemos recibido todos los datos que necesitamos antes de empezar a analizarlos.

Para ello utilizamos una transacción de lectura de QDataStream. Esta sigue leyendo los datos del flujo en un búfer interno y los revierte en caso de que la lectura sea incompleta. Comenzamos llamando a startTransaction(), lo que también restablece el estado del flujo para indicar que se han recibido nuevos datos en el socket. A continuación, utilizamos el operador de streaming de ` QDataStream` para leer la frase de la suerte desde el socket y almacenarla en un ` QString`. Una vez leída, completamos la transacción llamando a ` QDataStream::commitTransaction()`. Si no hemos recibido un paquete completo, esta función restablece los datos del flujo a la posición inicial, tras lo cual podemos esperar una nueva señal de `readyRead()`.

Tras una transacción de lectura correcta, llamamos a ` QLabel::setText()` para mostrar la frase de la fortuna.

Proyecto de ejemplo en code.qt.io

Véase también «Servidor de la fortuna » y «Cliente de la fortuna bloqueante».

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.