Beispiel 1: Direkte Verbindung mit einer statischen Quelle

1. Erstellen eines Quellobjekts

   Um dieses Source-Objekt zu erstellen, erstellen wir zunächst die Definitionsdatei simpleswitch.rep. Diese Datei beschreibt die Eigenschaften und Methoden für das Objekt und wird in den Qt Remote Objects Compiler repc eingegeben. In dieser Datei werden nur die Schnittstellen definiert, die für die Replikate erforderlich sind.

   simpleswitch.rep

   class SimpleSwitch
   {
       PROP(bool currState=false);
       SLOT(server_slot(bool clientState));
   };

   In simpleswitch.rep,

   • currState den aktuellen Zustand des Schalters an.
   • server_slot() ermöglicht es uns, mit der Quelle zu interagieren - sie wird mit dem Signal echoSwitchState(bool newstate) verbunden.

   Damit repc diese Datei verarbeiten kann, fügen Sie die folgende Zeile in Ihre cmake Datei ein:

   qt6_add_repc_sources(directconnectserver
       simpleswitch.rep
   )

   Wenn Sie qmake verwenden:

   REPC_SOURCE = simpleswitch.rep

   Diese Anweisungen sind nur für das Qt Remote Objects Modul relevant, also müssen Sie es auch zu Ihrem Projekt hinzufügen. Wenn Sie CMake verwenden, fügen Sie hinzu:

   find_package(Qt6 REQUIRED COMPONENTS RemoteObjects)
   target_link_libraries(directconnectserver PRIVATE Qt6::RemoteObjects)

   Wenn Sie qmake verwenden:

   QT       += remoteobjects

   repc erstellt den rep_SimpleSwitch_source.h Header in dem von Ihnen angegebenen Build-Verzeichnis. Für weitere Informationen siehe Quelle.

   repc erstellt drei Hilfsklassen für die Verwendung mit QtRO. Für dieses Beispiel verwenden wir die Basisklasse: SimpleSwitchSimpleSource. Es handelt sich um eine abstrakte Klasse, die in rep_SimpleSwitch_source.h definiert ist. Wir leiten von ihr ab, um unsere SimpleSwitch-Implementierungsklasse wie unten gezeigt zu definieren:

   simpleswitch.h

   #ifndef SIMPLESWITCH_H
   #define SIMPLESWITCH_H
   
   #include "rep_simpleswitch_source.h"
   
   class SimpleSwitch : public SimpleSwitchSimpleSource
   {
       Q_OBJECT
   public:
       SimpleSwitch(QObject *parent = nullptr);
       ~SimpleSwitch();
       void server_slot(bool clientState) override;
   public Q_SLOTS:
       void timeout_slot();
   private:
       QTimer *stateChangeTimer;
   };
   
   #endif

   In simpleswitch.h,

   • stateChangeTimer ist eine QTimer, die verwendet wird, um den Zustand unseres SimpleSwitch umzuschalten.
   • timeout_slot() ist mit stateChangeTimer's timeout() Signal verbunden.
   • server_slot() - das automatisch in der Quelle aufgerufen wird, wenn eine Replik ihre Version des Slots aufruft - gibt den empfangenen Wert aus.
   • currStateChanged(bool)Das Signal timeout(), das in der von repc erzeugten rep_SimpleSwitch_source.h definiert ist, wird immer dann ausgegeben, wenn currState umschaltet. In diesem Beispiel ignorieren wir das Signal auf der Quellseite und behandeln es später auf der Replikat-Seite.

   Die Definition unserer Klasse SwitchState ist unten dargestellt:

   simpleswitch.cpp

   #include "simpleswitch.h"// KonstruktorSimpleSwitch::SimpleSwitch(QObject *parent) : SimpleSwitchSimpleSource(parent) { stateChangeTimer = new QTimer(this); // Initialisierung des Timers   QObject::connect(stateChangeTimer, &QTimer::timeout, this, &SimpleSwitch::timeout_slot); // timeout()-Signal von stateChangeTimer mit timeout_slot() von simpleSwitch verbinden stateChangeTimer->start(2000); // Timer starten und Timout auf 2 Sekunden setzen    qDebug() << "Source Node Started";
   }//destructorSimpleSwitch::~SimpleSwitch() {  stateChangeTimer->stop(); }void SimpleSwitch::server_slot(bool clientState){
       qDebug() << "Replica state is " << clientState; // print switch state echoed back by client
   }void SimpleSwitch::timeout_slot() { // Slot wird bei Zeitüberschreitung aufgerufen if (currState()) // prüfen, ob aktueller Zustand wahr ist, currState() ist in der von repc generierten rep_simpleswitch_source.h definiertsetCurrState(false); // Zustand auf false setzen elsesetCurrState(true); // Zustand auf true setzen    qDebug() << "Source State is "<<currState();
   
   

2. Create a registryDa

   in diesem Beispiel eine direkte Verbindung zwischen den Knoten verwendet wird, können wir diesen Schritt auslassen.

3. Create a host nodeDer

   Host-Knoten wird wie unten gezeigt erstellt:

   QRemoteObjectHost srcNode(QUrl(QStringLiteral("local:replica")));

4. Host source object and remotingDie

   folgenden Anweisungen instanziieren das Source-Objekt und übergeben es an den Host, um "Remoting" zu ermöglichen, d.h. den Prozess, ein Objekt für das QtRO-Netzwerk sichtbar zu machen:

   SimpleSwitch srcSwitch; // create simple switch
   srcNode.enableRemoting(&srcSwitch); // enable remoting

   Der Inhalt der Datei main.cpp, die die oben beschriebenen Schritte implementiert, ist wie folgt:

   main.cpp

   #include <QCoreApplication>
   #include "simpleswitch.h"
   
   int main(int argc, char *argv[])
   {
       QCoreApplication a(argc, argv);
   
       SimpleSwitch srcSwitch; // create simple switch
   
       // Create host node without Registry:
       QRemoteObjectHost srcNode(QUrl(QStringLiteral("local:replica")));
       srcNode.enableRemoting(&srcSwitch); // enable remoting/sharing
   
       return a.exec();
   }

   Kompilieren Sie dieses quellseitige Projekt und führen Sie es aus. Die Ausgabe, ohne dass Replikate erstellt wurden, sollte wie unten dargestellt aussehen, wobei der Schaltzustand alle zwei Sekunden zwischen true und false wechselt.

   

Die folgenden Schritte dienen der Erstellung der Replikatseite des Netzwerks, die in diesem Beispiel den Zustand des Schalters von der Quelle abruft und ihn zurückgibt.

Replik-Code

1. Verwenden Sie repc, um ein Replikat zu Ihrem Projekt hinzuzufügenWir

   verwenden dieselbe API-Definitionsdatei wie auf der Quellseite, SimpleSwitch.rep, um eine Replikat-Header-Datei mit repc zu erstellen.

   Wenn Sie cmake verwenden

   ,

   fügen Sie die folgende Zeile in Ihre clientseitige cmake Datei ein und geben Sie eine .rep Dateieingabe an:

   qt6_add_repc_replicas(directconnectclient
       simpleswitch.rep
   )

   Wenn Sie qmake verwenden

   ,

   fügen Sie die folgende Zeile in Ihre clientseitige .pro Datei ein:

   REPC_REPLICA = simpleswitch.rep

   Das repc Tool erzeugt eine rep_SimpleSwitch_replica.h Datei im Build-Verzeichnis. Weitere Informationen finden Sie unter Replik.

2. Erstellen eines Knotens zur Verbindung mit dem Host-Knoten der QuelleDer

   folgende Code instanziiert den zweiten Knoten im Netzwerk und verbindet ihn mit dem Host-Knoten der Quelle:

   QRemoteObjectNode repNode; // create remote object node
   repNode.connectToNode(QUrl(QStringLiteral("local:replica"))); // connect with remote host node

3. Rufen Sie die Knotenfunktion acquire() auf, um einen Zeiger auf eine Replik zu erstellen.

   Zuerst instanziieren wir ein Replikat:

   QSharedPointer<SimpleSwitchReplica> ptr;
   ptr.reset(repNode.acquire<SimpleSwitchReplica>()); // acquire replica of source from host node

   Hinweis: acquire() gibt einen Zeiger auf das Replikat zurück, verwaltet aber nicht dessen Lebensdauer. In diesem Beispiel wird empfohlen, den zurückgegebenen Zeiger in ein QSharedPointer oder QScopedPointer zu verpacken, um sicherzustellen, dass der Zeiger immer ordnungsgemäß gelöscht wird.

   main.cpp implementiert die oben beschriebenen Schritte und instanziiert unser Objekt:

   main.cpp

   #include <QCoreApplication>
   #include "client.h"
   
   int main(int argc, char *argv[])
   {
       QCoreApplication a(argc, argv);
   
       QSharedPointer<SimpleSwitchReplica> ptr; // shared pointer to hold source replica
   
       QRemoteObjectNode repNode; // create remote object node
       repNode.connectToNode(QUrl(QStringLiteral("local:replica"))); // connect with remote host node
   
       ptr.reset(repNode.acquire<SimpleSwitchReplica>()); // acquire replica of source from host node
   
       Client rswitch(ptr); // create client switch object and pass reference of replica to it
   
       return a.exec();
   }

   Die vollständige Deklaration und Definition für die Klasse Client lautet wie folgt:

   client.h

   #ifndef _CLIENT_H
   #define _CLIENT_H
   
   #include <QObject>
   #include <QSharedPointer>
   
   #include "rep_simpleswitch_replica.h"
   
   class Client : public QObject
   {
       Q_OBJECT
   public:
       Client(QSharedPointer<SimpleSwitchReplica> ptr);
       ~Client() override = default;
       void initConnections();// Function to connect signals and slots of source and client
   
   Q_SIGNALS:
       void echoSwitchState(bool switchState);// this signal is connected with server_slot(..) on the source object and echoes back switch state received from source
   
   public Q_SLOTS:
       void recSwitchState_slot(bool); // slot to receive source state
   private:
       bool clientSwitchState; // holds received server switch state
       QSharedPointer<SimpleSwitchReplica> reptr;// holds reference to replica
   
    };
   
   #endif

   client.cpp

   #include "client.h"// constructorClient::Client(QSharedPointer<SimpleSwitchReplica> ptr) : QObject(nullptr),reptr(ptr) { // Verbinde Signal für Replikat, das mit Initialisierungsslot initialisiert wurde.initConnections(); // Wir können uns mit SimpleSwitchReplica Signalen/Slots // direkt  verbinden , da unser Replikat von repc generiert wurde.}void Client::initConnections() { // initialisiere Verbindungen zwischen Signalen und Slots // verbinde das Signal currStateChanged() des Quellreplikats mit dem Slot recSwitchState() des Clients, um den aktuellen Zustand der Quelle zu erhalten   QObject::connect(reptr.data(), &SimpleSwitchReplica::currStateChanged, this, &Client::recSwitchState_slot); // Verbinde das Signal echoSwitchState(..) des Clients mit dem server_slot(..) des Replikats, um den empfangenen Status zurückzusenden   QObject::connect(this, &Client::echoSwitchState, reptr.data(), &SimpleSwitchReplica::server_slot); }void Client::recSwitchState_slot(bool value){
       qDebug() << "Received source state "<< value << reptr.data()->currState();
       clientSwitchState = reptr.data()->currState(); Q_EMIT echoSwitchState(clientSwitchState); // Emit signal to echo received state back to server}

   Das Kompilieren und Ausführen dieses Beispiels zusammen mit dem Beispiel auf der Quellseite erzeugt die folgende Ausgabe: