Golang实现gRPC：proto定义与代码生成全解析

本文详细介绍了如何使用 Golang 开发 gRPC 服务，重点在于 `.proto` 文件的定义和代码生成。首先，需要安装 `protoc` 编译器和 Golang 的 gRPC 插件，然后通过编写清晰的 `.proto` 文件来定义服务接口和消息类型，例如定义 Greeter 服务及其 SayHello 方法。接着，使用 `protoc` 命令生成 Golang 代码，包括服务接口和消息类型。文章还阐述了如何实现 gRPC 服务端和客户端逻辑，并详细讲解了 gRPC 服务的错误处理机制，通过 `status` 包返回错误码和消息。最后，探讨了 gRPC 的流式传输功能，通过在 `.proto` 文件中定义 `stream` 关键字实现双向流通信。

编写清晰的 .proto 文件需定义 syntax、package、service 和 message，使用 proto3 语法声明服务接口与消息类型，如 Greeter 服务包含 SayHello 方法；通过 protoc 生成 Go 代码后，在服务端实现接口逻辑并启动 gRPC 服务器，客户端创建连接并调用方法；错误处理使用 status 包返回错误码与消息；流式传输通过在 .proto 中定义 stream 关键字实现双向流通信。

用 Golang 开发 gRPC 服务，核心在于定义 .proto 文件来描述服务接口，然后使用 protoc 编译器生成 Golang 代码，包括服务接口和消息类型。

定义 .proto 文件并生成代码，再编写服务端和客户端逻辑。

如何编写清晰的 .proto 文件来定义 gRPC 服务？

首先，你需要安装 protoc 编译器和 Golang 的 gRPC 插件。 然后，创建一个 .proto 文件，比如 service.proto，在里面定义你的服务接口和消息类型。

syntax = "proto3";

package example;

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

这个例子定义了一个 Greeter 服务，包含一个 SayHello 方法，接收 HelloRequest 消息，返回 HelloReply 消息。

接下来，使用 protoc 编译器生成 Golang 代码：

protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative service.proto

这会生成 service.pb.go 和 service_grpc.pb.go 两个文件，包含定义的消息类型和服务接口。

如何实现 gRPC 服务端？

有了生成的代码，就可以编写服务端逻辑了。 创建一个 server.go 文件：

package main

import (
    "context"
    "fmt"
    "log"
    "net"

    "google.golang.org/grpc"
    pb "example" // 替换为你的包名
)

type server struct {
    pb.UnimplementedGreeterServer
}

func (s *server) SayHello(ctx context.Context, req *pb.HelloRequest) (*pb.HelloReply, error) {
    return &pb.HelloReply{Message: "Hello " + req.Name}, nil
}

func main() {
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }
    s := grpc.NewServer()
    pb.RegisterGreeterServer(s, &server{})
    fmt.Println("Server listening on :50051")
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

这个服务端实现了 Greeter 接口的 SayHello 方法，并监听 50051 端口。

如何编写 gRPC 客户端？

类似地，创建一个 client.go 文件：

package main

import (
    "context"
    "log"
    "os"
    "time"

    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials/insecure"
    pb "example" // 替换为你的包名
)

const (
    address     = "localhost:50051"
    defaultName = "world"
)

func main() {
    conn, err := grpc.Dial(address, grpc.WithTransportCredentials(insecure.NewCredentials()))
    if err != nil {
        log.Fatalf("did not connect: %v", err)
    }
    defer conn.Close()
    c := pb.NewGreeterClient(conn)

    name := defaultName
    if len(os.Args) > 1 {
        name = os.Args[1]
    }

    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel()
    r, err := c.SayHello(ctx, &pb.HelloRequest{Name: name})
    if err != nil {
        log.Fatalf("could not greet: %v", err)
    }
    log.Printf("Greeting: %s", r.Message)
}

这个客户端连接到服务端，调用 SayHello 方法，并打印返回的消息。

如何处理 gRPC 服务的错误？

