gRPC + Spring Boot实战：微服务高性能通讯从入门到落地

一、gRPC简介

gRPC是Google开源的高性能RPC框架，基于HTTP/2和Protocol Buffers，支持双向流、多语言代码天生。相比REST JSON，gRPC序列化体积小3-5倍，耽误低沉30%以上，是微服务间通讯的首选方案。
二、项目布局

1. grpc-demo/
2. ├── grpc-api/          # Proto定义 + 生成代码
3. │   └── src/main/proto/
4. │       └── user.proto
5. ├── grpc-server/       # 服务端
6. └── grpc-client/       # 客户端

复制代码

三、Proto文件界说

1. syntax = "proto3";
2. package com.example.grpc;
4. option java_package = "com.example.grpc.user";
5. option java_outer_classname = "UserProto";
7. service UserService {
8.   rpc GetUser (GetUserRequest) returns (GetUserResponse);
9.   rpc ListUsers (ListUsersRequest) returns (stream GetUserResponse);
10.   rpc CreateUser (stream CreateUserRequest) returns (CreateUserBatchResponse);
11.   rpc Chat (stream ChatMessage) returns (stream ChatMessage);
12. }
14. message GetUserRequest {
15.   int32 id = 1;
16. }
18. message GetUserResponse {
19.   int32 id = 1;
20.   string name = 2;
21.   string email = 3;
22.   int32 age = 4;
23. }
25. message ListUsersRequest {
26.   int32 page = 1;
27.   int32 size = 2;
28. }
30. message CreateUserRequest {
31.   string name = 1;
32.   string email = 2;
33.   int32 age = 3;
34. }
36. message CreateUserBatchResponse {
37.   int32 count = 1;
38.   repeated GetUserResponse users = 2;
39. }
41. message ChatMessage {
42.   string from = 1;
43.   string message = 2;
44. }

复制代码

四、Maven依赖设置

1. <dependencies>
2.     <dependency>
3.         <groupId>net.devh</groupId>
4.         grpc-spring-boot-starter</artifactId>
5.         <version>3.1.0.RELEASE</version>
6.     </dependency>
7.     <dependency>
8.         <groupId>io.grpc</groupId>
9.         grpc-protobuf</artifactId>
10.         <version>1.62.2</version>
11.     </dependency>
12.     <dependency>
13.         <groupId>io.grpc</groupId>
14.         grpc-stub</artifactId>
15.         <version>1.62.2</version>
16.     </dependency>
17. </dependencies>
19. <build>
20.     <extensions>
21.         <extension>
22.             <groupId>kr.motd.maven</groupId>
23.             os-maven-plugin</artifactId>
24.             <version>1.7.1</version>
25.         </extension>
26.     </extensions>
27.     <plugins>
28.         <plugin>
29.             <groupId>org.xolstice.maven.plugins</groupId>
30.             protobuf-maven-plugin</artifactId>
31.             <version>0.6.1</version>
32.             <configuration>
33.                 <protocArtifact>com.google.protobuf:protoc:3.25.3:exe:${os.detected.classifier}</protocArtifact>
34.                 <pluginId>grpc-java</pluginId>
35.                 <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.62.2:exe:${os.detected.classifier}</pluginArtifact>
36.             </configuration>
37.             <executions>
38.                 <execution>
39.                     <goals><goal>compile</goal><goal>compile-custom</goal></goals>
40.                 </execution>
41.             </executions>
42.         </plugin>
43.     </plugins>
44. </build>

复制代码

五、服务端实现

1. @GrpcService
2. public class UserGrpcService extends UserServiceGrpc.UserServiceImplBase {
4.     @Autowired
5.     private UserRepository userRepository;
7.     @Override
8.     public void getUser(GetUserRequest request, StreamObserver<GetUserResponse> responseObserver) {
9.         User user = userRepository.findById(request.getId())
10.             .orElseThrow(() -> new StatusRuntimeException(
11.                 Status.NOT_FOUND.withDescription("User not found")));
12.         responseObserver.onNext(toResponse(user));
13.         responseObserver.onCompleted();
14.     }
16.     @Override
17.     public void listUsers(ListUsersRequest request,
18.             StreamObserver<GetUserResponse> responseObserver) {
19.         List<User> users = userRepository.findAll(
20.             PageRequest.of(request.getPage(), request.getSize())).getContent();
21.         for (User user : users) {
22.             responseObserver.onNext(toResponse(user));
23.         }
24.         responseObserver.onCompleted();
25.     }
27.     @Override
28.     public StreamObserver<CreateUserRequest> createUser(
29.             StreamObserver<CreateUserBatchResponse> responseObserver) {
30.         return new StreamObserver<CreateUserRequest>() {
31.             List<User> created = new ArrayList<>();
32.             public void onNext(CreateUserRequest req) {
33.                 User user = new User(req.getName(), req.getEmail(), req.getAge());
34.                 created.add(userRepository.save(user));
35.             }
36.             public void onError(Throwable t) { }
37.             public void onCompleted() {
38.                 CreateUserBatchResponse resp = CreateUserBatchResponse.newBuilder()
39.                     .setCount(created.size())
40.                     .addAllUsers(created.stream().map(u -> toResponse(u)).collect(Collectors.toList()))
41.                     .build();
42.                 responseObserver.onNext(resp);
43.                 responseObserver.onCompleted();
44.             }
45.         };
46.     }
48.     private GetUserResponse toResponse(User user) {
49.         return GetUserResponse.newBuilder()
50.             .setId(user.getId()).setName(user.getName())
51.             .setEmail(user.getEmail()).setAge(user.getAge()).build();
52.     }
53. }

