Serveur Fortune

Cet exemple est destiné à être exécuté en même temps que l'exemple Fortune Client ou l'exemple Blocking Fortune Client.

Il utilise QTcpServer pour accepter les connexions TCP entrantes et un simple protocole de transfert de données basé sur QDataStream pour écrire une fortune au client qui se connecte (à partir de l'exemple Fortune Client ), avant de fermer la connexion.

class Server : public QDialog
{
    Q_OBJECT

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

private slots:
    void sendFortune();

private:
    void initServer();

    QLabel *statusLabel = nullptr;
    QTcpServer *tcpServer = nullptr;
    QList<QString> fortunes;
};

Le serveur est implémenté à l'aide d'une classe simple avec un seul slot, pour gérer les connexions entrantes.

    tcpServer = new QTcpServer(this);
    if (!tcpServer->listen()) {
        QMessageBox::critical(this, tr("Fortune Server"),
                              tr("Unable to start the server: %1.")
                              .arg(tcpServer->errorString()));
        close();
        return;
    }
    QString ipAddress;
    const QList<QHostAddress> ipAddressesList = QNetworkInterface::allAddresses();
    // use the first non-localhost IPv4 address
    for (const QHostAddress &entry : ipAddressesList) {
        if (entry != QHostAddress::LocalHost && entry.toIPv4Address()) {
            ipAddress = entry.toString();
            break;
        }
    }
    // if we did not find one, use IPv4 localhost
    if (ipAddress.isEmpty())
        ipAddress = QHostAddress(QHostAddress::LocalHost).toString();
    statusLabel->setText(tr("The server is running on\n\nIP: %1\nport: %2\n\n"
                            "Run the Fortune Client example now.")
                         .arg(ipAddress).arg(tcpServer->serverPort()));

Dans son constructeur, notre objet Serveur appelle QTcpServer::listen() pour configurer un QTcpServer qui écoute toutes les adresses, sur un port arbitraire. Il affiche ensuite le port choisi par QTcpServer dans une étiquette, afin que l'utilisateur sache à quel port le client fortune doit se connecter.

fortunes << tr("You've been leading a dog's life. Stay off the furniture.")
         << tr("You've got to think about tomorrow.")
         << tr("You will be surprised by a loud noise.")
         << tr("You will feel hungry again in another hour.")
         << tr("You might have mail.")
         << tr("You cannot kill time without injuring eternity.")
         << tr("Computers are not intelligent. They only think they are.");

Notre serveur génère une liste de fortunes aléatoires qu'il peut envoyer aux clients qui se connectent.

connect(tcpServer, &QTcpServer::newConnection, this, &Server::sendFortune);

Lorsqu'un client se connecte à notre serveur, QTcpServer émet QTcpServer::newConnection(). Ce dernier invoquera à son tour notre slot sendFortune() :

void Server::sendFortune()
{
    QByteArray block;
    QDataStream out(&block, QIODevice::WriteOnly);
    out.setVersion(QDataStream::Qt_6_5);

    out << fortunes[QRandomGenerator::global()->bounded(fortunes.size())];

L'objectif de ce slot est de sélectionner une ligne aléatoire dans notre liste de fortunes, de l'encoder dans un QByteArray à l'aide de QDataStream, puis de l'écrire sur le socket de connexion. Il s'agit d'une méthode courante pour transférer des données binaires à l'aide de QTcpSocket. Nous commençons par créer un objet QByteArray et un objet QDataStream, en passant le tableau d'octets au constructeur de QDataStream. Nous définissons ensuite explicitement la version du protocole de QDataStream à QDataStream::Qt_5_10 pour nous assurer que nous pouvons communiquer avec les clients des futures versions de Qt (voir QDataStream::setVersion()). Nous continuons en introduisant une fortune aléatoire.

    QTcpSocket *clientConnection = tcpServer->nextPendingConnection();
    connect(clientConnection, &QAbstractSocket::disconnected,
            clientConnection, &QObject::deleteLater);

Nous appelons ensuite QTcpServer::nextPendingConnection(), qui renvoie QTcpSocket représentant le côté serveur de la connexion. En connectant QTcpSocket::disconnected() à QObject::deleteLater(), nous nous assurons que le socket sera supprimé après la déconnexion.

    clientConnection->write(block);
    clientConnection->disconnectFromHost();
}

La fortune encodée est écrite à l'aide de QTcpSocket::write(), et nous appelons enfin QTcpSocket::disconnectFromHost(), qui fermera la connexion après que QTcpSocket aura fini d'écrire la fortune sur le réseau. Comme QTcpSocket travaille de manière asynchrone, les données seront écrites après le retour de cette fonction, et le contrôle revient à la boucle d'événements de Qt. Le socket se fermera alors, ce qui entraînera la suppression du socket par QObject::deleteLater().

Exemple de projet @ code.qt.io