gRPC 实现多客户端之间通过服务端转发通信

要实现多个客户端之间的通信通过服务端进行转发，可以使用 gRPC 来实现。

首先，需要定义一个 gRPC 服务，包含一个转发方法。在 .proto 文件中定义如下：

syntax = "proto3";

service ForwardService {
  rpc ForwardMessage (stream Message) returns (stream Message) {}
}

message Message {
  string content = 1;
}

然后，根据上面的 .proto 文件生成对应的 C++ 代码，可以使用 protobuf 的 protoc 工具来生成代码。

接下来，在服务端实现转发方法。在服务端的代码中，需要实现 ForwardService::ForwardMessage 方法，该方法接收一个输入流和输出流，可以将接收到的消息转发给其他客户端。

#include <iostream>
#include <memory>
#include <string>
#include <grpcpp/grpcpp.h>
#include "forward_service.grpc.pb.h"

using grpc::Server;
using grpc::ServerBuilder;
using grpc::ServerContext;
using grpc::Status;
using forward::ForwardService;
using forward::Message;

class ForwardServiceImpl final : public ForwardService::Service {
  Status ForwardMessage(ServerContext* context, grpc::ServerReaderWriter<Message, Message>* stream) override {
    Message message;
    while (stream->Read(&message)) {
      // 在这里进行转发逻辑，将收到的消息转发给其他客户端
      // ...
      
      // 转发完成后，将消息写回输出流
      stream->Write(message);
    }
    return Status::OK;
  }
};

void RunServer() {
  std::string server_address('0.0.0.0:50051');
  ForwardServiceImpl service;

  ServerBuilder builder;
  builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());
  builder.RegisterService(&service);

  std::unique_ptr<Server> server(builder.BuildAndStart());
  std::cout << "Server listening on " << server_address << std::endl;
  server->Wait();
}

int main() {
  RunServer();
  return 0;
}

最后，客户端代码可以使用 gRPC 提供的 C++ 客户端库来实现。客户端需要连接到服务端，并发送消息到服务端的转发方法中，然后接收服务端转发的消息。

#include <iostream>
#include <memory>
#include <string>
#include <grpcpp/grpcpp.h>
#include "forward_service.grpc.pb.h"

using grpc::Channel;
using grpc::ClientContext;
using grpc::Status;
using forward::ForwardService;
using forward::Message;

class ForwardClient {
 public:
  ForwardClient(std::shared_ptr<Channel> channel)
      : stub_(ForwardService::NewStub(channel)) {}

  void ForwardMessage(const std::string& content) {
    Message request;
    request.set_content(content);

    ClientContext context;
    std::shared_ptr<grpc::ClientReaderWriter<Message, Message>> stream(
        stub_->ForwardMessage(&context));

    stream->Write(request);
    stream->WritesDone();

    Message response;
    while (stream->Read(&response)) {
      // 处理服务端转发的消息
      std::cout << "Received: " << response.content() << std::endl;
    }

    Status status = stream->Finish();
    if (!status.ok()) {
      std::cout << "ForwardMessage rpc failed." << std::endl;
    }
  }

 private:
  std::unique_ptr<ForwardService::Stub> stub_;
};

int main() {
  std::string server_address("localhost:50051");
  ForwardClient client(grpc::CreateChannel(server_address, grpc::InsecureChannelCredentials()));

  // 发送消息到服务端进行转发
  client.ForwardMessage("Hello from client");

  return 0;
}

以上就是使用 gRPC 实现多个客户端之间通过服务端进行转发的一个示例。当有新的客户端连接到服务端时，服务端可以创建一个新的线程来处理该客户端的转发请求，实现多个客户端之间的通信。