gRPC 错误处理通常通过返回 error 类型来实现。 在服务端，你可以返回 status.Error 来传递更详细的错误信息，例如错误码和错误消息。

import (
    "context"
    "fmt"
    "log"
    "net"

    "google.golang.org/grpc"
    "google.golang.org/grpc/status"
    "google.golang.org/grpc/codes"
    pb "example" // 替换为你的包名
)

type server struct {
    pb.UnimplementedGreeterServer
}

func (s *server) SayHello(ctx context.Context, req *pb.HelloRequest) (*pb.HelloReply, error) {
    if req.Name == "" {
        return nil, status.Error(codes.InvalidArgument, "Name cannot be empty")
    }
    return &pb.HelloReply{Message: "Hello " + req.Name}, nil
}

func main() {
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }
    s := grpc.NewServer()
    pb.RegisterGreeterServer(s, &server{})
    fmt.Println("Server listening on :50051")
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

在客户端，你可以检查返回的 error 是否为 status.Error，并获取错误码和错误消息。

import (
    "context"
    "log"
    "os"
    "time"

    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials/insecure"
    "google.golang.org/grpc/status"
    pb "example" // 替换为你的包名
)

const (
    address     = "localhost:50051"
    defaultName = "world"
)

func main() {
    conn, err := grpc.Dial(address, grpc.WithTransportCredentials(insecure.NewCredentials()))
    if err != nil {
        log.Fatalf("did not connect: %v", err)
    }
    defer conn.Close()
    c := pb.NewGreeterClient(conn)

    name := defaultName
    if len(os.Args) > 1 {
        name = os.Args[1]
    }

    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel()
    r, err := c.SayHello(ctx, &pb.HelloRequest{Name: name})
    if err != nil {
        st, ok := status.FromError(err)
        if ok {
            log.Printf("gRPC error: code=%s, message=%s", st.Code(), st.Message())
        } else {
            log.Fatalf("could not greet: %v", err)
        }
        return
    }
    log.Printf("Greeting: %s", r.Message)
}

如何使用 gRPC 的 Stream 功能？

gRPC 支持流式传输，允许服务端和客户端双向发送多个消息。 在 .proto 文件中，可以使用 stream 关键字定义流式 RPC。

syntax = "proto3";

package example;

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply) {}
  rpc SayHelloStream (stream HelloRequest) returns (stream HelloReply) {}
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

这里定义了一个 SayHelloStream 方法，接收一个 HelloRequest 消息流，返回一个 HelloReply 消息流。

服务端实现：

func (s *server) SayHelloStream(stream pb.Greeter_SayHelloStreamServer) error {
    for {
        req, err := stream.Recv()
        if err == io.EOF {
            return nil
        }
        if err != nil {
            return err
        }
        err = stream.Send(&pb.HelloReply{Message: "Hello " + req.Name})
        if err != nil {
            return err
        }
    }
}

客户端实现：

func main() {
    conn, err := grpc.Dial(address, grpc.WithTransportCredentials(insecure.NewCredentials()))
    if err != nil {
        log.Fatalf("did not connect: %v", err)
    }
    defer conn.Close()
    c := pb.NewGreeterClient(conn)

    stream, err := c.SayHelloStream(context.Background())
    if err != nil {
        log.Fatalf("could not greet: %v", err)
    }

    for i := 0; i < 5; i++ {
        err := stream.Send(&pb.HelloRequest{Name: fmt.Sprintf("world %d", i)})
        if err != nil {
            log.Fatalf("could not send: %v", err)
        }
        resp, err := stream.Recv()
        if err == io.EOF {
            break
        }
        if err != nil {
            log.Fatalf("could not receive: %v", err)
        }
        log.Printf("Greeting: %s", resp.Message)
    }

    err = stream.CloseSend()
    if err != nil {
        log.Fatalf("could not close: %v", err)
    }
}

理论要掌握，实操不能落！以上关于《Golang实现gRPC：proto定义与代码生成全解析》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！