有没有好的、简单的用于进程间调用的 RPC 库？

Question

我需要使用内置 C++ 类型的参数从客户端进程向服务器进程发送一个（可能是一个）简单的单向命令（因此序列化非常简单）。 C++、Windows XP+。

我正在寻找一个不需要复杂配置、提供简单界面、不需要数小时到数天学习并且没有商业使用限制的库。简单问题的简单解决方案。

Boost.Interprocess 对于这个简单的任务来说太低级了，因为它不提供RPC接口。套接字可能也有点过分了，因为我不需要在机器之间进行通信。 DCOM、CORBA 等也是如此。命名管道？从未使用过它们，有什么好的 WinAPI 库吗？开放MPI？

Answer 1

我不认为套接字真的太过分了。所有替代方案都有自己的问题，并且套接字比命名管道、共享内存等得到更好的支持，因为几乎每个人都在使用它们。本地系统上套接字的速度可能不是问题。

Apache Thrift：

http://incubator.apache.org/thrift/

有一些 RPC 实现围绕 Google 的 protobuf 库作为封送机制：

https:/ /github.com/google/protobuf/blob/master/docs/third_party.md#rpc-implementations

有 XML-RPC：

http://xmlrpc-c.sourceforge.net/

如果您的消息确实很简单，我可能会考虑使用 UDP 数据包，那么就无需管理连接。

Answer 2

您可能会喜欢 ZeroMQ 这样的东西。也许不像一个完整的 RPC，而是可以用来创建 RPC 的原始字节消息传递框架。它简单、轻便并且具有令人印象深刻的性能。您可以在其之上轻松实现 RPC。这是直接来自手册的示例服务器：

//
//  Hello World server in C++
//  Binds REP socket to tcp://*:5555
//  Expects "Hello" from client, replies with "World"
//
#include <zmq.hpp>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

int main () {
    //  Prepare our context and socket
    zmq::context_t context (1);
    zmq::socket_t socket (context, ZMQ_REP);
    socket.bind ("tcp://*:5555");

    while (true) {
        zmq::message_t request;

        //  Wait for next request from client
        socket.recv (&request);
        printf ("Received Hello");

        //  Do some 'work'
        sleep (1);

        //  Send reply back to client
        zmq::message_t reply (5);
        memcpy ((void *) reply.data (), "World", 5);
        socket.send (reply);
    }
    return 0;
}

此示例使用 tcp://*.5555，但如果您使用以下内容，则使用更高效的 IPC 技术：

socket.bind("ipc://route.to.ipc");

甚至更快的线程间协议：

socket.bind("inproc://path.for.client.to.connect");

Answer 3

如果您只需要支持 Windows，我会使用 Windows 内置 RPC，我已经写了两篇关于此的介绍性文章：

http://www.codeproject.com/KB/IP/r​​pcintro1.aspx
http://www.codeproject.com/KB/IP/r​​pcintro2.aspx

您可以使用 ncalrpc< /a> 协议，如果您只需要本地进程间通信。

Answer 4

Boost.MPI。简单、快速、可扩展。

#include <boost/mpi/environment.hpp>
#include <boost/mpi/communicator.hpp>
#include <iostream>
#include <sstream>
namespace mpi = boost::mpi;

int main(int argc, char* argv[]) 
{
  mpi::environment env(argc, argv);
  mpi::communicator world;

  std::stringstream ss;
  ss << "Hello, I am process " << world.rank() << " of " << world.size() << ".";

  world.send(1, 0, ss.str());
}

Answer 5

如果您仅在 Windows 上工作，并且确实需要 C++ 接口，请使用 COM/DCOM。它基于RPC（又基于DCE RPC）。

它使用起来非常简单——只要您花时间学习基础知识。

• ATL：http://msdn.microsoft.com/en- us/library/3ax346b7(VS.71).aspx
• 接口定义语言：http://msdn.microsoft.com/en-us/library/aa367091(VS.85).aspx

Answer 6

您可能甚至不需要图书馆。 Windows 在其核心 API (windows.h) 中内置了一个 IPC 机制。您基本上可以将 Windows 消息发布到不同进程主窗口的消息队列中。 Windows 甚至定义了一个标准消息来执行此操作：WM_COPYDATA。

• WM_COPYDATA 上的 MSDN 文档
• MSDN 演示代码
• 更多演示代码如下 StackOverflow response

---

发送过程基本上是：

• FindWindow
• 发送消息

接收进程（窗口）：

• 在 Vista 及更高版本上，必须使用 ChangeWindowsMessageEx
• 覆盖其 WindowProc
• 为了处理传入的WM_COPYDATA

Answer 7

我知道我们距离易于使用还很远。但当然您可以坚持使用 CORBA。例如 ACE/TAO

Answer 8

我听说 RPC 与 Raknet 很好而且很简单。

Answer 9

另外，您可以查看 msgpack-rpc

更新

我认为，虽然 Thrift/Protobuf 更灵活，但需要编写一些特定格式的代码。例如，Protobuf 需要一些 .proto 文件，可以使用包中的特定编译器进行编译，生成一些类。在某些情况下，它可能比代码的其他部分更困难。
msgpack-rpc 更简单。它不需要编写一些额外的代码。这是示例：

#include <iostream>

#include <msgpack/rpc/server.h>
#include <msgpack/rpc/client.h>

class Server: public msgpack::rpc::dispatcher {
public:
    typedef msgpack::rpc::request request_;

    Server() {};

    virtual ~Server() {};

    void dispatch(request_ req)
    try {
        std::string method;
        req.method().convert(&method);

        if (method == "id") {
            id(req);
        } else if (method == "name") {
            name(req);
        } else if (method == "err") {
            msgpack::type::tuple<> params;
            req.params().convert(¶ms);
            err(req);
        } else {
            req.error(msgpack::rpc::NO_METHOD_ERROR);
        }
    }
    catch (msgpack::type_error& e) {
        req.error(msgpack::rpc::ARGUMENT_ERROR);
        return;
    }
    catch (std::exception& e) {
        req.error(std::string(e.what()));
        return;
    }

    void id(request_ req) {
        req.result(1);
    }

    void name(request_ req) {
        req.result(std::string("name"));
    }

    void err(request_ req) {
        req.error(std::string("always fail"));
    }
};

int main() {
    // { run RPC server
    msgpack::rpc::server server;
    std::auto_ptr<msgpack::rpc::dispatcher> dispatcher(new Server);
    server.serve(dispatcher.get());
    server.listen("0.0.0.0", 18811);
    server.start(1);
    // }

    msgpack::rpc::client c("127.0.0.1", 18811);
    int64_t id = c.call("id").get<int64_t>();
    std::string name = c.call("name").get<std::string>();

    std::cout << "ID: " << id << std::endl;
    std::cout << "name: " << name << std::endl;

    return 0;
}

输出

ID: 1
name: name

您可以在这里找到更复杂的示例 https://github .com/msgpack/msgpack-rpc/tree/master/cpp/test

Answer 10

我正在使用适用于 Windows 的 XmlRpc C++ 在这里找到

真的很容易使用:) 但唯一的副作用是这只是只是一个客户！

Answer 11

还有 Microsoft Messaging Queueing，当所有进程都在本地计算机上时，使用起来相当简单。

Answer 12

进程间通信最简单的解决方案是使用文件系统。请求和响应可以写入临时文件。您可以制定请求和响应文件的命名约定。

这不会给你最好的性能，但也许已经足够好了。