gRPC C++ windows程序实践(二)1. 编写proto文件2. 生成pb文件3. 创建gRPC工程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
syntax = "proto3";

package pandora;

// The greeting service definition.
service GreeterEx {
  // Sends a greeting
  rpc Say (Request) returns (Reply) {}
}

// The request message
message Request {
  string content = 1;
}

// The response message containing the greetings
message Reply {
  string message = 1;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#include <iostream>
#include <memory>
#include <string>

#include <grpcpp/ext/proto_server_reflection_plugin.h>
#include <grpcpp/grpcpp.h>
#include <grpcpp/health_check_service_interface.h>

#include "example.grpc.pb.h"

using grpc::Server;
using grpc::ServerBuilder;
using grpc::ServerContext;
using grpc::Status;
using pandora::GreeterEx;
using pandora::Reply;
using pandora::Request;

class GreeterServiceImpl final : public GreeterEx::Service {
    Status Say(ServerContext* context, const Request* request,
        Reply* reply) override {
        reply->set_message(request->content() + "world");
        return Status::OK;
    }
};

void RunServer() {
    std::string server_address("localhost:50000");
    GreeterServiceImpl service;

    grpc::EnableDefaultHealthCheckService(true);
    grpc::reflection::InitProtoReflectionServerBuilderPlugin();
    ServerBuilder builder;
    // Listen on the given address without any authentication mechanism.
    builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());
    // Register "service" as the instance through which we'll communicate with
    // clients. In this case it corresponds to an *synchronous* service.
    builder.RegisterService(&service);
    // Finally assemble the server.
    std::unique_ptr<Server> server(builder.BuildAndStart());
    std::cout << "Server listening on " << server_address << std::endl;

    // Wait for the server to shutdown. Note that some other thread must be
    // responsible for shutting down the server for this call to ever return.
    server->Wait();
}

int main(int argc, char** argv) {
    RunServer();

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#include <iostream>
#include <memory>
#include <string>

#include <grpcpp/grpcpp.h>

#include "example.grpc.pb.h"

using grpc::Channel;
using grpc::ClientContext;
using grpc::Status;
using pandora::GreeterEx;
using pandora::Reply;
using pandora::Request;

class GreeterClient {
public:
    GreeterClient(std::shared_ptr<Channel> channel)
        : stub_(GreeterEx::NewStub(channel)) {}

    std::string Say(const std::string& content) {
        Request request;
        request.set_content(content);

        Reply reply;

        ClientContext context;

        // The actual RPC.
        Status status = stub_->Say(&context, request, &reply);

        // Act upon its status.
        if (status.ok()) {
            return reply.message();
        }
        else {
            std::cout << status.error_code() << ": " << status.error_message()
                << std::endl;
            return "RPC failed";
        }
    }

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

int main(int argc, char** argv) {

    GreeterClient greeter(
        grpc::CreateChannel("localhost:50000", grpc::InsecureChannelCredentials()));
    std::string reply = greeter.Say("hello");
    std::cout << "Greeter received: " << reply << std::endl;
    char c = 0;
    std::cin >> c;

    return 0;
}