后端技术_gRPC的内部组件关联
gRPC基本原理
- 基于protobuf
- 基于HTTP 2.0
- 基于TCP
protobuf
1 | // xxxx.proto |
gRPC模式
- 一元
- 客户端 –请求–> 服务端
- 服务端 –响应–> 客户端
- 服务端流RPC模式
- 客户端 –请求–> 服务端
- 服务端 –响应、响应–> 客户端（多次回数据）
- 客户端流RPC模式
- 客户端 –请求、请求–> 服务端
- 服务端 –响应–> 客户端
- 双向流RPC模式
- 客户端 –请求、请求–> 服务端
- 服务端 –响应、响应–> 客户端
流模式实践
- 以下均为同步流程
- 注意如果读写过于耗时，尽量开额外的读写线程
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
45syntax = "proto3";
option java_multiple_files = true;
option java_package = "io.grpc.examples.routeguide";
option java_outer_classname = "RouteGuideProto";
option objc_class_prefix = "RTG";
package routeguide;
// 实现一个输入位置，返回著名景点的功能
service RouteGuide {
rpc GetFeature(Point) returns (Feature) {} // 一元模式
rpc ListFeatures(Rectangle) returns (stream Feature) {} // 服务端流RPC模式
rpc RecordRoute(stream Point) returns (RouteSummary) {} // 客户端流RPC模式
rpc RouteChat(stream RouteNote) returns (stream RouteNote) {} // 双向流RPC模式
}
message Point { // 经纬度
int32 latitude = 1; // 纬度
int32 longitude = 2; // 经度
}
message Rectangle { // 区域
// One corner of the rectangle.
Point lo = 1;
// The other corner of the rectangle.
Point hi = 2;
}
message Feature {
// The name of the feature. 特征名
string name = 1;
// The point where the feature is detected. 坐标
Point location = 2;
}
message RouteNote {
// The location from which the message is sent.
Point location = 1;
// The message to be sent.
string message = 2;
}
message RouteSummary {
// The number of points received.
int32 point_count = 1;
// The number of known features passed while traversing the route.
int32 feature_count = 2;
// The distance covered in metres.
int32 distance = 3; // 距离
// The duration of the traversal in seconds.
int32 elapsed_time = 4;
}
一元
1 | // 客户端 |
服务端流RPC模式
1 | // 客户端 |
客户端流RPC模式
1 | // 客户端 |
双向流RPC模式
1 | // 客户端 |
HTTP2.0
- http 1.0 一次请求一次响应
- http 1.1 允许使用pipeline，多次请求多次响应，但是响应必须按照请求的顺序，不然产生异常
- http 2.0 支持二进制的乱序模式，顺序可以调换
gRPC实践
同步与异步
同步
- client
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86#
#
#
#
#
#
#
#
#
using grpc::Channel;
using grpc::ClientContext;
using grpc::Status;
using helloworld::Greeter;
using helloworld::HelloReply;
using helloworld::HelloRequest;
class GreeterClient {
public:
GreeterClient(std::shared_ptr<Channel> channel)
: stub_(Greeter::NewStub(channel)) {}
// Assembles the client's payload, sends it and presents the response back
// from the server.
std::string SayHello(const std::string& user) {
// Data we are sending to the server.
HelloRequest request;
request.set_name(user);
// Container for the data we expect from the server.
HelloReply reply;
// Context for the client. It could be used to convey extra information to
// the server and/or tweak certain RPC behaviors.
ClientContext context;
// The actual RPC.
Status status = stub_->SayHello(&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<Greeter::Stub> stub_;
};
int main(int argc, char** argv) {
std::string target_str;
std::string arg_str("--target");
if (argc > 1) {
std::string arg_val = argv[1];
size_t start_pos = arg_val.find(arg_str);
if (start_pos != std::string::npos) {
start_pos += arg_str.size();
if (arg_val[start_pos] == '=') {
target_str = arg_val.substr(start_pos + 1);
} else {
std::cout << "The only correct argument syntax is --target="
<< std::endl;
return 0;
}
} else {
std::cout << "The only acceptable argument is --target=" << std::endl;
return 0;
}
} else {
target_str = "localhost:50051"; // grpc地址
}
// 没有进行认证
GreeterClient greeter(
grpc::CreateChannel(target_str, grpc::InsecureChannelCredentials()));
std::string user("world");
std::string reply = greeter.SayHello(user);
std::cout << "Greeter received: " << reply << std::endl;
return 0;
} - server
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
58
59
60
61
62
63#
#
#
#
#
#
#
#
#
#
#
using grpc::Server;
using grpc::ServerBuilder;
using grpc::ServerContext;
using grpc::Status;
using helloworld::Greeter;
using helloworld::HelloReply;
using helloworld::HelloRequest;
// Logic and data behind the server's behavior.
class GreeterServiceImpl final : public Greeter::Service {
Status SayHello(ServerContext* context, const HelloRequest* request,
HelloReply* reply) override {
std::string prefix("Hello ");
reply->set_message(prefix + request->name());
return Status::OK;
}
};
void RunServer() {
std::string server_address("0.0.0.0:50051"); // 地址
GreeterServiceImpl service;
grpc::EnableDefaultHealthCheckService(true);
grpc::reflection::InitProtoReflectionServerBuilderPlugin();
ServerBuilder builder;
// 开启同步多进程方式
builder.SetSyncServerOption(ServerBuilder::MIN_POLLERS, 4);
builder.SetSyncServerOption(ServerBuilder::MAX_POLLERS, 8);
// 最少4个epoll，最多8个epoll
// 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 | # |
异步客户端
1 | # |