跨语言 RPC 实战:gRPC 与 Dubbo Triple 对比

2025-12-31后端15 分钟274 次阅读
AI 摘要salmon-ai

本文详细解析了 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

目录


一、技术选型指南

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 一图看懂选型

flowchart TD A[需要跨语言 RPC?] --> B{K8s 环境?} A --> C{传统部署?} B -->|简单调用| D[原生 gRPC] B -->|需要服务网格| E[gRPC + Istio] C -->|Java 为主| F[Dubbo Triple] C -->|多语言为主| G[gRPC + Nacos] style D fill:#90EE90 style E fill:#87CEEB style F fill:#FFB6C1 style G fill:#DDA0DD

二、Protocol Buffers 基础

2.1 什么是 Protocol Buffers?

Protocol Buffers(简称 Protobuf)是 Google 开发的一种语言无关、平台无关的数据序列化格式。它是 gRPC 的基础。

核心价值:一份 .proto 文件定义接口,自动生成多种语言的代码。

flowchart TB subgraph proto["📄 user.proto (接口定义)"] desc["一次定义,多语言生成"] end proto -->|protoc 编译器| java["☕ Java 代码"] proto -->|protoc 编译器| go["🐹 Go 代码"] proto -->|protoc 编译器| python["🐍 Python 代码"] proto -->|protoc 编译器| rust["🦀 Rust 代码"]

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 架构:

flowchart LR subgraph Client["☕ Java Client"] C1[硬编码 IP:Port] end subgraph Server["🐹 Go Server"] S1[":19090"] end Client -->|gRPC| Server

Dubbo Triple 架构:

flowchart LR subgraph Consumer["Consumer :8080"] C1[发现服务] end subgraph Nacos["Nacos :8848"] N1[服务注册表] end subgraph Provider["Provider :50051"] P1[注册服务] end Consumer <-->|服务发现| Nacos Provider <-->|服务注册| Nacos Consumer -->|Triple| Provider

6.3 选型决策树

flowchart TD A[需要跨语言 RPC?] --> B{是 K8s 环境?} B -->|是| C{需要服务治理?} B -->|否| D{Java 为主?} C -->|否| E[✅ 原生 gRPC] C -->|是| F[✅ gRPC + Istio] D -->|是| G{需要服务治理?} D -->|否| H[✅ gRPC + Nacos] G -->|是| I[✅ Dubbo Triple + Nacos] G -->|否| J[✅ 原生 gRPC] style E fill:#90EE90 style F fill:#87CEEB style H fill:#DDA0DD style I fill:#FFB6C1 style J fill:#90EE90

七、Spring Cloud Alibaba 多协议共存实战

本节以 Spring Cloud Alibaba 2023.x(对应 Spring Boot 3.2+)为例,演示如何让一个服务同时提供 HTTP 和 gRPC 接口,并注册到 Nacos。

7.1 架构设计

flowchart TB subgraph Nacos["Nacos 注册中心"] direction TB N1["user-service<br/>192.168.1.10:8080 (HTTP)<br/>metadata: grpc-port=19090"] end subgraph UserService["user-service"] HTTP[":8080 HTTP"] GRPC[":19090 gRPC"] end subgraph JavaClient["☕ Java 服务"] Feign["Feign Client<br/>GET /api/user/1"] end subgraph GoClient["🐹 Go 服务"] GrpcClient["gRPC Client<br/>rpc GetUser()"] end UserService -->|注册| Nacos JavaClient -->|发现 port:8080| Nacos GoClient -->|发现 metadata.grpc-port| Nacos Feign -->|HTTP :8080| HTTP GrpcClient -->|gRPC :19090| GRPC

关键点:

  • 一个服务注册到 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 多协议调用流程总结

flowchart TB subgraph Nacos["Nacos 注册中心"] ServiceInfo["user-service<br/>ip: 192.168.1.10<br/>port: 8080<br/>metadata: {grpc-port: 19090}"] end subgraph Consumers["消费者"] direction LR subgraph FeignCall["order-service (Feign)"] F1["读取 port → :8080"] F2["HTTP 调用"] end subgraph GrpcCall1["order-service (gRPC)"] G1["读取 metadata → :19090"] G2["gRPC 调用"] end subgraph GrpcCall2["go-gateway (gRPC)"] G3["读取 metadata → :19090"] G4["gRPC 调用"] end end Nacos --> FeignCall Nacos --> GrpcCall1 Nacos --> GrpcCall2

关键点:

  1. HTTP 端口:注册到 Nacos 的 port 字段,Feign 默认使用
  2. gRPC 端口:放在 metadata 中,gRPC 客户端需要手动读取
  3. 两个端口独立:HTTP 走 8080,gRPC 走 19090,互不影响
  4. Go 和 Java 互通:都通过 Nacos 发现服务,然后读取 metadata 获取 gRPC 端口

八、gRPC 原理简述

8.1 通信流程

sequenceDiagram participant Client as ☕ Java Client participant Stub as UserService Stub participant PB1 as Protobuf 序列化 participant HTTP as HTTP/2 网络传输 participant PB2 as Protobuf 反序列化 participant Server as 🐹 Go Server Client->>Stub: 1. 调用 getUser(request) Stub->>PB1: 2. 构建 Request 对象 PB1->>HTTP: 3. 序列化为二进制 HTTP->>PB2: 4. 网络传输 (HTTP/2) PB2->>Server: 5. 反序列化为 Go 结构体 Server->>Server: 6. 执行业务逻辑 Server->>PB2: 7. 构建 Response PB2->>HTTP: 8. 序列化响应 HTTP->>PB1: 9. 网络传输 PB1->>Client: 10. 返回 Java 对象

8.2 为什么 gRPC 高效?

  1. Protobuf 二进制序列化:比 JSON 小 3-10 倍,解析快 20-100 倍
  2. HTTP/2 多路复用:单连接并发多个请求,无队头阻塞
  3. 头部压缩:HPACK 算法压缩 HTTP 头
  4. 流式传输:支持双向流,适合实时场景

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,可以混合使用

参考资料:

觉得有用就点个赞,不用登录也能读

评论

0 条
登录 之后才能评论
—
还没有评论,来说第一句