QT项目_RPC(进程间通讯)

最新推荐文章于 2024-09-09 11:25:37 发布
最新推荐文章于 2024-09-09 11:25:37 发布
阅读量2.8k 收藏 6
点赞数
分类专栏： Qt开发 文章标签： qt rpc 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50183638/article/details/129056932
版权

QT项目_RPC(进程间通讯)

前言：
两个进程间通信、或是说两个应用程序之间通讯。实际情况是在QT开发的一个项目中，里面包含两个子程序，子程序有单独的界面和应用逻辑，这两个子程序跑起来之后需要一些数据的交互，例如：一个程序是用户界面和用户程序，另一个程序时OSD菜单
注意：RPC通讯传输的数据类型有bool、int和std::string(QString不行)
效果演示：
在这里插入图片描述

1、移植RCP源码到自己工程

①移植RPC，说白了就是两个文件夹里面有N多个源文件，直接复制过来直接用，需要自行修改.pro文件以便加入编译
在这里插入图片描述
在这里插入图片描述

# rest_rpc
INCLUDEPATH += $$PWD/msgpack
DEPENDPATH += $$PWD/msgpack

②工程目录
在这里插入图片描述
在这里插入图片描述

2、源码展示
test_rpc.pro

TEMPLATE = subdirs

SUBDIRS += \
    apply \
    layer

apply/apply.pro

QT += quick \
    widgets

CONFIG += c++11

# The following define makes your compiler emit warnings if you use
# any Qt feature that has been marked deprecated (the exact warnings
# depend on your compiler). Refer to the documentation for the
# deprecated API to know how to port your code away from it.
DEFINES += QT_DEPRECATED_WARNINGS

# You can also make your code fail to compile if it uses deprecated APIs.
# In order to do so, uncomment the following line.
# You can also select to disable deprecated APIs only up to a certain version of Qt.
#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0

SOURCES += \
        main.cpp \
        mainwidget.cpp \
        rpc/MessageTip.cpp \
        rpc/RPCClient.cpp \
        rpc/RPCServer.cpp

RESOURCES += qml.qrc

# Additional import path used to resolve QML modules in Qt Creator's code model
QML_IMPORT_PATH =

# Additional import path used to resolve QML modules just for Qt Quick Designer
QML_DESIGNER_IMPORT_PATH =

# Default rules for deployment.
qnx: target.path = /tmp/$${TARGET}/bin
else: unix:!android: target.path = /opt/$${TARGET}/bin
!isEmpty(target.path): INSTALLS += target

# rest_rpc
INCLUDEPATH += $$PWD/msgpack
DEPENDPATH += $$PWD/msgpack

HEADERS += \
    mainwidget.h \
    rpc/MessageTip.h \
    rpc/RPCClient.h \
    rpc/RPCServer.h

apply/Headers/rpc/MessageTip.h

#ifndef MESSAGETIP_H
#define MESSAGETIP_H

#include <qstring.h>

namespace MessageTip
{
    void onApplyvalueChanged(int value);
    void onApplystringChanged(std::string value);
}

#endif // MESSAGETIP_H

apply/Headers/rpc/RPCClient.h

#ifndef RPCCLIENT_H
#define RPCCLIENT_H

#include "rest_rpc/rpc_client.hpp"

class RPCClient
{
public:
    RPCClient();

    static RPCClient *get_instance()
    {
        static RPCClient manage;
        return &manage;
    }

    /**
     * @brief 尝试连接RPC Server
     * @return true 连接成功，false　连接失败
     */
    void tryConnect();

    rest_rpc::rpc_client *getSocketObject();

private:
    rest_rpc::rpc_client *m_pClient = nullptr;
};

#endif // RPCCLIENT_H

apply/Headers/rpc/RPCServer.h

#ifndef RPCSERVER_H
#define RPCSERVER_H

#include <qstring.h>
#include "rest_rpc/rpc_server.h"

using namespace rest_rpc;
using namespace rpc_service;

class RPCServer
{
public:
    RPCServer();
    void setApplyvalue(rpc_conn conn , int value);
    void setApplystring(rpc_conn conn , std::string value);
};

#endif // RPCSERVER_H

apply/Headers/mainwidget.h

