1
# HTTP/1.x 队头阻塞影响
2
request_1_time = 100  # ms，慢请求
3
request_2_time = 10   # ms，快请求
4
request_3_time = 10   # ms，快请求
5

6
# HTTP/1.x 串行处理
7
total_time_v1 = request_1_time + request_2_time + request_3_time
8
print(f"HTTP/1.x 总耗时: {total_time_v1} ms")
9

10
# 理想情况（并行）
11
total_time_parallel = max(request_1_time, request_2_time, request_3_time)
12
print(f"并行理想耗时: {total_time_parallel} ms")
13

14
print(f"性能差距: {total_time_v1 / total_time_parallel}x")
15

16
# 输出:
17
# HTTP/1.x 总耗时: 120 ms
18
# 并行理想耗时: 100 ms
19
# 性能差距: 1.2x（简单场景差距不大，实际影响更显著）

1
POST /api/users HTTP/1.1
2
Host: api.example.com
3
Content-Type: application/json
4
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
5
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64)...
6
Accept: application/json
7
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8
8
Cookie: session=abc123; token=xyz789; ...

1
# 头部压缩效果示例
2
original_header = """
3
POST /api/users HTTP/1.1
4
Host: api.example.com
5
Content-Type: application/json
6
Authorization: Bearer eyJhbGciOiJIUzI1NiIs...
7
User-Agent: gRPC-Java/1.50.0
8
"""
9

10
# HTTP/1.x 头部大小（估算）
11
http1_size = len(original_header)  # 约 200 字节
12
print(f"HTTP/1.x 头部大小: {http1_size} 字节")
13

14
# HTTP/2 首次传输（建立动态字典）
15
http2_first = 80  # 约 80 字节
16
print(f"HTTP/2 首次传输: {http2_first} 字节")
17

18
# HTTP/2 后续传输（动态字典索引）
19
http2_subsequent = 15  # 仅传输索引和差值
20
print(f"HTTP/2 后续传输: {http2_subsequent} 字节")
21

22
print(f"压缩比: {http1_size / http2_subsequent:.1f}x")
23
# 输出: 压缩比: 13.3x

1
Method: POST
2
Path: /{package}.{service}/{method}
3
Headers:
4
  :scheme: https
5
  :method: POST
6
  :path: /example.UserService/GetUser
7
  :authority: api.example.com
8
  content-type: application/grpc
9
  grpc-encoding: gzip
10
  grpc-timeout: 5S
11
  grpc-message-type: example.GetUserRequest
12
Body: <Protobuf 编码的请求>

1
Headers:
2
  :status: 200
3
  content-type: application/grpc
4
  grpc-encoding: identity
5
  grpc-status: 0  # OK
6
  grpc-message: OK
7
Body: <Protobuf 编码的响应>

1
// 定义消息
2
message User {
3
  int32 id = 1;        // 字段编号 1
4
  string name = 2;     // 字段编号 2
5
  string email = 3;    // 字段编号 3
6
}

1
每个字段 = Tag + Value
2
Tag = (field_number << 3) | wire_type
3

4
示例：id = 150
5
Tag = (1 << 3) | 0 = 0x08
6
Value = 150 = 0x96 0x01 (Varint 编码)
7
编码结果: 08 96 01

1
// JSON 编码（约 80 字节）
2
{
3
  "id": 150,
4
  "name": "Alice",
5
  "email": "alice@example.com"
6
}

1
// Protobuf 编码（约 25 字节）
2
08 96 01 12 05 41 6c 69 63 65 1a 0f 61 6c 69 63 65 40 65 78 61 6d 70 6c 65 2e 63 6f 6d

1
# 大小对比
2
json_size = 80  # 字节
3
protobuf_size = 25  # 字节
4

5
print(f"JSON 大小: {json_size} 字节")
6
print(f"Protobuf 大小: {protobuf_size} 字节")
7
print(f"压缩比: {json_size / protobuf_size:.1f}x")
8

