RPC(Remote Procedure Call)即远程过程调用,是一种允许程序像调用本地函数一样调用远程服务的技术。在分布式系统中,RPC是微服务间通信的核心机制。
Go语言作为云原生时代的首选语言,其并发模型(goroutine + channel)天然适配高并发RPC场景。但标准库net/rpc功能有限,无法满足生产环境对服务发现、负载均衡、熔断降级等需求。因此,社区涌现出一批专业go语言rpc框架,如gRPC、go-micro、kratos、rpcx等。
与Java生态的Dubbo、Spring Cloud不同,Go的go语言rpc框架更强调轻量、高效、可组合性,通常基于Protocol Buffers或自定义二进制协议,避免重量级依赖,契合云原生“小而美”的服务设计哲学。
当前主流go语言rpc框架各具特色:
选择框架需综合考虑:团队熟悉度、性能要求、生态集成、长期维护成本。新手建议从gRPC入门,进阶后可探索kratos或Kitex构建复杂系统。
| 特性 | gRPC | go-micro | kratos | rpcx |
|---|---|---|---|---|
| 协议支持 | HTTP/2 + Protobuf | 自定义(默认JSON) | gRPC + HTTP | 自定义(二进制/JSON) |
| 服务发现 | 需集成Consul/Etcd | 内置(支持多后端) | 内置(基于Consul) | 内置(支持ZK/Etcd) |
| 负载均衡 | 客户端轮询/随机 | 内置(支持多种策略) | 客户端(RoundRobin/Random) | 内置(支持权重、就近) |
| 熔断降级 | 需集成Hystrix | 需插件(如go-micro/registry) | 内置(基于circuit-breaker) | 需插件(如rpcx/plugins) |
| 链路追踪 | 支持OpenTelemetry | 需集成Jaeger/Zipkin | 内置OpenTelemetry支持 | 需插件(如rpcx/plugins/zipkin) |
| 学习曲线 | 中等(需理解Protobuf) | 较高(概念较多) | 中高(DDD+微服务知识) | 低(插件化,可渐进式使用) |
许多开发者困惑:何时用gRPC,何时用HTTP?以下为关键决策维度:
实际项目中常采用混合架构:用户端用HTTP/REST,内部服务用gRPC通信。例如:用户请求 → Nginx → API Gateway(HTTP)→ 内部服务(gRPC)→ 数据库。
gRPC基于HTTP/2协议,使用Protocol Buffers作为接口定义语言(IDL)和序列化格式。其核心优势在于:
Go中使用gRPC需三步:
1. 定义.proto文件(user.proto):
// user.proto
syntax = "proto3";
package user;
service UserService {
// 一元调用
rpc GetUser(GetUserRequest) returns (GetUserResponse);
// 服务端流式
rpc ListUsers(UserFilter) returns (stream User);
}
message GetUserRequest {
int64 id = 1;
}
message GetUserResponse {
int64 id = 1;
string name = 2;
string email = 3;
}
message UserFilter {
int32 page = 1;
int32 page_size = 2;
}
message User {
int64 id = 1;
string name = 2;
string email = 3;
}
2. 生成Go代码:
# 安装插件
go get -u google.golang.org/protobuf/cmd/protoc-gen-go
go get -u google.golang.org/grpc/cmd/protoc-gen-go-grpc
# 生成
protoc --go_out=. --go-grpc_out=. user.proto
3. 服务端实现:
// server.go
package main
import (
"context"
"log"
"net"
"google.golang.org/grpc"
"google.golang.org/grpc/reflection"
"pb" // 生成的包
)
type server struct {
pb.UnimplementedUserServiceServer
}
func (s *server) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.GetUserResponse, error) {
// 查询数据库逻辑
return &pb.GetUserResponse{
Id: req.GetId(),
Name: "张三",
Email: "zhangsan@example.com",
}, nil
}
func main() {
lis, err := net.Listen("tcp", ":50051")
if err != nil {
log.Fatalf("failed to listen: %v", err)
}
s := grpc.NewServer()
pb.RegisterUserServiceServer(s, &server{})
reflection.Register(s) // 启用反射,便于调试
log.Println("gRPC server listening on :50051")
s.Serve(lis)
}
4. 客户端调用:
// client.go
package main
import (
"context"
"log"
"time"
"google.golang.org/grpc"
"pb"
)
func main() {
conn, err := grpc.Dial("localhost:50051", grpc.WithInsecure(), grpc.WithBlock())
if err != nil {
log.Fatalf("did not connect: %v", err)
}
defer conn.Close()
c := pb.NewUserServiceClient(conn)
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
r, err := c.GetUser(ctx, &pb.GetUserRequest{Id: 123})
if err != nil {
log.Fatalf("could not greet: %v", err)
}
log.Printf("User: %s (%s)", r.GetName(), r.GetEmail())
}
传统HTTP请求-响应模式无法满足实时场景。gRPC的流式特性可高效实现:
以下为服务端流式示例(用户列表流):
// proto中已定义ListUsers
func (s *server) ListUsers(filter *pb.UserFilter, stream pb.UserService_ListUsersServer) error {
// 模拟分页查询
page := filter.GetPage()
pageSize := filter.GetPageSize()
start := (page - 1) * pageSize
end := start + pageSize
// 模拟数据库查询结果
users := []struct {
Id int64
Name string
Email string
}{
{1, "用户1", "user1@test.com"},
{2, "用户2", "user2@test.com"},
{3, "用户3", "user3@test.com"},
}
for i := start; i < end && i < len(users); i++ {
err := stream.Send(&pb.User{
Id: users[i].Id,
Name: users[i].Name,
Email: users[i].Email,
})
if err != nil {
return err
}
}
return nil
}
客户端消费流:
stream, err := c.ListUsers(ctx, &pb.UserFilter{Page: 1, PageSize: 10})
if err != nil {
log.Fatal(err)
}
for {
user, err := stream.Recv()
if err == io.EOF {
break
}
if err != nil {
log.Fatal(err)
}
log.Printf("Received user: %s", user.GetName())
}
关键点:流式调用需在服务端处理好客户端断开连接的情况(通过context.Done()监听)。
拦截器(Interceptor)是gRPC的AOP机制,类似中间件。常用场景:
实现日志拦截器示例:
func LoggingInterceptor() grpc.UnaryServerInterceptor {
return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
start := time.Now()
log.Printf("[RPC] %s called with %v", info.FullMethod, req)
resp, err := handler(ctx, req)
log.Printf("[RPC] %s completed in %v, err=%v", info.FullMethod, time.Since(start), err)
return resp, err
}
}
# 使用
s := grpc.NewServer(grpc.UnaryInterceptor(LoggingInterceptor()))
客户端拦截器同理:可用于添加TraceID、统计RT、重试逻辑。
go-micro是Go生态中最早的微服务框架之一,提供完整的微服务解决方案:
与gRPC不同,go-micro提供更高层抽象,开发者更关注业务逻辑,而非底层通信细节。
1. 服务端注册服务:
package main
import (
"context"
"fmt"
"log"
"github.com/micro/go-micro"
"github.com/micro/go-micro/registry"
"github.com/micro/go-micro/registry/etcd"
)
type User struct{}
func (u *User) Get(ctx context.Context, req *struct{Id int64}, rsp *struct{Name string}) error {
rsp.Name = "张三"
return nil
}
func main() {
# 初始化注册中心
reg := etcd.NewRegistry(registry.Addrs("127.0.0.1:2379"))
# 创建服务
service := micro.NewService(
micro.Name("go.micro.srv.user"),
micro.Registry(reg),
)
# 注册处理器
micro.RegisterHandler("User", "Get", new(User))
# 启动服务
if err := service.Run(); err != nil {
log.Fatal(err)
}
}
2. 客户端发现服务:
package main
import (
"context"
"fmt"
"log"
"github.com/micro/go-micro"
"github.com/micro/go-micro/registry"
"github.com/micro/go-micro/registry/etcd"
)
func main() {
reg := etcd.NewRegistry(registry.Addrs("127.0.0.1:2379"))
service := micro.NewService(
micro.Name("go.micro.cli.user"),
micro.Registry(reg),
)
# 创建客户端
userClient := service.Client().NewNode("go.micro.srv.user")
# 发起调用
var rsp struct{Name string}
err := userClient.Call(context.Background(), "User", "Get", &struct{Id int64}{123}, &rsp)
if err != nil {
log.Fatal(err)
}
fmt.Println("User Name:", rsp.Name)
}
关键点:服务名需唯一(如go.micro.srv.user),客户端通过服务名发现实例,Selector自动选择节点。
当服务间无需同步等待时,用Broker实现异步通信,解耦系统:
发布订单事件:
func CreateOrder(order *Order) error {
# 保存订单...
# 发布事件
msg := broker.NewMessage("order.created", order)
return broker.Publish(context.Background(), msg)
}
订阅事件(如发送邮件):
func SendEmailHandler(msg *broker.Message) error {
var order Order
if err := msg.Decode(&order); err != nil {
return err
}
# 发送邮件逻辑...
log.Printf("Email sent to user %d", order.UserId)
return nil
}
# 启动订阅
broker.Subscribe("order.created", broker.HandlerFunc(SendEmailHandler))
优势:订单服务无需知道谁消费事件,新增功能(如通知、库存扣减)只需新增订阅者,实现松耦合。