#ifndef MAINWIDGET_H
#define MAINWIDGET_H

#include <QObject>
#include <QWidget>
#include <QQmlComponent>
#include <QQmlApplicationEngine>
#include <QQuickItem>
#include "rpc/RPCServer.h"

class MainWidget : public QObject
{
    Q_OBJECT
public:
    MainWidget();

protected slots:
    void onClickPageNo(bool enable);
    void onApplyvalueChanged(int value);
    void onApplystringChanged(QString value);

private:
    QQuickItem *m_applyItem = nullptr;
    QObject *m_applyObject = nullptr;
    RPCServer *m_pRPCServer = nullptr;
};

#endif // MAINWIDGET_H

apply/Sources/rpc/MessageTip.cpp

#include "MessageTip.h"
#include "RPCClient.h"
#include "qdebug.h"


void MessageTip::onApplyvalueChanged(int value)
{
    try {
        RPCClient::get_instance()->getSocketObject()->call<void>("MessageTip::layervalueChanged", value);
    } catch (const std::exception &e) {
        qDebug() << "Exception {}", e.what();
    }
}

void MessageTip::onApplystringChanged(std::string value)
{
    try {
        RPCClient::get_instance()->getSocketObject()->call<void>("MessageTip::layerstringChanged", value);
    } catch (const std::exception &e) {
        qDebug() << "Exception {}", e.what();
    }
}

apply/Sources/rpc/RPCClient.cpp

#include "RPCClient.h"
#include <QtDebug>

RPCClient::RPCClient()
{

}

void RPCClient::tryConnect()
{
    m_pClient = new rest_rpc::rpc_client("127.0.0.1", 9000);
    m_pClient->enable_auto_reconnect(true);

    m_pClient->connect();

    std::thread([&] {
        while (true)
        {
            if (m_pClient->has_connected()) {
                qDebug() << "apply RPC connect success";

                break;
            } else {
                qDebug() << "apply RPC connect fail";
                std::this_thread::sleep_for(std::chrono::milliseconds(500));
            }
        }
    }).detach();
}

rest_rpc::rpc_client *RPCClient::getSocketObject()
{
    return m_pClient;
}

apply/Sources/rpc/RPCServer.cpp

#include "RPCServer.h"
#include "qdebug.h"

RPCServer::RPCServer()
{
    std::thread([&] {
        rpc_server server(9001, std::thread::hardware_concurrency());

        server.register_handler("MessageTip::setApplyvalue", &RPCServer::setApplyvalue, this);
        server.register_handler("MessageTip::setApplystring", &RPCServer::setApplystring, this);

        server.run();
    }).detach();
}

void RPCServer::setApplyvalue(rpc_conn conn , int value)
{
    //todo
    qDebug() << "apply recv :" << value;
}

void RPCServer::setApplystring(rpc_conn conn , std::string value)
{
    //todo
    qDebug() << "apply recv :" << QString::fromStdString(value);
}

apply/Sources/main.cpp

#include <QGuiApplication>
#include <QQmlApplicationEngine>
#include "mainwidget.h"
#include "qdebug.h"
#include "qthread.h"

int main(int argc, char *argv[])
{
    QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);

    QGuiApplication app(argc, argv);

//    QQmlApplicationEngine engine;
//    const QUrl url(QStringLiteral("qrc:/main.qml"));
//    QObject::connect(&engine, &QQmlApplicationEngine::objectCreated,
//    &app, [url](QObject * obj, const QUrl & objUrl) {
//        if (!obj && url == objUrl) {
//            QCoreApplication::exit(-1);
//        }
//    }, Qt::QueuedConnection);
//    engine.load(url);

    MainWidget mainwidget;
    return app.exec();
}

apply/Sources/mainwidget.cpp

#include "mainwidget.h"
#include "qdebug.h"
#include "rpc/RPCClient.h"
#include "rpc/MessageTip.h"
#include <QProcess>

