20K Java+AI 岗位高频考点 — gRPC是微服务间高性能通信的事实标准。覆盖Protobuf、四种通信模式、拦截器、负载均衡、与REST对比、Spring Boot集成等。
gRPC是Google开源的高性能RPC框架,基于HTTP/2 + Protobuf。
性能优势:
性能对比:
| 指标 | gRPC | REST+JSON |
|---|---|---|
| 序列化速度 | ~1000 ns | ~10000 ns |
| 消息体积 | 小(二进制) | 大(文本) |
| 连接复用 | HTTP/2多路复用 | HTTP/1.1需Keep-Alive |
| 流式支持 | 原生支持 | 需SSE/WebSocket |
Protobuf是Google的二进制序列化格式,使用.proto文件定义数据结构:
syntax = "proto3";
package order;
option java_multiple_files = true;
option java_package = "com.example.grpc.order";
service OrderService {
rpc GetOrder(OrderRequest) returns (OrderResponse);
rpc ListOrders(ListRequest) returns (stream OrderResponse); // 服务端流
rpc UploadOrders(stream OrderRequest) returns (BatchResponse); // 客户端流
rpc Chat(stream ChatMessage) returns (stream ChatMessage); // 双向流
}
message OrderRequest {
int64 order_id = 1;
}
message OrderResponse {
int64 id = 1;
string user_name = 2;
double amount = 3;
OrderStatus status = 4;
repeated OrderItem items = 5; // 列表
map<string, string> metadata = 6; // Map
oneof payment { // 联合类型
string alipay_id = 7;
string wechat_id = 8;
}
}
enum OrderStatus {
UNKNOWN = 0;
CREATED = 1;
PAID = 2;
SHIPPED = 3;
}
message OrderItem {
int64 product_id = 1;
int32 quantity = 2;
double price = 3;
}
编码原理:
field_number + wire_type(Tag)标识一元RPC(Unary):最简单,类似HTTP请求-响应
OrderResponse response = blockingStub.getOrder(OrderRequest.newBuilder()
.setOrderId(123L).build());
服务端流(Server Streaming):客户端发一个请求,服务端返回流
Iterator<OrderResponse> it = blockingStub.listOrders(
ListRequest.newBuilder().setUserId(1L).build());
while (it.hasNext()) {
OrderResponse order = it.next();
// 处理每个订单
}
客户端流(Client Streaming):客户端发流,服务端返回一个响应
StreamObserver<BatchResponse> responseObserver = new StreamObserver<>() {
@Override public void onNext(BatchResponse resp) { /* 处理响应 */ }
@Override public void onError(Throwable t) { /* 处理错误 */ }
@Override public void onCompleted() { /* 完成 */ }
};
StreamObserver<OrderRequest> requestObserver = asyncStub.uploadOrders(responseObserver);
requestObserver.onNext(order1);
requestObserver.onNext(order2);
requestObserver.onCompleted();
双向流(Bidirectional Streaming):双方都可以随时发送
StreamObserver<ChatMessage> requestObserver = asyncStub.chat(responseObserver);
// 异步发送消息
requestObserver.onNext(ChatMessage.newBuilder().setText("Hello").build());
Channel:到服务端的虚拟连接(HTTP/2连接),线程安全可复用。
Stub:客户端代理,基于Channel创建。
// ManagedChannel - 长连接
ManagedChannel channel = ManagedChannelBuilder
.forAddress("localhost", 9090)
.usePlaintext() // 非TLS(开发用)
.defaultLoadBalancingPolicy("round_robin")
.keepAliveTime(30, TimeUnit.SECONDS)
.build();
// 三种Stub
OrderServiceGrpc.OrderServiceBlockingStub blockingStub = // 同步阻塞
OrderServiceGrpc.newBlockingStub(channel);
OrderServiceGrpc.OrderServiceFutureStub futureStub = // Future异步
OrderServiceGrpc.newFutureStub(channel);
OrderServiceGrpc.OrderServiceStub asyncStub = // 完全异步
OrderServiceGrpc.newStub(channel);
客户端拦截器:
public class AuthClientInterceptor implements ClientInterceptor {
@Override
public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
MethodDescriptor<ReqT, RespT> method, CallOptions options, Channel next) {
return new ForwardingClientCall.SimpleForwardingClientCall<ReqT, RespT>(
next.newCall(method, options)) {
@Override
public void start(Listener<RespT> responseListener, Metadata headers) {
headers.put(Metadata.Key.of("authorization", Metadata.ASCII_STRING_MARSHALLER),
"Bearer " + tokenService.getToken());
super.start(responseListener, headers);
}
};
}
}
服务端拦截器:
public class LoggingServerInterceptor implements ServerInterceptor {
@Override
public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
String method = call.getMethodDescriptor().getFullMethodName();
long start = System.currentTimeMillis();
log.info("gRPC call started: {}", method);
return new ForwardingServerCallListener.SimpleForwardingServerCallListener<ReqT>(
next.startCall(call, headers)) {
@Override
public void onComplete() {
long duration = System.currentTimeMillis() - start;
log.info("gRPC call completed: {} in {}ms", method, duration);
super.onComplete();
}
};
}
}
public class ExceptionInterceptor implements ServerInterceptor {
@Override
public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
return new ForwardingServerCallListener.SimpleForwardingServerCallListener<ReqT>(
next.startCall(call, headers)) {
@Override
public void onHalfClose() {
try {
super.onHalfClose();
} catch (BusinessException e) {
call.close(Status.INVALID_ARGUMENT
.withDescription(e.getMessage())
.asRuntimeException(), headers);
} catch (Exception e) {
call.close(Status.INTERNAL
.withDescription("Internal server error")
.asRuntimeException(), headers);
}
}
};
}
}
// 客户端设置超时
OrderResponse response = blockingStub
.withDeadlineAfter(5, TimeUnit.SECONDS)
.getOrder(request);
// 服务端检查Deadline
@Override
public void getOrder(OrderRequest request, StreamObserver<OrderResponse> observer) {
if (Context.current().isCancelled()) {
observer.onError(Status.CANCELLED.asRuntimeException());
return;
}
// 处理请求
}
Deadline传播:gRPC自动将Deadline传播到下游调用,避免级联超时。
客户端负载均衡(内置):
round_robin:轮询pick_first:选第一个(默认)
ManagedChannel channel = ManagedChannelBuilder
.forTarget("dns:///my-service:9090")
.defaultLoadBalancingPolicy("round_robin")
.build();
结合注册中心:
// 自定义NameResolver
public class NacosNameResolver extends NameResolver {
@Override
public void start(Listener listener) {
// 订阅Nacos服务变更
namingService.subscribe("order-service", event -> {
List<Instance> instances = namingService.selectInstances("order-service", true);
List<EquivalentAddressGroup> addresses = instances.stream()
.map(i -> new EquivalentAddressGroup(
new InetSocketAddress(i.getIp(), i.getPort())))
.collect(Collectors.toList());
listener.onAddresses(addresses, Attributes.EMPTY);
});
}
}
# K8s Service - Headless Service(返回所有Pod IP)
apiVersion: v1
kind: Service
metadata:
name: order-service
spec:
clusterIP: None # Headless
selector:
app: order-service
ports:
- port: 9090
targetPort: 9090
// DNS解析Headless Service返回所有Pod IP
ManagedChannel channel = ManagedChannelBuilder
.forTarget("dns:///order-service.default.svc.cluster.local:9090")
.defaultLoadBalancingPolicy("round_robin")
.usePlaintext()
.build();
<!-- grpc-spring-boot-starter -->
<dependency>
<groupId>net.devh</groupId>
<artifactId>grpc-server-spring-boot-starter</artifactId>
<version>3.1.0.RELEASE</version>
</dependency>
<dependency>
<groupId>net.devh</groupId>
<artifactId>grpc-client-spring-boot-starter</artifactId>
<version>3.1.0.RELEASE</version>
</dependency>
# application.yml
grpc:
server:
port: 9090
enable-keep-alive: true
keep-alive-time: 30s
client:
order-service:
address: 'dns:///order-service:9090'
negotiationType: plaintext
// 服务端
@GrpcService
public class OrderGrpcService extends OrderServiceGrpc.OrderServiceImplBase {
@Autowired OrderService orderService;
@Override
public void getOrder(OrderRequest request, StreamObserver<OrderResponse> observer) {
Order order = orderService.getById(request.getOrderId());
observer.onNext(toProto(order));
observer.onCompleted();
}
}
// 客户端
@Service
public class OrderClient {
@GrpcClient("order-service")
OrderServiceGrpc.OrderServiceBlockingStub orderStub;
public OrderDTO getOrder(Long id) {
OrderResponse resp = orderStub.getOrder(
OrderRequest.newBuilder().setOrderId(id).build());
return toDTO(resp);
}
}
TLS双向认证:
// 服务端TLS
serverBuilder.useTransportSecurity(
new File("server.crt"), new File("server.key"));
// 客户端TLS
channelBuilder.useTransportSecurity()
.sslContext(GrpcSslContexts.forClient()
.trustManager(new File("ca.crt"))
.keyManager(new File("client.crt"), new File("client.key"))
.build());
Token认证:通过拦截器在Metadata中传递JWT Token。
| 维度 | gRPC | REST |
|---|---|---|
| 协议 | HTTP/2 | HTTP/1.1/2 |
| 序列化 | Protobuf(二进制) | JSON(文本) |
| 接口定义 | .proto文件(强类型) | OpenAPI/Swagger |
| 流式通信 | 原生四种模式 | 需SSE/WebSocket |
| 代码生成 | 自动生成客户端/服务端 | 手动编写或OpenAPI Generator |
| 浏览器支持 | 需gRPC-Web代理 | 原生支持 |
| 调试 | 不易(二进制) | 容易(curl/Postman) |
| 生态 | 微服务内部 | 对外API |
| 性能 | 高 | 中 |
gRPC适用:
REST适用:
混合方案:
外部客户端 → API Gateway(REST) → 内部服务A(gRPC) → 内部服务B(gRPC)
// Spring Cloud Gateway + gRPC
@Bean
public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
return builder.routes()
.route("order-api", r -> r
.path("/api/orders/**")
.filters(f -> f.grpcToRest("order-service"))
.uri("grpc://order-service:9090"))
.build();
}
或者使用grpc-gateway(Go实现)将REST请求转为gRPC调用。
import "grpc/health/v1/health.proto";
service Health {
rpc Check(HealthCheckRequest) returns (HealthCheckResponse);
}
// 服务端注册健康检查
healthStatusManager.setStatus("order.OrderService",
HealthCheckResponse.ServingStatus.SERVING);
K8s集成:
livenessProbe:
exec:
command: ["/bin/grpc_health_probe", "-addr=:9090"]
readinessProbe:
exec:
command: ["/bin/grpc_health_probe", "-addr=:9090"]
HTTP/2流控:基于WINDOW_UPDATE帧,接收方通知发送方还能接收多少数据。
gRPC层面的背压:
// 服务端流式响应时检查请求方是否ready
@Override
public void listOrders(ListRequest request, StreamObserver<OrderResponse> observer) {
for (Order order : orders) {
if (observer.isReady()) {
observer.onNext(toProto(order));
} else {
// 等待客户端消费
}
}
observer.onCompleted();
}
// 重试配置
ManagedChannel channel = ManagedChannelBuilder
.forTarget("dns:///order-service:9090")
.defaultServiceConfig(Map.of(
"methodConfig", List.of(Map.of(
"name", List.of(Map.of("service", "order.OrderService")),
"retryPolicy", Map.of(
"maxAttempts", 3.0,
"initialBackoff", "0.5s",
"maxBackoff", "3s",
"backoffMultiplier", 2.0,
"retryableStatusCodes", List.of("UNAVAILABLE", "DEADLINE_EXCEEDED")
)
))
))
.build();
// 客户端发送Metadata
Metadata headers = new Metadata();
headers.put(Metadata.Key.of("x-request-id", Metadata.ASCII_STRING_MARSHALLER),
UUID.randomUUID().toString());
headers.put(Metadata.Key.of("x-trace-id", Metadata.ASCII_STRING_MARSHALLER),
traceId);
// 通过拦截器读取
String traceId = headers.get(
Metadata.Key.of("x-trace-id", Metadata.ASCII_STRING_MARSHALLER));
<dependency>
<groupId>io.grpc</groupId>
<artifactId>grpc-context</artifactId>
</dependency>
// 使用OpenTelemetry gRPC拦截器
public class TracingServerInterceptor implements ServerInterceptor {
@Override
public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
// 从Metadata提取trace context
Span span = tracer.spanBuilder(call.getMethodDescriptor().getFullMethodName())
.setParent(extractContext(headers))
.startSpan();
try (Scope scope = span.makeCurrent()) {
return next.startCall(call, headers);
} finally {
span.end();
}
}
}
1. 连接复用:共享Channel,不要每次创建新Channel
2. 连接池:多个Channel做负载分担
3. Keep-Alive:防止连接空闲被断开
4. 消息压缩:Gzip压缩减少传输量
5. 批量请求:减少网络往返
6. 流式代替多次Unary:减少连接开销
// 开启压缩
channelBuilder.compressorRegistry(
CompressorRegistry.getDefaultInstance());
serverBuilder.decompressorRegistry(
DecompressorRegistry.getDefaultInstance());
// 请求级压缩
stub.withCompression("gzip").getOrder(request);
// Channel配置
ManagedChannel channel = ManagedChannelBuilder
.forTarget("dns:///order-service:9090")
.keepAliveTime(30, TimeUnit.SECONDS) // 每30秒发ping
.keepAliveTimeout(10, TimeUnit.SECONDS) // 10秒无响应断开
.keepAliveWithoutCalls(true) // 无请求也发ping
.idleTimeout(300, TimeUnit.SECONDS) // 5分钟空闲断开
.maxInboundMessageSize(4 * 1024 * 1024) // 最大消息4MB
.build();
// 优雅关闭
Runtime.getRuntime().addShutdownHook(new Thread(() -> {
channel.shutdown();
try {
channel.awaitTermination(5, TimeUnit.SECONDS);
} catch (InterruptedException e) {
channel.shutdownNow();
}
}));
1. 字段编号:1-15只占1字节,高频字段用小编号
2. repeated字段:使用packed编码(proto3默认)
3. 避免大消息:单消息不超过1MB,大的用流式
4. 合理使用map:map比repeated键值对更紧凑
5. oneof替代多个optional:节省空间
API Gateway(REST) → User Service(gRPC) ←→ Order Service(gRPC)
↓ ↓
Product Service(gRPC) Payment Service(gRPC)
技术选型:
方案一:路由规则
// 自定义LoadBalancer,按版本路由
public class CanaryLoadBalancer extends LoadBalancer {
@Override
public PickResult pickSubChannel(PickSubchannelArgs args) {
String version = args.getHeaders().get(VERSION_KEY);
if ("v2".equals(version)) {
return canarySubChannel;
}
return stableSubChannel;
}
}
方案二:Istio/Virtual Service
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
spec:
http:
- route:
- destination:
host: order-service
subset: v1
weight: 90
- destination:
host: order-service
subset: v2
weight: 10
兼容性规则:
最佳实践:使用reserved保留已删除的字段编号和名称。
// gRPC接收请求 → Kafka异步处理
@GrpcService
public class OrderGrpcService extends OrderServiceGrpc.OrderServiceImplBase {
@Autowired KafkaTemplate<String, String> kafkaTemplate;
@Override
public void createOrder(CreateOrderRequest request, StreamObserver<OrderResponse> observer) {
String orderId = UUID.randomUUID().toString();
kafkaTemplate.send("order-events", orderId, toJson(request));
observer.onNext(OrderResponse.newBuilder()
.setId(orderId)
.setStatus(OrderStatus.CREATED)
.build());
observer.onCompleted();
}
}
// 方式一:Package版本
package order.v1;
package order.v2;
// 方式二:独立proto文件
// order_v1.proto
// order_v2.proto
// 服务端同时支持多版本
@GrpcService
public class OrderV1Service extends OrderV1ServiceGrpc.OrderV1ServiceImplBase { }
@GrpcService
public class OrderV2Service extends OrderV2ServiceGrpc.OrderV2ServiceImplBase { }
1. 多路复用:一个TCP连接并行多个请求,无需连接池
2. 头部压缩:HPACK减少Header开销
3. 流控:原生流控机制,支持背压
4. Server Push:可用于服务端流式响应
5. 二进制帧:更高效的传输
传统Service Mesh:应用 → Sidecar Proxy → 服务
Proxyless模式:应用 → xDS API(直接与控制面通信) → 服务
优势:减少一次网络跳转(无Sidecar),性能接近直连。
实现:gRPC xDS支持(1.39+),配合Istio控制面。
工具:
grpcurl:命令行工具(类似curl)grpcui:Web UI(类似Postman)Postman:支持gRPCBloomRPC:GUI客户端
# 列出服务
grpcurl -plaintext localhost:9090 list
# 调用方法
grpcurl -plaintext -d '{"order_id": 123}' localhost:9090 order.OrderService/GetOrder
| 状态码 | 含义 | HTTP映射 |
|---|---|---|
| OK | 成功 | 200 |
| CANCELLED | 调用取消 | 499 |
| INVALID_ARGUMENT | 参数无效 | 400 |
| DEADLINE_EXCEEDED | 超时 | 504 |
| NOT_FOUND | 资源不存在 | 404 |
| ALREADY_EXISTS | 已存在 | 409 |
| PERMISSION_DENIED | 权限不足 | 403 |
| RESOURCE_EXHAUSTED | 资源耗尽 | 429 |
| UNAVAILABLE | 服务不可用 | 503 |
| UNAUTHENTICATED | 未认证 | 401 |
| INTERNAL | 内部错误 | 500 |
| 维度 | gRPC | Dubbo |
|---|---|---|
| 协议 | HTTP/2 + Protobuf | Triple(HTTP/2) + 自定义 |
| 序列化 | Protobuf | Hessian/Protobuf/JSON |
| 服务发现 | 需外部组件 | 内置注册中心 |
| 负载均衡 | 客户端 | 客户端 |
| 生态 | 多语言 | Java为主 |
| 治理 | 有限 | 丰富(路由/熔断/限流) |
| 学习成本 | 低 | 中 |
Dubbo 3.x已支持gRPC协议(Triple),可以复用gRPC生态。
单消息限制(默认4MB),大文件用流式传输:
// 客户端分块上传
StreamObserver<UploadResponse> responseObserver = ...;
StreamObserver<UploadRequest> requestObserver = asyncStub.uploadFile(responseObserver);
byte[] buffer = new byte[64 * 1024]; // 64KB chunks
int read;
while ((read = fis.read(buffer)) > 0) {
requestObserver.onNext(UploadRequest.newBuilder()
.setData(ByteString.copyFrom(buffer, 0, read))
.build());
}
requestObserver.onCompleted();
Server server = ServerBuilder.forPort(9090)
.addService(new OrderService())
.build()
.start();
// 优雅停机
Runtime.getRuntime().addShutdownHook(new Thread(() -> {
server.shutdown();
try {
server.awaitTermination(30, TimeUnit.SECONDS);
} catch (InterruptedException e) {
server.shutdownNow();
}
}));
gRPC三板斧:HTTP/2 + Protobuf + 代码生成
>
四种模式:Unary最简单、Server Stream推送数据、Client Stream上传、Bidirectional聊天
>
选型原则:内部通信用gRPC、对外API用REST
>
性能关键:Channel复用、Keep-Alive保活、流式代替多次调用