1.简略一元RPC方式

首先写Proto文件，定义函数名和参数

syntax = "proto3";

package helloWorld;

option go_package = "./proto";

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

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

本Proto文件首先声明了使用proto3语法，定义了Greeter的RPC服务，其中RPC的方法为SayHello，入参为消息体HelloRequest，出参为HelloReply，还定义了这两个消息体。

Server部分

var port string

func init() {
	flag.StringVar(&port, "port", "8080", "port to listen on")
	flag.Parse()
}

type server struct {
	pb.UnimplementedGreeterServer
}

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

func main() {
	//生成一个grpc服务器
	s := grpc.NewServer()
	//注入实例
	pb.RegisterGreeterServer(s, &server{})

	lis, _ := net.Listen("tcp", ":"+port)
	err := s.Serve(lis)
	if err != nil {
		panic(err)
	}
}

创建了grpc Server端的抽象对象
然后将server（包含服务端接口）注入到s中
创建Listen监听TCP
s.Serve()开启服务

Client部分

var port string

func init() {
	flag.StringVar(&port, "port", "8080", "port to listen on")
	flag.Parse()
}

func SayHello(client pb.GreeterClient) error {
	resq, _ := client.SayHello(context.TODO(), &pb.HelloRequest{Name: "world"})
	fmt.Println(resq.Message)
	return nil
}

func main() {
	//创建与服务端的连接句柄
	conn, _ := grpc.Dial("127.0.0.1:8080", grpc.WithTransportCredentials(insecure.NewCredentials()))
	defer conn.Close()
	//创建客户端对象
	client := pb.NewGreeterClient(conn)
	//发出请求
	_ = SayHello(client)
}

创建与服务端的连接句柄
创建客户端对象
发出请求

这样一元RPC就完成啦，分别配置好server（创建服务器，注入接口，启动监听开启服务器），client（连接句柄，创建客户端对象，发出请求）

2.流式RPC方式

由于一元rpc可能会出现数据包过大造成瞬时压力，需要等待所有数据报接受成功才响应的问题，出现流式rpc

流式RPC使用stream关键字，分为客户端流式和服务端流式，还有双向流式

直接说双向流式

首先写Proto文件，定义函数名和参数

rpc SayRoute (stream HelloRequest) returns (stream HelloReply) {}

Server部分

func (s *server) SayRoute(stream pb.Greeter_SayRouteServer) error {
	n := 0
	for {
		_ = stream.Send(&pb.HelloReply{Message: "hi Route"})
		r, err := stream.Recv()
		if err == io.EOF {
			return nil
		}
		if err != nil {
			return err
		}
		n++
		println(r.Name, n)
	}
}

Client部分

func SayRoute(client pb.GreeterClient, r *pb.HelloRequest) error {
	stream, _ := client.SayRoute(context.Background())
	for i := 0; i < 10; i++ {
		_ = stream.Send(r)

		fmt.Println("1")
		resp, err := stream.Recv()

		if err == io.EOF {
			break
		}
		if err != nil {
			return err
		}
		fmt.Println(resp.Message)
	}
	return nil
}

stream.Send()和stream.Recv()分别是发送和接受数据，这里的消息体是HelloRequest和HelloReply。 stream.Send()和stream.Recv()是阻塞的，所以需要在另一个goroutine中执行

服务端流式类似，服务器使用stream.Send()发送数据，客户端使用stream.Recv()接受数据

客户端流式，客户端不断使用stream.Send()最后使用stream.CloseAndRecv(),服务器使用Recv()和SendAndRecv()

gRPC暂时先写到这啦，现在对rpc没有什么需求，大致了解一下

了解RPC

1.简略一元RPC方式

首先写Proto文件，定义函数名和参数

Server部分

Client部分

2.流式RPC方式

首先写Proto文件，定义函数名和参数

Server部分

Client部分