gRPC + Spring Boot实战：微服务高性能通信从入门到落地
<h2>一、gRPC简介</h2><p>gRPC是Google开源的高性能RPC框架，基于HTTP/2和Protocol Buffers，支持双向流、多语言代码生成。相比REST JSON，gRPC序列化体积小3-5倍，延迟降低30%以上，是微服务间通信的首选方案。</p>
<h2>二、项目结构</h2>
<pre><code>grpc-demo/
├── grpc-api/ # Proto定义 + 生成代码
│ └── src/main/proto/
│ └── user.proto
├── grpc-server/ # 服务端
└── grpc-client/ # 客户端</code></pre>
<h2>三、Proto文件定义</h2>
<pre><code>syntax = "proto3";
package com.example.grpc;
option java_package = "com.example.grpc.user";
option java_outer_classname = "UserProto";
service UserService {
rpc GetUser (GetUserRequest) returns (GetUserResponse);
rpc ListUsers (ListUsersRequest) returns (stream GetUserResponse);
rpc CreateUser (stream CreateUserRequest) returns (CreateUserBatchResponse);
rpc Chat (stream ChatMessage) returns (stream ChatMessage);
}
message GetUserRequest {
int32 id = 1;
}
message GetUserResponse {
int32 id = 1;
string name = 2;
string email = 3;
int32 age = 4;
}
message ListUsersRequest {
int32 page = 1;
int32 size = 2;
}
message CreateUserRequest {
string name = 1;
string email = 2;
int32 age = 3;
}
message CreateUserBatchResponse {
int32 count = 1;
repeated GetUserResponse users = 2;
}
message ChatMessage {
string from = 1;
string message = 2;
}</code></pre>
<h2>四、Maven依赖配置</h2>
<pre><code><dependencies>
<dependency>
<groupId>net.devh</groupId>
<artifactId>grpc-spring-boot-starter</artifactId>
<version>3.1.0.RELEASE</version>
</dependency>
<dependency>
<groupId>io.grpc</groupId>
<artifactId>grpc-protobuf</artifactId>
<version>1.62.2</version>
</dependency>
<dependency>
<groupId>io.grpc</groupId>
<artifactId>grpc-stub</artifactId>
<version>1.62.2</version>
</dependency>
</dependencies>
<build>
<extensions>
<extension>
<groupId>kr.motd.maven</groupId>
<artifactId>os-maven-plugin</artifactId>
<version>1.7.1</version>
</extension>
</extensions>
<plugins>
<plugin>
<groupId>org.xolstice.maven.plugins</groupId>
<artifactId>protobuf-maven-plugin</artifactId>
<version>0.6.1</version>
<configuration>
<protocArtifact>com.google.protobuf:protoc:3.25.3:exe:${os.detected.classifier}</protocArtifact>
<pluginId>grpc-java</pluginId>
<pluginArtifact>io.grpc:protoc-gen-grpc-java:1.62.2:exe:${os.detected.classifier}</pluginArtifact>
</configuration>
<executions>
<execution>
<goals><goal>compile</goal><goal>compile-custom</goal></goals>
</execution>
</executions>
</plugin>
</plugins>
</build></code></pre>
<h2>五、服务端实现</h2>
<pre><code>@GrpcService
public class UserGrpcService extends UserServiceGrpc.UserServiceImplBase {
@Autowired
private UserRepository userRepository;
@Override
public void getUser(GetUserRequest request, StreamObserver<GetUserResponse> responseObserver) {
User user = userRepository.findById(request.getId())
.orElseThrow(() -> new StatusRuntimeException(
Status.NOT_FOUND.withDescription("User not found")));
responseObserver.onNext(toResponse(user));
responseObserver.onCompleted();
}
@Override
public void listUsers(ListUsersRequest request,
StreamObserver<GetUserResponse> responseObserver) {
List<User> users = userRepository.findAll(
PageRequest.of(request.getPage(), request.getSize())).getContent();
for (User user : users) {
responseObserver.onNext(toResponse(user));
}
responseObserver.onCompleted();
}
@Override
public StreamObserver<CreateUserRequest> createUser(
StreamObserver<CreateUserBatchResponse> responseObserver) {
return new StreamObserver<CreateUserRequest>() {
List<User> created = new ArrayList<>();
public void onNext(CreateUserRequest req) {
User user = new User(req.getName(), req.getEmail(), req.getAge());
created.add(userRepository.save(user));
}
public void onError(Throwable t) { }
public void onCompleted() {
CreateUserBatchResponse resp = CreateUserBatchResponse.newBuilder()
.setCount(created.size())
.addAllUsers(created.stream().map(u -> toResponse(u)).collect(Collectors.toList()))
.build();
responseObserver.onNext(resp);
responseObserver.onCompleted();
}
};
}
private GetUserResponse toResponse(User user) {
return GetUserResponse.newBuilder()
.setId(user.getId()).setName(user.getName())
.setEmail(user.getEmail()).setAge(user.getAge()).build();
}
}</code></pre>
<h2>六、客户端调用</h2>
<pre><code>@Service
public class UserGrpcClient {
@GrpcClient("user-service")
private UserServiceGrpc.UserServiceBlockingStub blockingStub;
@GrpcClient("user-service")
private UserServiceGrpc.UserServiceStub asyncStub;
public GetUserResponse getUser(int id) {
return blockingStub.getUser(GetUserRequest.newBuilder().setId(id).build());
}
public List<GetUserResponse> listUsers(int page, int size) {
List<GetUserResponse> result = new ArrayList<>();
Iterator<GetUserResponse> it = blockingStub.listUsers(
ListUsersRequest.newBuilder().setPage(page).setSize(size).build());
while (it.hasNext()) { result.add(it.next()); }
return result;
}
public void createUserBatch(List<CreateUserRequest> requests) {
StreamObserver<CreateUserBatchResponse> observer = new StreamObserver<CreateUserBatchResponse>() {
public void onNext(CreateUserBatchResponse resp) {
System.out.println("Created " + resp.getCount() + " users");
}
public void onError(Throwable t) { t.printStackTrace(); }
public void onCompleted() { System.out.println("Batch done"); }
};
StreamObserver<CreateUserRequest> requestObserver = asyncStub.createUser(observer);
for (CreateUserRequest req : requests) { requestObserver.onNext(req); }
requestObserver.onCompleted();
}
}</code></pre>
<h2>七、客户端配置</h2>
<pre><code># application.yml
grpc:
client:
user-service:
address: static://localhost:9090
negotiationType: plaintext
enableKeepAlive: true
keepAliveTime: 30s
keepAliveTimeout: 10s
server:
port: 8081</code></pre>
<h2>八、REST网关集成</h2>
<pre><code>@RestController
@RequestMapping("/api/users")
public class UserRestController {
@Autowired
private UserGrpcClient grpcClient;
@GetMapping("/{id}")
public Map<String, Object> getUser(@PathVariable int id) {
GetUserResponse resp = grpcClient.getUser(id);
return Map.of("id", resp.getId(), "name", resp.getName(),
"email", resp.getEmail(), "age", resp.getAge());
}
@GetMapping
public List<Map<String, Object>> listUsers(
@RequestParam(defaultValue = "0") int page,
@RequestParam(defaultValue = "10") int size) {
return grpcClient.listUsers(page, size).stream()
.map(r -> Map.of("id", r.getId(), "name", r.getName(),
"email", r.getEmail(), "age", r.getAge()))
.collect(Collectors.toList());
}
}</code></pre>
<h2>九、性能对比</h2>
<pre><code>指标 REST/JSON gRPC/Protobuf
-----------------------------------------------
序列化体积 ~2.1KB ~0.4KB
平均延迟 45ms 12ms
QPS (单连接) ~3,200 ~9,500
CPU占用 高 低
代码生成 无 自动
流式支持 SSE(单向) 双向流</code></pre>
<h2>十、最佳实践</h2>
<ol>
<li><strong>Proto版本管理</strong>：使用buf工具管理Proto文件和Breaking Change检测</li>
<li><strong>错误处理</strong>：用gRPC Status Code替代业务异常，保持语义一致</li>
<li><strong>超时设置</strong>：Deadline传播，避免级联超时</li>
<li><strong>负载均衡</strong>：结合Nacos/Consul实现服务发现+客户端负载均衡</li>
<li><strong>拦截器</strong>：用gRPC Interceptor实现认证、日志、链路追踪</li>
</ol>
<h2>十一、总结</h2>
<p>gRPC + Spring Boot是微服务高性能通信的最佳实践。通过grpc-spring-boot-starter，Spring Boot开发者可以像写普通Service一样实现gRPC服务。四种通信模式（Unary、Server Stream、Client Stream、Bidirectional Stream）覆盖了几乎所有微服务交互场景。</p>
</div>
<div id="MySignature" role="contentinfo">
---
📌 **如果觉得文章对你有帮助，欢迎点赞👍收藏⭐！**
💬 有问题或建议？欢迎在评论区留言讨论~
🔗 更多技术干货请关注作者：弥烟袅绕
📚 本文地址：https://www.cnblogs.com/czlws/p/19853464/grpc-spring-boot-microservice-tutorial<br><br>
来源：https://www.cnblogs.com/czlws/p/19853464/grpc-spring-boot-microservice-tutorial
頁:
[1]