• 简单模式（Simple RPC），客户端发起请求并等待服务端响应；
  • 服务端流式 RPC（Server-side streaming RPC），客户端发起一个请求到服务端，服务端返回一段连续的数据流响应；
  • 客户端流式 RPC（Client-side streaming RPC），与服务端流式相反，客户端流式是客户端不断地向服务端发送数据流，最后由服务端返回一个响应；
  • 双向流式 RPC（Bidirectional streaming RPC），客户端和服务端可同时向对方发送数据流，同时也可以接收数据；

一：简单模式

新建并编译 proto 文件

新建文件 simple.proto

syntax = "proto3";

package proto;
option go_package = "/pb";

// 定义发送请求信息
message SimpleRequest{
  // 参数类型 参数名称 标识号
  string data = 1;
}

// 定义响应信息
message SimpleResponse{
  int32 code = 1;
  string value = 2;
}

// 定义我们的服务(可以定义多个服务，每个服务可以定义多个接口)
service Simple{
  rpc GetSimpleInfo(SimpleRequest) returns (SimpleResponse){};
}

进入项目的目录，使用如下命令编译文件（.proto文件放在proto文件夹）

protoc --go_out=plugins=grpc:. ./proto/simple.proto

执行完成之后会在项目目录生成pb文件下，文件夹内有 simple.pb.go 文件

创建 server 端

package main

import (
	"context"
	pb "gRPCModel/pb"
	"google.golang.org/grpc"
	"log"
	"net"
)

const (
	Address string = ":8000"
	Network string = "tcp"
)

type SimpleService struct {
}

func (s *SimpleService) GetSimpleInfo(ctx context.Context, req *pb.SimpleRequest) (*pb.SimpleResponse, error) {
	data := req.Data
	log.Println("get form client:", data)
	resp := &pb.SimpleResponse{
		Code:  200,
		Value: "grpc",
	}
	return resp, nil
}

func main() {
	// 1.监听端口
	listener, err := net.Listen(Network, Address)
	if err != nil {
		log.Fatalf("net.listen err: %v", err)
	}

	log.Println(Address, " net listening...")

	// 2.实例化gRPC服务端
	grpcServer := grpc.NewServer()

	// 3.注册我们实现的服务 SimpleService
	pb.RegisterSimpleServer(grpcServer, &SimpleService{})

	// 4.启动gRPC服务端
	err = grpcServer.Serve(listener)
	if err != nil {
		log.Fatalf("grpc server err: %v",err)
	}
}

创建 client 端

package main

import (
 "context"
 pb "go-grpc-example/1-simple_rpc/proto"
 "google.golang.org/grpc"
 "log"
)

const (
 Address string = ":8000"
)

func main() {
 // 1.创建于gRPC服务端的连接
 conn, err := grpc.Dial(Address, grpc.WithInsecure())
 if err != nil {
  log.Fatalf("dial conn err: %v", err)
 }
 defer conn.Close()

 // 2.创建grpc客户端
 client := pb.NewSimpleClient(conn)

 // 3.调用服务端提供的服务
 req := pb.SimpleRequest{
  Data: "Hello,Server",
 }
 resp, err := client.GetSimpleInfo(context.Background(), &req)
 if err != nil {
  log.Fatalf("resp err: %v", err)
 }
 log.Printf("get from server,code: %v,value: %v", resp.Code, resp.Value)

}

运行客户端：

go run client.go

输出：
get from server,code: 200,value: grpc

成功调用了服务端提供的方法并返回数据。