Fortune-Server

Dieses Beispiel ist für die Ausführung zusammen mit dem Beispiel „Fortune-Client“ oder dem Beispiel „Blocking Fortune-Client“ vorgesehen.

Es verwendet „ QTcpServer “, um eingehende TCP-Verbindungen anzunehmen, und ein einfaches, auf „ QDataStream “ basierendes Datenübertragungsprotokoll, um dem verbundenen Client (aus dem Beispiel „Fortune Client“ ) ein „Fortune“ zu schreiben, bevor die Verbindung geschlossen wird.

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;
};

Der Server wird mithilfe einer einfachen Klasse mit nur einem Slot implementiert, der für die Bearbeitung eingehender Verbindungen zuständig ist.

    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()));

In seinem Konstruktor ruft unser Server-Objekt ` QTcpServer::listen()` auf, um einen ` QTcpServer ` einzurichten, der auf allen Adressen an einem beliebigen Port lauscht. Anschließend wird die gewählte Port- QTcpServer in einem Label angezeigt, damit der Benutzer weiß, mit welchem Port sich der „Fortune Client“ verbinden soll.

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.");

Unser Server generiert eine Liste mit zufälligen „Fortunes“, die er an verbundene Clients senden kann.

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

Wenn ein Client eine Verbindung zu unserem Server herstellt, löst QTcpServer den QTcpServer::newConnection() aus. Dies wiederum ruft unseren sendFortune()-Slot auf:

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

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

Der Zweck dieses Slots besteht darin, eine zufällige Zeile aus unserer Liste von „Fortune“-Sprüchen auszuwählen, sie mithilfe von ` QDataStream` in ein ` QByteArray ` zu kodieren und sie anschließend an den Verbindungs-Socket zu schreiben. Dies ist eine gängige Methode zur Übertragung binärer Daten mithilfe von ` QTcpSocket`. Zunächst erstellen wir ein ` QByteArray `- und ein ` QDataStream `-Objekt, wobei wir das Bytearray an den Konstruktor von ` QDataStream` übergeben. Anschließend setzen wir die Protokollversion von ` QDataStream ` explizit auf ` QDataStream::Qt_5_10 `, um sicherzustellen, dass wir mit Clients aus zukünftigen Versionen von Qt kommunizieren können (siehe QDataStream::setVersion()). Als Nächstes streamen wir ein zufälliges Sprichwort ein.

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

Anschließend rufen wir ` QTcpServer::nextPendingConnection()` auf, was die ` QTcpSocket ` zurückgibt, die die serverseitige Verbindung repräsentiert. Indem wir ` QTcpSocket::disconnected()` mit ` QObject::deleteLater()` verknüpfen, stellen wir sicher, dass der Socket nach dem Trennen der Verbindung gelöscht wird.

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

Das kodierte Sprichwort wird mit ` QTcpSocket::write()` geschrieben, und schließlich rufen wir ` QTcpSocket::disconnectFromHost()` auf, wodurch die Verbindung geschlossen wird, nachdem ` QTcpSocket ` das Schreiben des Sprichworts ins Netzwerk abgeschlossen hat. Da ` QTcpSocket ` asynchron arbeitet, werden die Daten erst geschrieben, nachdem diese Funktion zurückkehrt und die Kontrolle wieder an die Ereignisschleife von Qt übergeht. Der Socket wird dann geschlossen, was wiederum dazu führt, dass QObject::deleteLater() ihn löscht.

Beispielprojekt @ code.qt.io