MainWidget::MainWidget()
{
    QQmlApplicationEngine *m_pEngine = new QQmlApplicationEngine;
    QQmlComponent component(m_pEngine, QUrl(QStringLiteral("qrc:/main.qml")));
    QObject *mainObject = component.create();
    if (mainObject == nullptr) {
        qDebug() << "mainObject fail";
        return;
    }

    QList<QObject *> objectList = mainObject->findChildren<QObject *>("mybutton");
    if (objectList.isEmpty()) {
        qDebug() << "mybutton failed\n";
        return;
    }
    m_applyObject = objectList.last();

    connect(m_applyObject, SIGNAL(applyvalueChanged(int)), this, SLOT(onApplyvalueChanged(int)));
    connect(m_applyObject, SIGNAL(applystringChanged(QString)), this, SLOT(onApplystringChanged(QString)));
    connect(mainObject, SIGNAL(window_interface(bool)), this, SLOT(onClickPageNo(bool)));

    m_pRPCServer = new RPCServer();
    RPCClient::get_instance()->tryConnect();
}

void MainWidget::onClickPageNo(bool enable)
{
    QProcess *process = new QProcess();
    process->start("/home/zhou/work/test/build-test_rpc-Desktop_Qt_5_14_2_GCC_64bit-Debug/layer/layer");
}

void MainWidget::onApplyvalueChanged(int value)
{
    qDebug() << "onApplyvalueChanged" << value;
    MessageTip::onApplyvalueChanged(value);
}

void MainWidget::onApplystringChanged(QString value)
{
    qDebug() << "onApplystringChanged" << value;
    MessageTip::onApplystringChanged(std::string(value.toLocal8Bit()));
}

apply/main.qml

import QtQuick 2.12
import QtQuick.Window 2.12
import QtQuick.Controls 2.12

Window {
    visible: true
    width: 640
    height: 480
    objectName: "apply_window"
    title: qsTr("Hello apply")

    signal window_interface(bool enable)

    Column{
        anchors.fill: parent
        spacing: 20
        Button{
            width: 140
            height: 50

            text: "开启界面2"
            onClicked: {
                window_interface(true)
            }
        }
        Mybutton{
            width: 140
            height: 300
        }
    }
}

apply/Mybutton.qml

import QtQuick 2.0
import QtQuick.Controls 2.12

Item {
    objectName: "mybutton"

    signal applyvalueChanged(int value)
    signal applystringChanged(string value)

    Column{
        spacing: 10
        Button{
            objectName: "button"
            width: 140
            height: 50

            text: "send1"

            onClicked: {
                applyvalueChanged(1)
            }
        }
        Button{
            width: 140
            height: 50

            text: "send2"

            onClicked: {
                applyvalueChanged(2)
            }
        }
        Button{
            width: 140
            height: 50

            text: "验证string"
            onClicked: {
                applystringChanged("{\"name\":\"lili\",\"age\":24,\"class\":6}")
            }
        }
    }
}

layer.pro

QT += quick
QT += widgets

CONFIG += c++11

# The following define makes your compiler emit warnings if you use
# any Qt feature that has been marked deprecated (the exact warnings
# depend on your compiler). Refer to the documentation for the
# deprecated API to know how to port your code away from it.
DEFINES += QT_DEPRECATED_WARNINGS

# You can also make your code fail to compile if it uses deprecated APIs.
# In order to do so, uncomment the following line.
# You can also select to disable deprecated APIs only up to a certain version of Qt.
#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0

SOURCES += \
        main.cpp \
        mainwidget.cpp \
        rpc/MessageTip.cpp \
        rpc/RPCClient.cpp \
        rpc/RPCServer.cpp

RESOURCES += qml.qrc

# Additional import path used to resolve QML modules in Qt Creator's code model
QML_IMPORT_PATH =

# Additional import path used to resolve QML modules just for Qt Quick Designer
QML_DESIGNER_IMPORT_PATH =

# Default rules for deployment.
qnx: target.path = /tmp/$${TARGET}/bin
else: unix:!android: target.path = /opt/$${TARGET}/bin
!isEmpty(target.path): INSTALLS += target

# rest_rpc
INCLUDEPATH += $$PWD/msgpack
DEPENDPATH += $$PWD/msgpack

HEADERS += \
    mainwidget.h \
    rpc/MessageTip.h \
    rpc/RPCClient.h \
    rpc/RPCServer.h

layer/Headers/rpc/MessageTip.h

#ifndef MESSAGETIP_H
#define MESSAGETIP_H

#include <qstring.h>

