用于进程间调用的任何好的和简单的 RPC 库？ [关闭]

Question

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

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

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

Answer 1

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

还有 Apache Thrift：

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

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

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/rpcintro1.aspx
http://www.codeproject.com/KB/IP/rpcintro2.aspx

如果你只需要本地进程间通信，你可以使用ncalrpc协议。

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 demo code
• 更多演示代码如下 StackOverflow response

---

发送过程基本上是这样的：

• FindWindow
• SendMessage

接收过程（窗口）：

• 在 Vista 和更高版本上必须使用 ChangeWindowsMessageEx 修改其消息过滤器
• 覆盖其WindowProc
• 为了处理传入的WM_COPYDATA

Answer 7

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

Answer 8

有人告诉我，带有Raknet 的 RPC 既好又简单。

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

我正在使用 XmlRpc C++ for Windows found here

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

Answer 11

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

Answer 12

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

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