4. gRPC入门：Protobuf定义因子评分服务、gRPC服务端与客户端快速实现

在低延迟因子评分系统中，服务间通信的效率直接决定了端到端的响应时间。传统的 REST/JSON 方案在序列化、传输协议和连接管理上存在较大开销。本章将引入 gRPC 作为核心通信框架，通过 Protocol Buffers (Protobuf) 定义因子评分服务接口，并快速搭建服务端与客户端。

4.1 为什么选择 gRPC 作为因子评分通信协议

gRPC 基于 HTTP/2 协议，使用 Protobuf 作为接口定义语言（IDL）和序列化工具，相比 REST/JSON 具有以下关键优势：

4.2 Protobuf 定义因子评分服务

首先，在 proto 目录下创建 factorscore.proto 文件，定义评分请求、响应消息以及服务接口。

syntax = "proto3";

package factorscore;

option go_package = "github.com/yourorg/factorscore/proto";

// 单个因子输入
message FactorInput {
  string factor_name = 1;   // 因子名称，如 "credit_score"
  double value = 2;         // 因子数值
  map<string, string> metadata = 3; // 扩展元数据
}

// 评分请求
message ScoreRequest {
  string request_id = 1;            // 请求追踪 ID
  repeated FactorInput factors = 2; // 因子列表，至少 1 个
  int32 timeout_ms = 3;             // 期望超时（毫秒）
}

// 评分响应
message ScoreResponse {
  string request_id = 1;            // 回显请求 ID
  double score = 2;                 // 最终评分结果
  double confidence = 3;            // 置信度 [0.0, 1.0]
  map<string, double> factor_contributions = 4; // 各因子贡献度
  string error_message = 5;         // 错误信息，成功时为空
}

// 因子评分服务定义
service FactorScoreService {
  // 一元 RPC：单次评分
  rpc ComputeScore(ScoreRequest) returns (ScoreResponse);

  // 服务端流式 RPC：批量评分，逐个返回结果
  rpc BatchComputeScore(stream ScoreRequest) returns (stream ScoreResponse);
}

4.3 gRPC 服务端快速实现

以下使用 Go 语言实现服务端。首先安装 protoc 及 Go 插件，生成代码：

protoc --go_out=. --go-grpc_out=. factorscore.proto

生成的 factorscore.pb.go 和 factorscore_grpc.pb.go 包含消息类型和服务接口。服务端实现：

package main

import (
    "context"
    "log"
    "net"
    "time"

    pb "github.com/yourorg/factorscore/proto"
    "google.golang.org/grpc"
    "google.golang.org/grpc/reflection"
)

type scoreServer struct {
    pb.UnimplementedFactorScoreServiceServer
}

// 一元 RPC 实现
func (s *scoreServer) ComputeScore(ctx context.Context, req *pb.ScoreRequest) (*pb.ScoreResponse, error) {
    // 模拟评分计算逻辑
    score := 0.0
    for _, f := range req.Factors {
        score += f.Value * 0.1 // 简化加权
    }
    return &pb.ScoreResponse{
        RequestId: req.RequestId,
        Score:     score,
        Confidence: 0.95,
    }, nil
}

// 服务端流式 RPC 实现
func (s *scoreServer) BatchComputeScore(stream pb.FactorScoreService_BatchComputeScoreServer) error {
    for {
        req, err := stream.Recv()
        if err != nil {
            return err
        }
        // 模拟逐个计算并发送
        resp := &pb.ScoreResponse{
            RequestId: req.RequestId,
            Score:     0.5,
            Confidence: 0.8,
        }
        if err := stream.Send(resp); err != nil {
            return err
        }
    }
}

func main() {
    lis, _ := net.Listen("tcp", ":50051")
    s := grpc.NewServer(
        grpc.UnaryInterceptor(UnaryLatencyInterceptor), // 自定义拦截器
    )
    pb.RegisterFactorScoreServiceServer(s, &scoreServer{})
    reflection.Register(s)
    log.Fatal(s.Serve(lis))
}

// 一元拦截器示例：记录延迟
func UnaryLatencyInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
    start := time.Now()
    resp, err := handler(ctx, req)
    log.Printf("[gRPC] %s took %v", info.FullMethod, time.Since(start))
    return resp, err
}

4.4 gRPC 客户端快速实现

客户端代码同样基于生成的 proto 代码：

package main

import (
    "context"
    "log"
    "time"

    pb "github.com/yourorg/factorscore/proto"
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials/insecure"
)

func main() {
    conn, err := grpc.Dial("localhost:50051",
        grpc.WithTransportCredentials(insecure.NewCredentials()),
        grpc.WithDefaultCallOptions(
            grpc.MaxCallRecvMsgSize(4*1024*1024), // 4MB
            grpc.WaitForReady(true),              // 等待连接就绪
        ),
    )
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()

    client := pb.NewFactorScoreServiceClient(conn)

    // 一元 RPC 调用
    ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
    defer cancel()

    resp, err := client.ComputeScore(ctx, &pb.ScoreRequest{
        RequestId: "req-001",
        Factors: []*pb.FactorInput{
            {FactorName: "credit_score", Value: 720.0},
            {FactorName: "income_ratio", Value: 0.35},
        },
        TimeoutMs: 100,
    })
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("Score: %f, Confidence: %f", resp.Score, resp.Confidence)
}

4.5 gRPC 通信架构与延迟链路

下图展示了因子评分服务中 gRPC 的完整通信链路，从客户端发起请求到服务端处理并返回响应的全过程：

4.6 关键配置与性能调优参数

以下表格列出了 gRPC 服务端和客户端的关键配置参数，直接影响因子评分接口的延迟和吞吐：

4.7 本章小结

通过本章的学习，你已经掌握了：

• 使用 Protobuf 定义因子评分服务的消息结构和 RPC 接口。
• 基于 Go 语言快速实现 gRPC 服务端，包括一元 RPC 和服务端流式 RPC。
• 编写 gRPC 客户端，配置连接参数和超时控制。
• 理解 gRPC 通信架构中的延迟组成和关键调优参数。