namespace MessageTip
{
    void setApplyvalue(int value);
    void setApplystring(std::string value);
}

#endif // MESSAGETIP_H

layer/Headers/rpc/RPCClient.h

#ifndef RPCCLIENT_H
#define RPCCLIENT_H

#include "rest_rpc/rpc_client.hpp"

class RPCClient
{
public:
    RPCClient();
    static RPCClient *get_instance()
    {
        static RPCClient layer_manage;
        return &layer_manage;
    }

    /**
     * @brief 尝试连接RPC Server
     * @return true 连接成功，false　连接失败
     */
    void tryConnect();

    rest_rpc::rpc_client *getSocketObject();

private:
    rest_rpc::rpc_client *m_pClient = nullptr;
};

#endif // RPCCLIENT_H

layer/Headers/rpc/RPCServer.h

#ifndef RPCSERVER_H
#define RPCSERVER_H

#include <QtDebug>
#include <QThread>
#include <QObject>
#include <QQuickItem>

#include "rest_rpc/rpc_server.h"
using namespace rest_rpc;
using namespace rpc_service;


class RPCServer : public QObject
{
    Q_OBJECT
public:
    explicit RPCServer(QObject *parent = nullptr);
    void layervalueChanged(rpc_conn conn , int value);
    void layerstringChanged(rpc_conn conn , std::string value);

protected:

signals:

private:
    QObject *m_pMainObject = nullptr;
    QQuickItem *m_pOSDAreaItem = nullptr;
};

#endif // RPCSERVER_H

layer/Headers/mainwidget.h

#ifndef MAINWIDGET_H
#define MAINWIDGET_H

#include <QObject>
#include <QQmlComponent>
#include <QQmlApplicationEngine>
#include <QQuickItem>
#include "rpc/RPCServer.h"

class mainwidget : public QObject
{
    Q_OBJECT
public:
    mainwidget();

private:
    RPCServer *m_pRPCServer = nullptr;
};

#endif // MAINWIDGET_H

layer/Sources/rpc/MessageTip.cpp

#include "MessageTip.h"
#include "RPCClient.h"
#include <QtDebug>


void MessageTip::setApplyvalue(int value)
{
    try {
        return RPCClient::get_instance()->getSocketObject()->call<void>("MessageTip::setApplyvalue", value);
    } catch (const std::exception &e) {
        qDebug() << "setImageRotate exception" << e.what();
    }
}

void MessageTip::setApplystring(std::string value)
{
    try {
        return RPCClient::get_instance()->getSocketObject()->call<void>("MessageTip::setApplystring", value);
    } catch (const std::exception &e) {
        qDebug() << "setImageRotate exception" << e.what();
    }
}

layer/Sources/rpc/RPCClient.cpp

#include "RPCClient.h"
#include <QtDebug>

RPCClient::RPCClient()
{

}

void RPCClient::tryConnect()
{
//#if defined(__x86_64)
//    m_pClient = new rest_rpc::rpc_client("192.168.31.95", 9001);
//#else
    m_pClient = new rest_rpc::rpc_client("127.0.0.1", 9001);
//#endif
    m_pClient->enable_auto_heartbeat(true);

    m_pClient->connect();
    std::thread([&] {
        while (true)
        {
            qDebug() << "layer RPC connect fail";
            if (m_pClient->has_connected()) {
                qDebug() << "layer RPC connect success";

                break;
            } else {
                std::this_thread::sleep_for(std::chrono::milliseconds(500));
                qDebug() << "layer RPC connect fail";
            }
        }
    }).detach();
}

rest_rpc::rpc_client *RPCClient::getSocketObject()
{
    return m_pClient;
}

layer/Sources/rpc/RPCServer.cpp

#include "RPCServer.h"
#include "rpc/MessageTip.h"

RPCServer::RPCServer(QObject *parent) : QObject(parent)
{
    QThread::create([&] {
        rpc_server server(9000, std::thread::hardware_concurrency());

        server.register_handler("MessageTip::layervalueChanged", &RPCServer::layervalueChanged, this);
        server.register_handler("MessageTip::layerstringChanged", &RPCServer::layerstringChanged, this);

        server.run();
    })->start();
    qDebug() << "start rpc server";
}