复制代码

六、客户端调用

1. @Service
2. public class UserGrpcClient {
4.     @GrpcClient("user-service")
5.     private UserServiceGrpc.UserServiceBlockingStub blockingStub;
7.     @GrpcClient("user-service")
8.     private UserServiceGrpc.UserServiceStub asyncStub;
10.     public GetUserResponse getUser(int id) {
11.         return blockingStub.getUser(GetUserRequest.newBuilder().setId(id).build());
12.     }
14.     public List<GetUserResponse> listUsers(int page, int size) {
15.         List<GetUserResponse> result = new ArrayList<>();
16.         Iterator<GetUserResponse> it = blockingStub.listUsers(
17.             ListUsersRequest.newBuilder().setPage(page).setSize(size).build());
18.         while (it.hasNext()) { result.add(it.next()); }
19.         return result;
20.     }
22.     public void createUserBatch(List<CreateUserRequest> requests) {
23.         StreamObserver<CreateUserBatchResponse> observer = new StreamObserver<CreateUserBatchResponse>() {
24.             public void onNext(CreateUserBatchResponse resp) {
25.                 System.out.println("Created " + resp.getCount() + " users");
26.             }
27.             public void onError(Throwable t) { t.printStackTrace(); }
28.             public void onCompleted() { System.out.println("Batch done"); }
29.         };
30.         StreamObserver<CreateUserRequest> requestObserver = asyncStub.createUser(observer);
31.         for (CreateUserRequest req : requests) { requestObserver.onNext(req); }
32.         requestObserver.onCompleted();
33.     }
34. }

复制代码

七、客户端设置

1. # application.yml
2. grpc:
3.   client:
4.     user-service:
5.       address: static://localhost:9090
6.       negotiationType: plaintext
7.       enableKeepAlive: true
8.       keepAliveTime: 30s
9.       keepAliveTimeout: 10s
11. server:
12.   port: 8081

复制代码

八、REST网关集成

1. @RestController
2. @RequestMapping("/api/users")
3. public class UserRestController {
5.     @Autowired
6.     private UserGrpcClient grpcClient;
8.     @GetMapping("/{id}")
9.     public Map<String, Object> getUser(@PathVariable int id) {
10.         GetUserResponse resp = grpcClient.getUser(id);
11.         return Map.of("id", resp.getId(), "name", resp.getName(),
12.             "email", resp.getEmail(), "age", resp.getAge());
13.     }
15.     @GetMapping
16.     public List<Map<String, Object>> listUsers(
17.             @RequestParam(defaultValue = "0") int page,
18.             @RequestParam(defaultValue = "10") int size) {
19.         return grpcClient.listUsers(page, size).stream()
20.             .map(r -> Map.of("id", r.getId(), "name", r.getName(),
21.                 "email", r.getEmail(), "age", r.getAge()))
22.             .collect(Collectors.toList());
23.     }
24. }

复制代码

九、性能对比

1. 指标              REST/JSON      gRPC/Protobuf
2. -----------------------------------------------
3. 序列化体积        ~2.1KB         ~0.4KB
4. 平均延迟          45ms           12ms
5. QPS (单连接)      ~3,200         ~9,500
6. CPU占用           高             低
7. 代码生成          无             自动
8. 流式支持          SSE(单向)      双向流

复制代码

十、最佳实践

• Proto版本管理：利用buf工具管理Proto文件和Breaking Change检测
  
• 错误处置处罚：用gRPC Status Code更换业务非常，保持语义划一
  
• 超时设置：Deadline流传，克制级联超时
  
• 负载平衡：团结Nacos/Consul实现服务发现+客户端负载平衡
  
• 拦截器：用gRPC Interceptor实现认证、日记、链路追踪
  

十一、总结

gRPC + Spring Boot是微服务高性能通讯的最佳实践。通过grpc-spring-boot-starter，Spring Boot开发者可以像写平凡Service一样实现gRPC服务。四种通讯模式（Unary、Server Stream、Client Stream、Bidirectional Stream）覆盖了险些全部微服务交互场景。

免责声明：如果侵犯了您的权益，请联系站长及时删除侵权内容，谢谢合作！qidao123.com:ToB企服之家，中国第一个企服评测及软件市场,开放入驻,技术点评得现金.