Go + gRPC + HTTP/3：解锁下一代高性能通信

1
2
3
4
5
6
7
8
9
10
11
12
type Conn struct {
    conn   quic.Connection
    stream quic.Stream
}

func NewConn(conn quic.Connection) (net.Conn, error) {
    stream, err := conn.OpenStreamSync(context.Background())
    if err != nil {
       return nil, err
    }
    return &Conn{conn, stream}, nil
}

1
2
3
4
5
6
7
8
9
10
11
12
13
func NewCredentials(config *tls.Config) credentials.TransportCredentials {
    return &Credentials{
       creds:  credentials.NewTLS(config),
       config: config,
    }
}

func (pt *Credentials) ClientHandshake(ctx context.Context, authority string, conn net.Conn) (net.Conn, credentials.AuthInfo, error) {
    if c, ok := conn.(*Conn); ok {
       return conn, NewInfo(c), nil
    }
    return pt.creds.ClientHandshake(ctx, authority, conn)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
func EasyGrpcQuicServer(addr, certFile, keyFile string) error {
    // 加载证书和 CA
    certificate, _ := tls.LoadX509KeyPair(certFile, keyFile)
    certPool := x509.NewCertPool()
    ca, _ := ioutil.ReadFile("./certs/ca.crt")
    certPool.AppendCertsFromPEM(ca)

    // 配置 TLS
    tlsConf := &tls.Config{
       Certificates: []tls.Certificate{certificate},
       ClientCAs:    certPool,
       NextProtos:   []string{"h3"},
    }

    // 创建 QUIC 监听器
    ql, _ := quic.ListenAddr(addr, tlsConf, nil)
    listener := qnet.Listen(*ql)

    // 启动 gRPC 服务
    s := grpc.NewServer()
    pb.RegisterPartSearchServiceServer(s, &EsPartServer{})
    return s.Serve(listener)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
func NewQuicDialer(conf *tls.Config) func(context.Context, string) (net.Conn, error) {
    return func(ctx context.Context, addr string) (net.Conn, error) {
       host, _, _ := net.SplitHostPort(addr)
       tlsConf := conf.Clone()
       tlsConf.NextProtos = []string{"h3"}
       tlsConf.ServerName = host

       conn, err := quic.DialAddr(ctx, addr, tlsConf, nil)
       if err != nil {
          return nil, err
       }

       return NewConn(conn)
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
func EasyGrpcQuicClient(addr string) (pb.PartSearchServiceClient, *grpc.ClientConn, error) {
    // 加载客户端证书
    cert, _ := tls.LoadX509KeyPair("certs/client.crt", "certs/client.key")
    caCert, _ := ioutil.ReadFile("certs/ca.crt")
    certPool := x509.NewCertPool()
    certPool.AppendCertsFromPEM(caCert)

    tlsConf := &tls.Config{
       Certificates: []tls.Certificate{cert},
       RootCAs:      certPool,
    }

    // 创建 QUIC 拨号器
    quicDialer := NewQuicDialer(tlsConf)

    // 创建 gRPC 连接
    conn, err := grpc.Dial(addr,
       grpc.WithContextDialer(quicDialer),
       grpc.WithTransportCredentials(grpcquic.NewCredentials(tlsConf)),
    )

    return pb.NewPartSearchServiceClient(conn), conn, err
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
func main() {
    client, conn, err := EasyGrpcQuicClient("localhost:443")
    if err != nil {
       log.Fatalf("Failed to connect: %v", err)
    }
    defer conn.Close()

    response, err := client.Analyze(context.Background(), &messages.PartSearchParam{
       KeyWord: "STM32F407",
    })
    if err != nil {
       log.Fatalf("Failed to call Analyze: %v", err)
    }

    fmt.Printf("分析结果: %v\n", response.Tokens)
}

1
2
3
4
5
6
7
8
service SearchService {
    rpc Analyze (SearchParam) returns (Tokens) {
       option (google.api.http) = {
          post: "/v1/Analyze"
          body: "*"
       };
    }
}

1
2
3
4
5
6
7
func (s *EsServer) Analyze(ctx context.Context, req *messages.SearchParam) (*messages.Tokens, error) {
    tokens, err := parts.Analyze("easybom_all", req.KeyWord)
    if err != nil {
       return nil, err
    }
    return dto.MapperToPdToken(tokens), nil
}