void RPCServer::layervalueChanged(rpc_conn conn , int value)
{
    //todo
    MessageTip::setApplyvalue(value);
    qDebug() << "APPLY SEND :" << value;
}

void RPCServer::layerstringChanged(rpc_conn conn , std::string value)
{
    //todo
    MessageTip::setApplystring(value);
    qDebug() << "APPLY SEND :" << QString::fromStdString(value);
}

layer/Sources/main.cpp

#include <QGuiApplication>
#include <QQmlApplicationEngine>
#include "qdebug.h"
#include "mainwidget.h"

int main(int argc, char *argv[])
{
    QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);

    QGuiApplication app(argc, argv);

//    QQmlApplicationEngine engine;
//    const QUrl url(QStringLiteral("qrc:/main.qml"));
//    QObject::connect(&engine, &QQmlApplicationEngine::objectCreated,
//    &app, [url](QObject * obj, const QUrl & objUrl) {
//        if (!obj && url == objUrl) {
//            QCoreApplication::exit(-1);
//        }
//    }, Qt::QueuedConnection);
//    engine.load(url);

    mainwidget mainwidget;

    return app.exec();
}

layer/Sources/mainwidget.cpp

#include "mainwidget.h"
#include "rpc/RPCClient.h"

mainwidget::mainwidget()
{
    QQmlApplicationEngine *m_pEngine = new QQmlApplicationEngine;
    QQmlComponent component(m_pEngine, QUrl(QStringLiteral("qrc:/main.qml")));
    QObject *mainObject = component.create();
    if (mainObject == nullptr) {
        qDebug() << "mainObject fail";
        return;
    }

    m_pRPCServer = new RPCServer();
    RPCClient::get_instance()->tryConnect();
}

layer/main.qml

import QtQuick 2.12
import QtQuick.Window 2.12
import QtQuick.Controls 2.12

