跨语言 RPC 实战:gRPC 与 Dubbo Triple 对比
本文详细解析了 Java 与 Go 跨语言 RPC 的完整实战,对比了原生 gRPC 与 Dubbo Triple 的实现方式、生成代码差异、服务注册发现和调用链路,并通过
本文通过完整的 Demo,演示 Java 与 Go 之间的跨语言 RPC 调用,对比原生 gRPC 和 Dubbo Triple 两种方案的实现与选型。
技术栈:Java 21 + Spring Boot 3.5 + gRPC / Dubbo 3.x + Go 1.21+ + Nacos
目录
- 一、技术选型指南
- 二、Protocol Buffers 基础
- 三、protoc 编译器详解
- 四、方案一:原生 gRPC Demo
- 五、方案二:Dubbo Triple Demo
- 六、两种方案对比总结
- 七、Spring Cloud Alibaba 多协议共存实战
- 八、gRPC 原理简述
- 九、常见问题
一、技术选型指南
1.1 什么时候用原生 gRPC?
| 场景 | 说明 |
|---|---|
| K8s / 云原生环境 | K8s Service 自带服务发现,gRPC 轻量够用 |
| 简单跨语言调用 | 不需要复杂服务治理,快速上手 |
| 多语言团队 | Go、Python、Rust 等非 Java 语言为主 |
| 性能敏感场景 | 原生 gRPC 开销最小 |
1.2 什么时候用 Dubbo Triple?
| 场景 | 说明 |
|---|---|
| Java 微服务体系 | 已有 Spring Cloud / Dubbo 生态 |
| 需要服务治理 | 限流、熔断、重试、灰度发布 |
| 传统部署(非 K8s) | 需要 Nacos/Zookeeper 做服务发现 |
| 统一技术栈 | 希望 HTTP + gRPC 用同一套框架 |
1.3 一图看懂选型
二、Protocol Buffers 基础
2.1 什么是 Protocol Buffers?
Protocol Buffers(简称 Protobuf)是 Google 开发的一种语言无关、平台无关的数据序列化格式。它是 gRPC 的基础。
核心价值:一份 .proto 文件定义接口,自动生成多种语言的代码。
2.2 Proto 文件结构
protobuf
// ========== 1. 语法版本声明(必须在第一行)==========
syntax = "proto3";
// ========== 2. 包名(命名空间)==========
package demo;
// ========== 3. 代码生成选项 ==========
// Java 选项
option java_multiple_files = true; // 每个 message 生成独立文件
option java_package = "com.salmon.grpc.demo.proto"; // Java 包名
option java_outer_classname = "UserProto"; // 外部类名
// Go 选项
option go_package = "go-server/proto;userpb"; // Go 包路径;包别名
// ========== 4. 消息定义(数据结构)==========
message User {
int64 id = 1; // 字段编号 1
string username = 2; // 字段编号 2
string email = 3;
}
// ========== 5. 服务定义(RPC 接口)==========
service UserService {
rpc GetUser(GetUserRequest) returns (GetUserResponse);
}
2.3 Proto 数据类型
| Proto 类型 | Java 类型 | Go 类型 | 说明 |
|---|---|---|---|
double |
double | float64 | 双精度浮点 |
float |
float | float32 | 单精度浮点 |
int32 |
int | int32 | 32位整数 |
int64 |
long | int64 | 64位整数 |
bool |
boolean | bool | 布尔值 |
string |
String | string | UTF-8 字符串 |
bytes |
ByteString | []byte | 字节数组 |
repeated T |
List |
[]T | 数组/列表 |
map<K,V> |
Map<K,V> | map[K]V | 映射 |
2.4 字段编号规则
protobuf
message User {
int64 id = 1; // ✅ 字段编号,不是默认值!
string name = 2; // ✅ 编号必须唯一
string email = 3; // ✅ 编号范围:1 ~ 536,870,911
// reserved 4, 5; // 保留编号(已删除的字段)
}
重要规则:
- 字段编号一旦使用,永远不能修改(会破坏兼容性)
- 1-15 编号只占 1 字节,用于高频字段
- 16-2047 编号占 2 字节
- 删除字段时用
reserved保留编号
三、protoc 编译器详解
3.1 安装 protoc
bash
# macOS
brew install protobuf
# 验证安装
protoc --version
# libprotoc 25.2
3.2 Go 代码生成
安装 Go 插件:
bash
go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest
export PATH="$PATH:$(go env GOPATH)/bin"
生成命令:
bash
protoc --go_out=. --go_opt=paths=source_relative \
--go-grpc_out=. --go-grpc_opt=paths=source_relative \
proto/user.proto
生成的文件:
proto/
├── user.proto # 原始定义
├── user.pb.go # 消息结构体
└── user_grpc.pb.go # gRPC 服务接口
3.3 Java 代码生成(Maven 插件)
Java 项目使用 Maven 插件自动生成,执行 mvn compile 即可。
生成的文件位置:
target/generated-sources/protobuf/
├── java/ # 消息类
│ └── com/salmon/grpc/demo/proto/
│ ├── User.java
│ ├── GetUserRequest.java
│ └── GetUserResponse.java
└── grpc-java/ # gRPC 服务类
└── com/salmon/grpc/demo/proto/
└── UserServiceGrpc.java
💡 IDEA 需要刷新 Maven 项目才能识别
target/generated-sources目录
3.4 生成代码的用途
| 生成的代码 | Client 使用 | Server 使用 |
|---|---|---|
| 消息类(User.java / user.pb.go) | ✅ 构建请求、解析响应 | ✅ 解析请求、构建响应 |
| Stub 类(UserServiceGrpc.Stub) | ✅ 发起 RPC 调用 | ❌ |
| 服务接口(UserServiceGrpc.ImplBase) | ❌ | ✅ 实现业务逻辑 |
四、方案一:原生 gRPC Demo
4.1 项目结构
grpc-demo/
├── proto/
│ └── user.proto # 接口定义(共享)
├── src/main/ # Java 客户端(Spring Boot)
│ ├── proto/user.proto
│ ├── java/
│ └── resources/
└── go-server/ # Go 服务端
├── go.mod
├── main.go
├── service/
│ └── user_service.go
└── proto/
├── user.proto
├── user.pb.go # 生成
└── user_grpc.pb.go # 生成
4.2 Proto 文件定义
proto/user.proto:
protobuf
syntax = "proto3";
package demo;
option java_multiple_files = true;
option java_package = "com.salmon.grpc.demo.proto";
option java_outer_classname = "UserProto";
option go_package = "go-server/proto;userpb";
service UserService {
rpc GetUser(GetUserRequest) returns (GetUserResponse);
rpc ListUsers(ListUsersRequest) returns (ListUsersResponse);
}
message GetUserRequest {
int64 user_id = 1;
}
message GetUserResponse {
int32 code = 1;
string message = 2;
User data = 3;
}
message ListUsersRequest {
int32 page = 1;
int32 page_size = 2;
}
message ListUsersResponse {
int32 code = 1;
string message = 2;
repeated User data = 3;
int64 total = 4;
}
message User {
int64 id = 1;
string username = 2;
string nickname = 3;
int32 level = 4;
}
4.3 Go 服务端实现
go-server/main.go:
go
package main
import (
"fmt"
"log"
"net"
pb "go-server/proto"
"go-server/service"
"google.golang.org/grpc"
"google.golang.org/grpc/reflection"
)
func main() {
port := 19090
lis, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
if err != nil {
log.Fatalf("监听失败: %v", err)
}
grpcServer := grpc.NewServer()
pb.RegisterUserServiceServer(grpcServer, &service.UserServiceServer{})
reflection.Register(grpcServer)
log.Printf("🚀 Go gRPC Server 启动: localhost:%d", port)
if err := grpcServer.Serve(lis); err != nil {
log.Fatalf("启动失败: %v", err)
}
}
go-server/service/user_service.go:
go
package service
import (
"context"
"fmt"
pb "go-server/proto"
)
type UserServiceServer struct {
pb.UnimplementedUserServiceServer
}
var mockUsers = map[int64]*pb.User{
1: {Id: 1, Username: "salmon", Nickname: "Salmon", Level: 5},
2: {Id: 2, Username: "test", Nickname: "测试用户", Level: 3},
}
func (s *UserServiceServer) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.GetUserResponse, error) {
user, exists := mockUsers[req.UserId]
if !exists {
return &pb.GetUserResponse{Code: 404, Message: fmt.Sprintf("用户 %d 不存在", req.UserId)}, nil
}
return &pb.GetUserResponse{Code: 200, Message: "success", Data: user}, nil
}
func (s *UserServiceServer) ListUsers(ctx context.Context, req *pb.ListUsersRequest) (*pb.ListUsersResponse, error) {
var users []*pb.User
for _, u := range mockUsers {
users = append(users, u)
}
return &pb.ListUsersResponse{Code: 200, Message: "success", Data: users, Total: int64(len(users))}, nil
}
go-server/go.mod:
go
module go-server
go 1.21
require (
google.golang.org/grpc v1.62.0
google.golang.org/protobuf v1.32.0
)
4.4 Java 客户端实现
pom.xml 核心配置:
xml
<properties>
<java.version>21</java.version>
<grpc.version>1.62.2</grpc.version>
<protobuf.version>3.25.2</protobuf.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>io.grpc</groupId>
<artifactId>grpc-netty-shaded</artifactId>
<version>${grpc.version}</version>
</dependency>
<dependency>
<groupId>io.grpc</groupId>
<artifactId>grpc-protobuf</artifactId>
<version>${grpc.version}</version>
</dependency>
<dependency>
<groupId>io.grpc</groupId>
<artifactId>grpc-stub</artifactId>
<version>${grpc.version}</version>
</dependency>
<!-- Java 9+ 必须添加 -->
<dependency>
<groupId>org.apache.tomcat</groupId>
<artifactId>annotations-api</artifactId>
<version>6.0.53</version>
<scope>provided</scope>
</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:${protobuf.version}:exe:${os.detected.classifier}</protocArtifact>
<pluginId>grpc-java</pluginId>
<pluginArtifact>io.grpc:protoc-gen-grpc-java:${grpc.version}:exe:${os.detected.classifier}</pluginArtifact>
<protoSourceRoot>${project.basedir}/src/main/proto</protoSourceRoot>
</configuration>
<executions>
<execution>
<goals>
<goal>compile</goal>
<goal>compile-custom</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
GrpcClientConfig.java:
java
@Configuration
public class GrpcClientConfig {
@Value("${grpc.server.host:localhost}")
private String host;
@Value("${grpc.server.port:19090}")
private int port;
private ManagedChannel channel;
@Bean
public ManagedChannel managedChannel() {
channel = ManagedChannelBuilder.forAddress(host, port)
.usePlaintext()
.build();
return channel;
}
@Bean
public UserServiceGrpc.UserServiceBlockingStub userServiceBlockingStub(ManagedChannel channel) {
return UserServiceGrpc.newBlockingStub(channel);
}
@PreDestroy
public void shutdown() throws InterruptedException {
if (channel != null) {
channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
}
}
}
UserController.java:
java
@RestController
@RequestMapping("/api/user")
public class UserController {
private final UserServiceGrpc.UserServiceBlockingStub userServiceStub;
public UserController(UserServiceGrpc.UserServiceBlockingStub userServiceStub) {
this.userServiceStub = userServiceStub;
}
@GetMapping("/{id}")
public Map<String, Object> getUser(@PathVariable Long id) {
GetUserRequest request = GetUserRequest.newBuilder().setUserId(id).build();
GetUserResponse response = userServiceStub.getUser(request);
Map<String, Object> result = new HashMap<>();
result.put("code", response.getCode());
result.put("message", response.getMessage());
if (response.hasData()) {
result.put("data", Map.of(
"id", response.getData().getId(),
"username", response.getData().getUsername(),
"nickname", response.getData().getNickname()
));
}
return result;
}
}
4.5 运行 gRPC Demo
bash
# 1. 启动 Go 服务端
cd go-server
protoc --go_out=. --go_opt=paths=source_relative \
--go-grpc_out=. --go-grpc_opt=paths=source_relative \
proto/user.proto
go mod tidy
go run main.go
# 输出:🚀 Go gRPC Server 启动: localhost:19090
# 2. 启动 Java 客户端
cd grpc-demo
mvn clean compile
mvn spring-boot:run
# 3. 测试
curl http://localhost:8080/api/user/1
# {"code":200,"message":"success","data":{"id":1,"username":"salmon","nickname":"Salmon"}}
五、方案二:Dubbo Triple Demo
5.1 项目结构
dubbo-demo/
├── proto/
│ └── user.proto # 接口定义
├── dubbo-api/ # 公共 API 模块
│ ├── pom.xml
│ └── src/main/proto/user.proto
├── dubbo-provider/ # Java 服务提供者
│ ├── pom.xml
│ └── src/main/
│ ├── java/
│ │ └── com/salmon/dubbo/
│ │ ├── DubboProviderApplication.java
│ │ └── service/UserServiceImpl.java
│ └── resources/application.yml
├── dubbo-consumer/ # Java 服务消费者
│ ├── pom.xml
│ └── src/main/
│ ├── java/
│ │ └── com/salmon/dubbo/
│ │ ├── DubboConsumerApplication.java
│ │ └── controller/UserController.java
│ └── resources/application.yml
└── go-consumer/ # Go 消费者(可选)
├── go.mod
├── main.go
└── proto/
5.2 Proto 文件(与 gRPC 相同)
proto/user.proto:
protobuf
syntax = "proto3";
package demo;
option java_multiple_files = true;
option java_package = "com.salmon.dubbo.proto";
option java_outer_classname = "UserProto";
option go_package = "go-consumer/proto;userpb";
service UserService {
rpc GetUser(GetUserRequest) returns (GetUserResponse);
rpc ListUsers(ListUsersRequest) returns (ListUsersResponse);
}
message GetUserRequest {
int64 user_id = 1;
}
message GetUserResponse {
int32 code = 1;
string message = 2;
User data = 3;
}
message ListUsersRequest {
int32 page = 1;
int32 page_size = 2;
}
message ListUsersResponse {
int32 code = 1;
string message = 2;
repeated User data = 3;
int64 total = 4;
}
message User {
int64 id = 1;
string username = 2;
string nickname = 3;
int32 level = 4;
}
5.3 dubbo-api 模块(公共依赖)
dubbo-api/pom.xml:
xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.salmon.dubbo</groupId>
<artifactId>dubbo-api</artifactId>
<version>1.0.0</version>
<properties>
<java.version>21</java.version>
<dubbo.version>3.2.11</dubbo.version>
<protobuf.version>3.25.2</protobuf.version>
</properties>
<dependencies>
<dependency>
<groupId>com.google.protobuf</groupId>
<artifactId>protobuf-java</artifactId>
<version>${protobuf.version}</version>
</dependency>
<dependency>
<groupId>org.apache.dubbo</groupId>
<artifactId>dubbo-common</artifactId>
<version>${dubbo.version}</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:${protobuf.version}:exe:${os.detected.classifier}</protocArtifact>
<pluginId>dubbo</pluginId>
<pluginArtifact>org.apache.dubbo:dubbo-compiler:${dubbo.version}:exe:${os.detected.classifier}</pluginArtifact>
<protoSourceRoot>${project.basedir}/src/main/proto</protoSourceRoot>
</configuration>
<executions>
<execution>
<goals>
<goal>compile</goal>
<goal>compile-custom</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>
执行 mvn compile 后生成的文件:
dubbo-api/target/generated-sources/protobuf/
├── java/ # 消息类
│ └── com/salmon/dubbo/proto/
│ ├── User.java
│ ├── GetUserRequest.java
│ ├── GetUserResponse.java
│ └── ...
└── dubbo/ # Dubbo 服务接口(注意不是 grpc-java)
└── com/salmon/dubbo/proto/
└── DubboUserServiceTriple.java
⚠️ 注意:Dubbo 使用
dubbo-compiler插件,生成的是DubboXxxTriple.java,而不是 gRPC 的XxxGrpc.java
5.4 dubbo-provider 模块(服务提供者)
dubbo-provider/pom.xml:
xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.2.5</version>
</parent>
<groupId>com.salmon.dubbo</groupId>
<artifactId>dubbo-provider</artifactId>
<version>1.0.0</version>
<properties>
<java.version>21</java.version>
<dubbo.version>3.2.11</dubbo.version>
</properties>
<dependencies>
<!-- 公共 API -->
<dependency>
<groupId>com.salmon.dubbo</groupId>
<artifactId>dubbo-api</artifactId>
<version>1.0.0</version>
</dependency>
<!-- Dubbo Spring Boot Starter -->
<dependency>
<groupId>org.apache.dubbo</groupId>
<artifactId>dubbo-spring-boot-starter</artifactId>
<version>${dubbo.version}</version>
</dependency>
<!-- Nacos 注册中心 -->
<dependency>
<groupId>org.apache.dubbo</groupId>
<artifactId>dubbo-registry-nacos</artifactId>
<version>${dubbo.version}</version>
</dependency>
<!-- Spring Boot -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
</dependencies>
</project>
dubbo-provider/src/main/resources/application.yml:
yaml
dubbo:
application:
name: dubbo-user-provider
protocol:
name: tri # Triple 协议
port: 50051
registry:
address: nacos://localhost:8848
server:
port: 8081
UserServiceImpl.java:
java
package com.salmon.dubbo.service;
import com.salmon.dubbo.proto.*;
import org.apache.dubbo.config.annotation.DubboService;
import java.util.HashMap;
import java.util.Map;
@DubboService
public class UserServiceImpl implements DubboUserServiceTriple.IUserService {
private static final Map<Long, User> MOCK_USERS = new HashMap<>();
static {
MOCK_USERS.put(1L, User.newBuilder().setId(1).setUsername("salmon").setNickname("Salmon").setLevel(5).build());
MOCK_USERS.put(2L, User.newBuilder().setId(2).setUsername("test").setNickname("测试用户").setLevel(3).build());
}
@Override
public GetUserResponse getUser(GetUserRequest request) {
User user = MOCK_USERS.get(request.getUserId());
if (user == null) {
return GetUserResponse.newBuilder()
.setCode(404)
.setMessage("用户不存在")
.build();
}
return GetUserResponse.newBuilder()
.setCode(200)
.setMessage("success")
.setData(user)
.build();
}
@Override
public ListUsersResponse listUsers(ListUsersRequest request) {
return ListUsersResponse.newBuilder()
.setCode(200)
.setMessage("success")
.addAllData(MOCK_USERS.values())
.setTotal(MOCK_USERS.size())
.build();
}
}
DubboProviderApplication.java:
java
package com.salmon.dubbo;
import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
@EnableDubbo
public class DubboProviderApplication {
public static void main(String[] args) {
SpringApplication.run(DubboProviderApplication.class, args);
}
}
5.5 dubbo-consumer 模块(服务消费者)
dubbo-consumer/pom.xml:
xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.2.5</version>
</parent>
<groupId>com.salmon.dubbo</groupId>
<artifactId>dubbo-consumer</artifactId>
<version>1.0.0</version>
<properties>
<java.version>21</java.version>
<dubbo.version>3.2.11</dubbo.version>
</properties>
<dependencies>
<dependency>
<groupId>com.salmon.dubbo</groupId>
<artifactId>dubbo-api</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>org.apache.dubbo</groupId>
<artifactId>dubbo-spring-boot-starter</artifactId>
<version>${dubbo.version}</version>
</dependency>
<dependency>
<groupId>org.apache.dubbo</groupId>
<artifactId>dubbo-registry-nacos</artifactId>
<version>${dubbo.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
</project>
dubbo-consumer/src/main/resources/application.yml:
yaml
dubbo:
application:
name: dubbo-user-consumer
registry:
address: nacos://localhost:8848
server:
port: 8080
UserController.java:
java
package com.salmon.dubbo.controller;
import com.salmon.dubbo.proto.*;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.web.bind.annotation.*;
import java.util.HashMap;
import java.util.Map;
@RestController
@RequestMapping("/api/user")
public class UserController {
@DubboReference
private DubboUserServiceTriple.IUserService userService;
@GetMapping("/{id}")
public Map<String, Object> getUser(@PathVariable Long id) {
GetUserRequest request = GetUserRequest.newBuilder().setUserId(id).build();
GetUserResponse response = userService.getUser(request);
Map<String, Object> result = new HashMap<>();
result.put("code", response.getCode());
result.put("message", response.getMessage());
if (response.hasData()) {
result.put("data", Map.of(
"id", response.getData().getId(),
"username", response.getData().getUsername(),
"nickname", response.getData().getNickname()
));
}
return result;
}
@GetMapping("/list")
public Map<String, Object> listUsers() {
ListUsersRequest request = ListUsersRequest.newBuilder().setPage(1).setPageSize(10).build();
ListUsersResponse response = userService.listUsers(request);
Map<String, Object> result = new HashMap<>();
result.put("code", response.getCode());
result.put("message", response.getMessage());
result.put("total", response.getTotal());
result.put("data", response.getDataList());
return result;
}
}
DubboConsumerApplication.java:
java
package com.salmon.dubbo;
import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
@EnableDubbo
public class DubboConsumerApplication {
public static void main(String[] args) {
SpringApplication.run(DubboConsumerApplication.class, args);
}
}
5.6 Go 消费者调用 Dubbo Triple(可选)
Dubbo Triple 兼容 gRPC 协议,Go 可以用原生 gRPC 客户端直接调用:
go-consumer/main.go:
go
package main
import (
"context"
"fmt"
"log"
pb "go-consumer/proto"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials/insecure"
)
func main() {
// 直接连接 Dubbo Triple 服务(兼容 gRPC)
conn, err := grpc.Dial("localhost:50051", grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil {
log.Fatalf("连接失败: %v", err)
}
defer conn.Close()
client := pb.NewUserServiceClient(conn)
resp, err := client.GetUser(context.Background(), &pb.GetUserRequest{UserId: 1})
if err != nil {
log.Fatalf("调用失败: %v", err)
}
fmt.Printf("Response: code=%d, message=%s, user=%+v\n", resp.Code, resp.Message, resp.Data)
}
💡 Dubbo Triple 协议兼容 gRPC,所以 Go 客户端可以直接用原生 gRPC 调用,无需 dubbo-go
5.7 运行 Dubbo Triple Demo
bash
# 0. 启动 Nacos(必须)
# 下载 Nacos: https://nacos.io/download/nacos-server/
sh startup.sh -m standalone
# 访问 http://localhost:8848/nacos 验证
# 1. 编译公共 API
cd dubbo-api
mvn clean install
# 2. 启动 Provider
cd dubbo-provider
mvn spring-boot:run
# 日志:Dubbo service exported: tri://192.168.x.x:50051/...
# 3. 启动 Consumer
cd dubbo-consumer
mvn spring-boot:run
# 4. 测试
curl http://localhost:8080/api/user/1
# {"code":200,"message":"success","data":{"id":1,"username":"salmon","nickname":"Salmon"}}
# 5. Go 调用(可选)
cd go-consumer
go run main.go
# Response: code=200, message=success, user=...
六、两种方案对比总结
6.1 代码对比
| 对比项 | 原生 gRPC | Dubbo Triple |
|---|---|---|
| Maven 插件 | protoc-gen-grpc-java |
dubbo-compiler |
| 生成的服务类 | UserServiceGrpc |
DubboUserServiceTriple |
| 服务端实现 | 继承 ImplBase |
实现 IUserService |
| 客户端调用 | UserServiceGrpc.newBlockingStub() |
@DubboReference 注入 |
| 服务注册 | 手动配置地址 | 自动注册到 Nacos |
| 服务发现 | 硬编码 / 自己集成 | 自动从 Nacos 发现 |
6.2 架构对比
原生 gRPC 架构:
Dubbo Triple 架构:
6.3 选型决策树
七、Spring Cloud Alibaba 多协议共存实战
本节以 Spring Cloud Alibaba 2023.x(对应 Spring Boot 3.2+)为例,演示如何让一个服务同时提供 HTTP 和 gRPC 接口,并注册到 Nacos。
7.1 架构设计
关键点:
- 一个服务注册到 Nacos 时,可以携带元数据标识不同协议的端口
- Java 服务用 Feign 走 HTTP,Go 服务用 gRPC 走 RPC
- 两种协议互不影响,各走各的端口
7.2 项目结构
multi-protocol-demo/
├── user-service/ # 同时提供 HTTP + gRPC
│ ├── pom.xml
│ └── src/main/
│ ├── proto/user.proto
│ ├── java/com/salmon/user/
│ │ ├── UserServiceApplication.java
│ │ ├── controller/UserController.java # HTTP 接口
│ │ ├── grpc/UserGrpcService.java # gRPC 接口
│ │ └── config/GrpcServerConfig.java # gRPC 服务器配置
│ └── resources/application.yml
├── order-service/ # Java 消费者(Feign + gRPC)
│ └── ...
└── go-gateway/ # Go 消费者(gRPC)
└── ...
7.3 user-service 实现(HTTP + gRPC 双协议)
pom.xml:
xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.2.5</version>
</parent>
<groupId>com.salmon</groupId>
<artifactId>user-service</artifactId>
<version>1.0.0</version>
<properties>
<java.version>21</java.version>
<spring-cloud.version>2023.0.1</spring-cloud.version>
<spring-cloud-alibaba.version>2023.0.1.0</spring-cloud-alibaba.version>
<grpc.version>1.62.2</grpc.version>
<protobuf.version>3.25.2</protobuf.version>
</properties>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>${spring-cloud.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-alibaba-dependencies</artifactId>
<version>${spring-cloud-alibaba.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<!-- Spring Cloud Alibaba Nacos -->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<!-- Spring Boot Web (HTTP) -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- gRPC -->
<dependency>
<groupId>io.grpc</groupId>
<artifactId>grpc-netty-shaded</artifactId>
<version>${grpc.version}</version>
</dependency>
<dependency>
<groupId>io.grpc</groupId>
<artifactId>grpc-protobuf</artifactId>
<version>${grpc.version}</version>
</dependency>
<dependency>
<groupId>io.grpc</groupId>
<artifactId>grpc-stub</artifactId>
<version>${grpc.version}</version>
</dependency>
<dependency>
<groupId>io.grpc</groupId>
<artifactId>grpc-services</artifactId>
<version>${grpc.version}</version>
</dependency>
<!-- Java 9+ 注解 -->
<dependency>
<groupId>org.apache.tomcat</groupId>
<artifactId>annotations-api</artifactId>
<version>6.0.53</version>
<scope>provided</scope>
</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:${protobuf.version}:exe:${os.detected.classifier}</protocArtifact>
<pluginId>grpc-java</pluginId>
<pluginArtifact>io.grpc:protoc-gen-grpc-java:${grpc.version}:exe:${os.detected.classifier}</pluginArtifact>
</configuration>
<executions>
<execution>
<goals>
<goal>compile</goal>
<goal>compile-custom</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>
application.yml:
yaml
server:
port: 8080 # HTTP 端口
spring:
application:
name: user-service
cloud:
nacos:
discovery:
server-addr: localhost:8848
metadata:
# 关键:在元数据中声明 gRPC 端口
grpc-port: 19090
# 自定义 gRPC 配置
grpc:
server:
port: 19090 # gRPC 端口
GrpcServerConfig.java(启动 gRPC 服务器):
java
package com.salmon.user.config;
import com.salmon.user.grpc.UserGrpcService;
import io.grpc.Server;
import io.grpc.ServerBuilder;
import io.grpc.protobuf.services.ProtoReflectionService;
import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import java.io.IOException;
@Configuration
public class GrpcServerConfig {
@Value("${grpc.server.port:19090}")
private int grpcPort;
private Server grpcServer;
private final UserGrpcService userGrpcService;
public GrpcServerConfig(UserGrpcService userGrpcService) {
this.userGrpcService = userGrpcService;
}
@PostConstruct
public void startGrpcServer() throws IOException {
grpcServer = ServerBuilder.forPort(grpcPort)
.addService(userGrpcService)
.addService(ProtoReflectionService.newInstance()) // 反射服务,方便调试
.build()
.start();
System.out.println("🚀 gRPC Server started on port: " + grpcPort);
}
@PreDestroy
public void stopGrpcServer() {
if (grpcServer != null) {
grpcServer.shutdown();
System.out.println("gRPC Server stopped");
}
}
}
UserController.java(HTTP 接口):
java
package com.salmon.user.controller;
import org.springframework.web.bind.annotation.*;
import java.util.Map;
@RestController
@RequestMapping("/api/user")
public class UserController {
@GetMapping("/{id}")
public Map<String, Object> getUser(@PathVariable Long id) {
// HTTP 接口,供 Feign 调用
return Map.of(
"code", 200,
"message", "success",
"data", Map.of("id", id, "username", "salmon", "nickname", "Salmon")
);
}
@GetMapping("/list")
public Map<String, Object> listUsers() {
return Map.of("code", 200, "message", "success", "total", 2);
}
}
UserGrpcService.java(gRPC 接口):
java
package com.salmon.user.grpc;
import com.salmon.user.proto.*;
import io.grpc.stub.StreamObserver;
import org.springframework.stereotype.Service;
@Service
public class UserGrpcService extends UserServiceGrpc.UserServiceImplBase {
@Override
public void getUser(GetUserRequest request, StreamObserver<GetUserResponse> responseObserver) {
// gRPC 接口,供 Go 或其他 gRPC 客户端调用
GetUserResponse response = GetUserResponse.newBuilder()
.setCode(200)
.setMessage("success")
.setData(User.newBuilder()
.setId(request.getUserId())
.setUsername("salmon")
.setNickname("Salmon")
.build())
.build();
responseObserver.onNext(response);
responseObserver.onCompleted();
}
}
7.4 Go 服务通过 Nacos 发现并调用 Java gRPC
go-gateway/main.go:
go
package main
import (
"context"
"fmt"
"log"
pb "go-gateway/proto"
"github.com/nacos-group/nacos-sdk-go/v2/clients"
"github.com/nacos-group/nacos-sdk-go/v2/common/constant"
"github.com/nacos-group/nacos-sdk-go/v2/vo"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials/insecure"
)
func main() {
// 1. 创建 Nacos 客户端
sc := []constant.ServerConfig{
{IpAddr: "localhost", Port: 8848},
}
cc := constant.ClientConfig{
NamespaceId: "public",
TimeoutMs: 5000,
}
namingClient, err := clients.NewNamingClient(
vo.NacosClientParam{ServerConfigs: sc, ClientConfig: &cc},
)
if err != nil {
log.Fatalf("创建 Nacos 客户端失败: %v", err)
}
// 2. 从 Nacos 获取服务实例
instance, err := namingClient.SelectOneHealthyInstance(vo.SelectOneHealthInstanceParam{
ServiceName: "user-service",
})
if err != nil {
log.Fatalf("获取服务实例失败: %v", err)
}
// 3. 从元数据获取 gRPC 端口
grpcPort := instance.Metadata["grpc-port"]
if grpcPort == "" {
grpcPort = "19090" // 默认端口
}
target := fmt.Sprintf("%s:%s", instance.Ip, grpcPort)
fmt.Printf("发现服务: %s, gRPC 地址: %s\n", instance.ServiceName, target)
// 4. 建立 gRPC 连接
conn, err := grpc.Dial(target, grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil {
log.Fatalf("连接失败: %v", err)
}
defer conn.Close()
// 5. 调用 gRPC 接口
client := pb.NewUserServiceClient(conn)
resp, err := client.GetUser(context.Background(), &pb.GetUserRequest{UserId: 1})
if err != nil {
log.Fatalf("调用失败: %v", err)
}
fmt.Printf("gRPC 响应: code=%d, user=%+v\n", resp.Code, resp.Data)
}
go.mod:
go
module go-gateway
go 1.21
require (
github.com/nacos-group/nacos-sdk-go/v2 v2.2.5
google.golang.org/grpc v1.62.0
google.golang.org/protobuf v1.32.0
)
7.5 Java 服务通过 Nacos 调用 Go gRPC 服务
假设 Go 也提供了一个 gRPC 服务并注册到 Nacos:
GrpcClientConfig.java:
java
package com.salmon.order.config;
import com.alibaba.cloud.nacos.NacosDiscoveryProperties;
import com.alibaba.nacos.api.naming.NamingService;
import com.alibaba.nacos.api.naming.pojo.Instance;
import com.salmon.user.proto.UserServiceGrpc;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class GrpcClientConfig {
private final NacosDiscoveryProperties nacosProperties;
public GrpcClientConfig(NacosDiscoveryProperties nacosProperties) {
this.nacosProperties = nacosProperties;
}
@Bean
public UserServiceGrpc.UserServiceBlockingStub userServiceStub() throws Exception {
// 1. 获取 Nacos NamingService
NamingService namingService = nacosProperties.namingServiceInstance();
// 2. 获取健康实例
Instance instance = namingService.selectOneHealthyInstance("go-user-service");
// 3. 从元数据获取 gRPC 端口
String grpcPort = instance.getMetadata().getOrDefault("grpc-port", "19090");
String target = instance.getIp() + ":" + grpcPort;
System.out.println("发现 Go 服务: " + target);
// 4. 创建 gRPC Channel
ManagedChannel channel = ManagedChannelBuilder.forTarget(target)
.usePlaintext()
.build();
return UserServiceGrpc.newBlockingStub(channel);
}
}
7.6 Nacos 注册信息示例
在 Nacos 控制台(http://localhost:8848/nacos)可以看到:
json
{
"serviceName": "user-service",
"ip": "192.168.1.10",
"port": 8080,
"metadata": {
"grpc-port": "19090",
"preserved.register.source": "SPRING_CLOUD"
}
}
7.7 多协议调用流程总结
关键点:
- HTTP 端口:注册到 Nacos 的
port字段,Feign 默认使用 - gRPC 端口:放在
metadata中,gRPC 客户端需要手动读取 - 两个端口独立:HTTP 走 8080,gRPC 走 19090,互不影响
- Go 和 Java 互通:都通过 Nacos 发现服务,然后读取 metadata 获取 gRPC 端口
八、gRPC 原理简述
8.1 通信流程
8.2 为什么 gRPC 高效?
- Protobuf 二进制序列化:比 JSON 小 3-10 倍,解析快 20-100 倍
- HTTP/2 多路复用:单连接并发多个请求,无队头阻塞
- 头部压缩:HPACK 算法压缩 HTTP 头
- 流式传输:支持双向流,适合实时场景
8.3 四种调用模式
protobuf
service UserService {
// 1. 一元调用(最常用)
rpc GetUser(Request) returns (Response);
// 2. 服务端流(服务端推送多条数据)
rpc ListUsers(Request) returns (stream Response);
// 3. 客户端流(客户端发送多条数据)
rpc UploadUsers(stream Request) returns (Response);
// 4. 双向流(实时通信)
rpc Chat(stream Request) returns (stream Response);
}
九、常见问题
Q1: Java 9+ 编译报错 找不到 javax.annotation.Generated?
添加依赖:
xml
<dependency>
<groupId>org.apache.tomcat</groupId>
<artifactId>annotations-api</artifactId>
<version>6.0.53</version>
<scope>provided</scope>
</dependency>
Q2: proto 文件放在哪里管理?
推荐独立 Git 仓库,各项目通过 submodule 或复制引用:
proto-repo/ # 独立仓库
├── user.proto
├── order.proto
└── common.proto
Q3: IDEA 看不到生成的代码?
刷新 Maven 项目,或手动标记 target/generated-sources/protobuf/java 为 Sources Root。
Q4: Dubbo Triple 能被原生 gRPC 客户端调用吗?
可以!Dubbo Triple 协议兼容 gRPC,Go/Python 等语言可以用原生 gRPC 客户端直接调用。
Q5: 如何处理时间类型?
推荐使用字符串(ISO 8601 格式),跨语言更简单:
protobuf
message User {
string created_at = 1; // "2024-01-01T12:00:00Z"
}
总结
| 方案 | 适用场景 | 优点 | 缺点 |
|---|---|---|---|
| 原生 gRPC | K8s、简单跨语言、性能敏感 | 轻量、标准、多语言支持好 | 无服务治理,需自己集成注册中心 |
| Dubbo Triple | Java 微服务、传统部署、需要服务治理 | 内置 Nacos、限流熔断、生态成熟 | 学习成本稍高,主要面向 Java |
核心要点:
- Proto 文件是跨语言的契约,一次定义多语言生成
- K8s 环境优先考虑原生 gRPC
- Java 微服务体系优先考虑 Dubbo Triple
- Dubbo Triple 兼容 gRPC,可以混合使用
参考资料: