写个grpc代码

这是一个简单的 gRPC 代码示例，它演示了如何创建一个服务和客户端，以及如何在它们之间传递消息。

首先，我们需要定义一个 protobuf 文件来描述我们的服务和消息。在这个例子中，我们将定义一个简单的算术服务，它可以对两个数字执行加法和乘法运算：

syntax = "proto3";

package calculator;

service Calculator {
  rpc Add(AddRequest) returns (AddResponse) {}
  rpc Multiply(MultiplyRequest) returns (MultiplyResponse) {}
}

message AddRequest {
  int32 a = 1;
  int32 b = 2;
}

message AddResponse {
  int32 result = 1;
}

message MultiplyRequest {
  int32 a = 1;
  int32 b = 2;
}

message MultiplyResponse {
  int32 result = 1;
}

接下来，我们需要使用 protoc 编译器将 protobuf 文件编译成相应的代码。在这个例子中，我们将生成两个文件：calculator.pb.go 和 calculator_grpc.pb.go。前者包含 protobuf 消息类型的定义，后者包含 gRPC 服务的定义。

protoc calculator.proto --go_out=plugins=grpc:.

现在我们可以开始编写我们的服务代码了。在这个例子中，我们将创建一个名为 CalculatorService 的服务，它实现了我们在 protobuf 文件中定义的两个方法：Add 和 Multiply。

package main

import (
	"context"
	"log"
	"net"

	"google.golang.org/grpc"

	pb "path/to/calculator" // 导入编译生成的 protobuf 代码
)

type CalculatorService struct{}

func (s *CalculatorService) Add(ctx context.Context, req *pb.AddRequest) (*pb.AddResponse, error) {
	log.Printf("Add request received: %v", req)
	result := req.A + req.B
	return &pb.AddResponse{Result: result}, nil
}

func (s *CalculatorService) Multiply(ctx context.Context, req *pb.MultiplyRequest) (*pb.MultiplyResponse, error) {
	log.Printf("Multiply request received: %v", req)
	result := req.A * req.B
	return &pb.MultiplyResponse{Result: result}, nil
}

func main() {
	lis, err := net.Listen("tcp", ":8080")
	if err != nil {
		log.Fatalf("Failed to listen: %v", err)
	}

	grpcServer := grpc.NewServer()
	pb.RegisterCalculatorServer(grpcServer, &CalculatorService{})

	log.Println("Starting gRPC server...")
	if err := grpcServer.Serve(lis); err != nil {
		log.Fatalf("Failed to serve: %v", err)
	}
}

在我们的服务代码中，我们首先定义了一个名为 CalculatorService 的结构体，它实现了我们在 protobuf 文件中定义的两个方法：Add 和 Multiply。这些方法接收一个 context 对象和一个与请求消息对应的请求对象，并返回一个与响应消息对应的响应对象和一个错误（如果有的话）。

接下来，我们在主函数中启动了 gRPC 服务器。我们首先创建了一个网络监听器，然后创建了一个新的 gRPC 服务器，最后将我们的服务对象注册到服务器中。最后，我们调用 grpcServer.Serve(lis) 来启动服务器并开始监听传入的连接请求。

现在我们已经完成了服务端的代码，我们可以编写客户端代码来调用我们的服务。在这个例子中，我们将创建一个名为 CalculatorClient 的客户端，它将通过 gRPC 协议与我们的服务进行通信。

package main

import (
	"context"
	"log"

	"google.golang.org/grpc"

	pb "path/to/calculator" // 导入编译生成的 protobuf 代码
)

func main() {
	conn, err := grpc.Dial("localhost:8080", grpc.WithInsecure())
	if err != nil {
		log.Fatalf("Failed to connect: %v", err)
	}
	defer conn.Close()

	client := pb.NewCalculatorClient(conn)

	// 调用 Add 方法
	addReq := &pb.AddRequest{A: 2, B: 3}
	addRes, err := client.Add(context.Background(), addReq)
	if err != nil {
		log.Fatalf("Add failed: %v", err)
	}
	log.Printf("Add result: %d", addRes.Result)

	// 调用 Multiply 方法
	multiplyReq := &pb.MultiplyRequest{A: 2, B: 3}
	multiplyRes, err := client.Multiply(context.Background(), multiplyReq)
	if err != nil {
		log.Fatalf("Multiply failed: %v", err)
	}
	log.Printf("Multiply result: %d", multiplyRes.Result)
}

在我们的客户端代码中，我们首先创建了一个到我们的 gRPC 服务器的连接。我们创建了一个新的 CalculatorClient 客户端对象，它将用于调用我们的服务方法。

然后，我们调用了 Add 和 Multiply 方法，这些方法接收一个 context 对象和一个与请求消息对应的请求对象，并返回一个与响应消息对应的响应对象和一个错误（如果有的话）。我们在日志中输出了每个方法的结果。

现在我们已经编写了一个完整的 gRPC 代码示例，它演示了如何创建一个服务和客户端，并在它们之间传递消息。