Window {
    visible: true
    width: 640
    height: 480
    title: qsTr("Hello layer")

    Column{
        anchors.fill: parent
        spacing: 20
        Button{
            width: 140
            height: 50

            text: "layer +"
        }

        Button{
            width: 140
            height: 50

            text: "layer -"
        }
    }
}
HX科技
关注
专栏目录
Qt应用之关于RPC的那点儿理解，说得通透点吧
有问题或资源连接有缺失的可以私信公众号新潮看世界获取
05-28 5288
最近写分布式应用，无可避免地需要用到rpc调用，看到网上一大片的大堆大堆文字，心生敬畏了。 可是当我看到百度的sofa-rpc的时候，拿来用了一下。立马就发现，亲，这不就是dbus的网络版吗？当然了，很多同学没有用过dbus服务，自己去试试Qt里面的dbus应用吧。很好理解的。 百度sofa-rpc也是谷歌的grpc的产物，当然了还有很多其他的rpc框架。不过只要你明白dbus，rpc也就好理解了...
Qt基础之二十一：QtRO（Qt Remote Object）实现进程间通信
草上爬的博客
01-13 6530
这里将QtRO单独从上一篇拎出来，因为它是Qt5.9以后新加入的模块，专门用于进程间通信。其使用步骤有点类似之前介绍过的RPC（Remote Procedure Call）框架：gRPC和thrift，关于这两个框架详见和QtRO基于Socket封装，不仅支持RPC，还支持LPC（Local Process Communication），这两者都属于进程间通信。如果是用于RPC，使用QTcpSocket；如果用于LPC，则使用QLocalSocket。因为是Qt出品，能非常方便的集成到自己的Qt项目中。
QtRO (分布式RPC)
05-11
最简单的RPC的例子，
mingw c++/qt使用grpc方法详细教程
最新发布
SuperYang_的博客
09-09 1715
在GRPC里客户端应用可以像调用本地对象一样直接调用另一台不同的机器上服务端应用的方法，使得您能够更容易地创建分布式应用和服务。与许多RPC系统类似，gRPC也是基于以下理念：定义一个服务，指定其能够被远程调用的方法（包含参数和返回类型）。在服务端实现这个接口，并运行一个GRPC服务器来处理客户端调用。在客户端拥有一个存根能够像服务端一样的方法。GRPC调用流程：1> 客户端（gRPC Stub）调用 A 方法，发起 RPC 调用。
7月11日工作日记--Qt-demo实现rpc监控
qq_42866659的博客
07-11 453
Qtdemo，监控
qt-jsonrpc-server:Qt的jsonrpc服务器
03-21
qt-jsonrpc服务器 在qt中创建jsonrpc服务的最简单方法。只需将您的QObjects公开为服务即可。 特征 在网络套接字上使用jsonrpc调用您的QObjects。 服务器使用率 要创建提供一种将两个数字相加的方法的服务，只需创建一个以该方法为插槽的QObject。 class MyService : QObject{ Q_OBJECT public slots: inline int addNumbers ( int a, int b){ return a+b; } }; 然后，您可以简单地在端口80上开始提供该服务，例如： # include < QCoreApplication> # include < server> int main (){ QCoreApplication a (); jsonr
qt rpc 同步异步通信
02-23
1 pipeRpcDll库 IRpcServerListen类是服务端，IRpcServiceLauncher类是客户端 2 PipeClientRealCaseRpcHandler 客户端的通信类举例 3 PipeServerRealCaseRpcHandler 服务端的通信类举例 4 PipeClientEx项目是客户端调用pipeRpcDll库的例子 5 PipeServerEx项目是服务端调用pipeRpcDll库的例子
基于 QT 的 XML-RPC 客户端
hw5230的博客
09-02 447
XML-RPC 协议是现在大多数 blog 站点支持的标准协议。通过使用该协议，我们可以很方便地使用离线编辑客户端编辑好文章，然后直接上传到 blog 系统进行发布。豆子目前正在进行的一个项目，OrbitsWriter 就是做得类似的工作。尽管完成度不高，但是 XML-RPC 一节已经调通。如果对该项目有任何建议或意见，可以在 GitHub 上找到项目地址。本文所叙述的实现，即是豆子用在 OrbitsWriter 中的代码。如果需要，完全可以很方便直接从中分离开来。
Qt/QML编程之路：D-BUS进程间通信（4）
码农17年的博客
04-19 745
system bus有点像system service系统服务，使用的话直接调用就好了。而session bus会话总线也是类似service的方式提供接口服务。Qt/QML最适合于一些触摸的嵌入式界面设计，那么GUI界面怎么与底层的设备通信，怎么与一个系统内其他模块通信的呢？Inter-Process Communication (IPC)就是进程间通信。最早的d-bus来自于redhat linux的一个项目。
Qt 进程间共享内存通信及同步问题。
dxa572862121的博客
03-21 3090
文章目录序言进程间通讯方式使用原因共享内存通讯的几个问题解决问题Qt 同步信号量代码示例单向主从通讯服务端进程发送server.hserver.cpp客户端进程接收client.hclient.cpp运行结果双向全工通讯服务端server.hserver.cpp客户端client.hclient.cpp 序言 本文只对共享内存通讯做扩展启发，所示代码，并不能用于实际开发，需要自己稍作修改。 进程间...
Qt Remote Object（QtRO）实现进程间通信——遥控小车（一）
斧冰
07-05 2692
Q-Bus的官方例子是个遥控小车 在windows上自己手动编译了dbus，但还是跑不起来，在搜索Qt进程通信方式的时候，无意中看到Qt Remote Object（QtRO），这种方式支持跨进程的信号与槽，就尝试着用QtRO来改造这个遥控小车，让它跑起来。 看看我们的运行效果： 最后发现用QtRO其实更好用，前提是你的Qt版本是5.9及以上，如果不是的话，考虑用QLocalSocket和QLocalServer来实现（同一台电脑，如果是不同电脑，就用QTcpServer和QTcpSocket来实现，或
Qt编程核心技术
feitian542的专栏
05-15 6994
1　Qt概述 Qt是一个跨平台的C++图形用户界面库，由挪威TrollTech公司出品，目前包括Qt/X11， 基于Framebuffer的Qt Embedded，快速开发工具Qt Designer，国际化工具Qt Linguist 等，Qt支持Unix系统及Linux，还支持WinNT/Win2k，Win95/98平台。Qt的良好封装机制使得Qt的模块化程度非常高，可重用性较好，对于用户开发来说是非常方便的。Qt API和开发工具对所有支持平台都是一致的，从而可以进行独立于平台的程序开发和配置。它使得跨平
Qt线程/进程间通讯
weixin_42868530的博客
07-06 4064
Qt线程、进程间通信方法详解
从零开始实现RPC框架 - RPC原理及实现
热门推荐
Ricky
01-19 4万+
RPC概述RPC(Remote Procedure Call)即远程过程调用，允许一台计算机调用另一台计算机上的程序得到结果，而代码中不需要做额外的编程，就像在本地调用一样。现在互联网应用的量级越来越大，单台计算机的能力有限，需要借助可扩展的计算机集群来完成，分布式的应用可以借助RPC来完成机器之间的调用。RPC框架原理在RPC框架中主要有三个角色：Provider、Consumer和Registr
qt udp tcp代替RPC(一)
qianbo042311的博客
09-24 1616
是可以的，这个分为两种情况，一种是局域网，一种是在云端，作为云端服务端记住IP和端口，发送心跳，局域网里面没有问题，在云端不一定能维持链接，断开时可以重新启动udp，再发送心跳。其他工作我们可以使用二进制来代替json方式的发送，不过自己解析需要花时间，确实没有RPC工具来得方便，不过很多工作，我们可以使用调用脚本 lua 的方式来做。tcp 链接和udp链接类似，没有多大区别，不过，传输层tcp协议拥有传输控制方法，拥塞控制和丢包重传机制，udp是没有的，以下是简单的启动方法。udp这里收到了数据打印。
RPC进程通信小模型
独孤龙城的专栏
11-20 1458
这几天因为工作的需要，学习了一下RPC进程通信，RPC确实是个好东西啊，
Qt程序与非Qt程序的共享内存/信号量通信
遛遛马，务务农
04-20 723
共享内存的key需要通过以上函数来设置, 对于两个Qt程序来说,使用setkey设置同一个字符串即可,而对于Qt与非Qt程序通信来说,,需要使用setNativekey. 对Qt程序需要传入一个字符串const QString &key, 而非Qt程序(比如C程序)一般需要使用ftok来创建key值,而ftok的返回值为int类型,非字符串类型,此时Qt程序的setNativekey因参数类型不匹配, 不能建立起与C程序的桥梁,进而无法实现共享内存通信.对于信号量,Qt提供。
Qt——实现两个Qt程序进行本地通信套接字（TCP）
m0_49474265的博客
06-17 935
基于VS2019、Qt5.15.5，纯代码实现两个Qt程序进行本地通信套接字（TCP/IP或UDP）。
java进程间通信rpc_进程间通信知识
weixin_33895547的博客
02-17 283
v同主机进程间的数据交互机制：无名管道(pipe)、有名管道(fifo)、消息队列(messagqueue)、共享内存(sharememory)v同主机进程间的同步机制：信号量(semaphore)v同主机进程间的异步机制：信号(signal)v网络主机间数据交互机制：套接口(socket)5.1同一主机间的进程通信5.1.1、Unix进程通信方式5.1.1.1、无名管道无名管道是一种专门用来...
qt 进程间通讯 消息队列
08-31
在Linux下，QT可以使用mqueue消息队列实现进程间通信。为了使用消息队列，需要包含头文件#include <mqueue.h>，并在pro文件中添加编译选项LIBS = -lrt。消息队列具有以下特征：可以设置最大消息个数和每个消息的最大字节数，可以向消息队列中写入多条消息，而其他进程读取一条消息后，消息队列就会删除这条消息。 要发送消息到消息队列中，可以使用mq_send函数。该函数的原型是int mq_send(mqd_t mqdes, const char *ptr, size_t len, unsigned int prio)。其中，mqdes是打开消息队列时返回的消息队列描述符，ptr是指向要发送的消息的指针，len是消息的长度，prio是消息的优先级。 在应用中使用消息队列进行进程间通信，可以发现消息队列具有强大的功能。它可以方便地管理线程，实现互斥量和条件变量等功能。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* [Qt实现IPC进程间通信-mqueue消息队列](https://blog.csdn.net/weixin_40355471/article/details/113178838)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *3* [进程间通信之深入消息队列的详解](https://download.csdn.net/download/weixin_38517212/14872197)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

HX科技

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值