9
# 输出:
10
# JSON 大小: 80 字节
11
# Protobuf 大小: 25 字节
12
# 压缩比: 3.2x

1
// 服务定义
2
rpc ListUsers(ListUsersRequest) returns (stream User);
3

4
// 实现示例
5
public void listUsers(ListUsersRequest request, StreamObserver<User> responseObserver) {
6
    for (User user : userRepository.findAll()) {
7
        responseObserver.onNext(user);  // 发送每条数据
8
    }
9
    responseObserver.onCompleted();  // 结束流
10
}

1
// 服务定义
2
rpc UploadFile(stream FileChunk) returns (UploadResponse);
3

4
// 客户端实现
5
StreamObserver<FileChunk> requestObserver = asyncStub.uploadFile(new StreamObserver<UploadResponse>() {
6
    @Override
7
    public void onNext(UploadResponse response) {
8
        System.out.println("Upload completed: " + response.getFilePath());
9
    }
10
    // ...
11
});
12

13
// 发送多个文件块
14
for (FileChunk chunk : fileChunks) {
15
    requestObserver.onNext(chunk);
16
}
17
requestObserver.onCompleted();

1
// 服务定义
2
rpc Chat(stream ChatMessage) returns (stream ChatMessage);

1
// 定义接口（需要手写文档）
2
// POST /api/users
3
// Content-Type: application/json
4
// { "name": "Alice", "email": "alice@example.com" }
5

6
// 客户端调用
7
HttpClient client = HttpClient.newHttpClient();
8
HttpRequest request = HttpRequest.newBuilder()
9
    .uri(URI.create("http://api.example.com/api/users"))
10
    .header("Content-Type", "application/json")
11
    .POST(HttpRequest.BodyPublishers.ofString(
12
        "{\"name\":\"Alice\",\"email\":\"alice@example.com\"}"))
13
    .build();
14

15
HttpResponse<String> response = client.send(request,
16
    HttpResponse.BodyHandlers.ofString());
17
User user = objectMapper.readValue(response.body(), User.class);

1
// 定义接口（IDL）
2
service UserService {
3
  rpc CreateUser(CreateUserRequest) returns (User);
4
}

1
// 客户端调用（自动生成代码）
2
UserServiceGrpc.UserServiceBlockingStub stub = UserServiceGrpc.newBlockingStub(channel);
3
CreateUserRequest request = CreateUserRequest.newBuilder()
4
    .setName("Alice")
5
    .setEmail("alice@example.com")
6
    .build();
7
User user = stub.createUser(request);

1
// 客户端设置超时
2
UserRequest request = UserRequest.newBuilder().setId(1).build();
3
User user = stub.withDeadlineAfter(5, TimeUnit.SECONDS)
4
    .getUser(request);

1
// 客户端拦截器
2
public class AuthInterceptor implements ClientInterceptor {
3
    @Override
4
    public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
5
            MethodDescriptor<ReqT, RespT> method,
6
            CallOptions callOptions,
7
            Channel next) {
8
        return new ForwardingClientCall.SimpleForwardingClientCall<>(
9
                next.newCall(method, callOptions)) {
10
            @Override
11
            public void start(Listener<RespT> responseListener, Metadata headers) {
12
                headers.put(Metadata.Key.of("authorization", Metadata.ASCII_STRING_MARSHALLER),
13
                        "Bearer " + getToken());
14
                super.start(responseListener, headers);
15
            }
16
        };
17
    }
18
}

1
// 标准健康检查服务
2
service Health {
3
  rpc Check(HealthCheckRequest) returns (HealthCheckResponse);
4
}
5

6
message HealthCheckResponse {
7
  enum ServingStatus {
8
    UNKNOWN = 0;
9
    SERVING = 1;
10
    NOT_SERVING = 2;
11
  }
12
  ServingStatus status = 1;
13
}

1
# 使用 grpcurl 调用 gRPC 服务
2
grpcurl -plaintext \
3
  -d '{"id": 1}' \
4
  localhost:50051 \
5
  example.UserService/GetUser