← 返回首页 ❓ 面试题库
📑 本篇章节导航 (共10章,点击直达)
一、gRPC基础与核心概念二、拦截器与中间件三、负载均衡与服务发现四、Spring Boot集成五、与REST的对比和选型六、高级特性七、性能优化八、实战场景题九、面试高频综合题面试速记口诀

Q97 gRPC与微服务通信实战

20K Java+AI 岗位高频考点 — gRPC是微服务间高性能通信的事实标准。覆盖Protobuf、四种通信模式、拦截器、负载均衡、与REST对比、Spring Boot集成等。

一、gRPC基础与核心概念

1. gRPC是什么?为什么比REST快?

gRPC是Google开源的高性能RPC框架,基于HTTP/2 + Protobuf。

性能优势:

性能对比:

指标gRPCREST+JSON
序列化速度~1000 ns~10000 ns
消息体积小(二进制)大(文本)
连接复用HTTP/2多路复用HTTP/1.1需Keep-Alive
流式支持原生支持需SSE/WebSocket

2. Protobuf(Protocol Buffers)核心原理?

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;
}

编码原理:

3. gRPC的四种通信模式?

一元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());

4. gRPC的Channel和Stub是什么?

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);

二、拦截器与中间件

5. gRPC拦截器(Interceptor)怎么用?

客户端拦截器:


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();
            }
        };
    }
}

6. 如何实现gRPC的全局异常处理?


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);
                }
            }
        };
    }
}

7. gRPC的Deadline和超时?


// 客户端设置超时
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传播到下游调用,避免级联超时。


三、负载均衡与服务发现

8. gRPC的负载均衡方案?

客户端负载均衡(内置):


ManagedChannel channel = ManagedChannelBuilder
    .forTarget("dns:///my-service:9090")
    .defaultLoadBalancingPolicy("round_robin")
    .build();

结合注册中心:

9. gRPC + Nacos服务发现?


// 自定义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);
        });
    }
}

10. gRPC在K8s中的服务发现?


# 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();

四、Spring Boot集成

11. Spring Boot + gRPC的集成方案?


<!-- 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);
    }
}

12. 如何实现gRPC的认证?

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。


五、与REST的对比和选型

13. gRPC vs REST的完整对比?

维度gRPCREST
协议HTTP/2HTTP/1.1/2
序列化Protobuf(二进制)JSON(文本)
接口定义.proto文件(强类型)OpenAPI/Swagger
流式通信原生四种模式需SSE/WebSocket
代码生成自动生成客户端/服务端手动编写或OpenAPI Generator
浏览器支持需gRPC-Web代理原生支持
调试不易(二进制)容易(curl/Postman)
生态微服务内部对外API
性能高中

14. 什么时候用gRPC?什么时候用REST?

gRPC适用:

REST适用:

混合方案:


外部客户端 → API Gateway(REST) → 内部服务A(gRPC) → 内部服务B(gRPC)

15. gRPC Gateway怎么实现?


// 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调用。


六、高级特性

16. 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"]

17. gRPC的流控(Flow Control)?

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();
}

18. gRPC的重试策略?


// 重试配置
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();

19. gRPC的元数据(Metadata)传递?


// 客户端发送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));

20. gRPC如何与链路追踪集成?


<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();
        }
    }
}

七、性能优化

21. gRPC的性能优化方案?

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);

22. gRPC的连接管理最佳实践?


// 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();
    }
}));

23. gRPC的Protobuf优化技巧?

1. 字段编号:1-15只占1字节,高频字段用小编号

2. repeated字段:使用packed编码(proto3默认)

3. 避免大消息:单消息不超过1MB,大的用流式

4. 合理使用map:map比repeated键值对更紧凑

5. oneof替代多个optional:节省空间


八、实战场景题

24. 设计一个基于gRPC的微服务通信架构?


API Gateway(REST) → User Service(gRPC) ←→ Order Service(gRPC)
                          ↓                        ↓
                    Product Service(gRPC)    Payment Service(gRPC)

技术选型:

25. 如何实现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

26. 如何处理gRPC的向后兼容性?

兼容性规则:

最佳实践:使用reserved保留已删除的字段编号和名称。

27. gRPC如何与消息队列配合?


// 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();
    }
}

28. 如何实现gRPC的API版本管理?


// 方式一: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 { }

九、面试高频综合题

29. gRPC为什么选择HTTP/2?

1. 多路复用:一个TCP连接并行多个请求,无需连接池

2. 头部压缩:HPACK减少Header开销

3. 流控:原生流控机制,支持背压

4. Server Push:可用于服务端流式响应

5. 二进制帧:更高效的传输

30. gRPC的Proxyless模式是什么?

传统Service Mesh:应用 → Sidecar Proxy → 服务

Proxyless模式:应用 → xDS API(直接与控制面通信) → 服务

优势:减少一次网络跳转(无Sidecar),性能接近直连。

实现:gRPC xDS支持(1.39+),配合Istio控制面。

31. 如何调试gRPC接口?

工具:


# 列出服务
grpcurl -plaintext localhost:9090 list

# 调用方法
grpcurl -plaintext -d '{"order_id": 123}' localhost:9090 order.OrderService/GetOrder

32. gRPC的错误码体系?

状态码含义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

33. gRPC与Dubbo的对比?

维度gRPCDubbo
协议HTTP/2 + ProtobufTriple(HTTP/2) + 自定义
序列化ProtobufHessian/Protobuf/JSON
服务发现需外部组件内置注册中心
负载均衡客户端客户端
生态多语言Java为主
治理有限丰富(路由/熔断/限流)
学习成本低中

Dubbo 3.x已支持gRPC协议(Triple),可以复用gRPC生态。

34. 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();

35. gRPC如何实现优雅停机?


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保活、流式代替多次调用