Go RPC学习

RPC（remote procedure call）远程过程调用

gRPC

谷歌的rpc框架，它的idl是 Protocol Buffers

idl（interface definition language 接口描述语言）

四种服务类型

1. Unary
2. client-side streaming
3. server-side streaming
4. bidirectional-streaming

ProtoBuf

​​​​​​Protocol Buffers  |  Google Developers

protobuf详解 - 知乎 (zhihu.com)

/*
描述服务
1、GetFeature：输入一个Point，返回这个点的Fearture
2、ListFearchs，（输入为一个Rectangle，输出流这个区域内所有的Fearture）
3、RecordRoute，(输入流位每个时间点的Point，返回一个RouteSammary）
4、Recommend，（输入流RecommendationRequest，输出流Fearture)
 */

syntax ="proto3";
//option go_package
package route;

message Point{
  int32 latitude = 1;
  int32 longitude = 2;
}

message Rectangle{
  Point lo = 1;
  Point hi = 2;
}

message Fearture{
  string name = 1;
  Point location = 2;
}

message RouteSammary{
  int32 pointCount =1;
  int32 distance =2;
  int32 elapsedTime = 3;
}

enum RecommendationMode{
  GetFarthest = 0;
  GetNearest = 1;
}

message RecommendationRequest{
  RecommendationMode mode =1;
  Point point =2;
}

service RouteService{
  //unary
  rpc GetFeature(Point) returns (Fearture){}
  //server side streaming
  rpc ListFeature(Rectangle) returns (stream Fearture){}

  //client side streaming
  rpc RecordRoute(stream Point) returns (RouteSammary){}

  //bidirectional streaming
  rpc Recommend(stream RecommendationRequest) returns (stream Fearture){}
}

输入命令：

protoc --go_out=. --go_opt=paths=source_relative  --go-grpc_out=. --go-grpc_opt=paths=source_relative route.proto

go-out=. .代表当前文件

go-opt：记录一些我们想定义的选项

意思为：把输出文件存在相对于这个 . （route.proto）的位置，命令分为前后两部分，因为会生成两个文件。

---

调用

上面的proto文件运行了以后我们写一个客户端和一个服务端做测试

我把函数拆开来写，方便看一点

server.go

package main

import (
	"context"
	pb "github.com/HanFa/learn-go/grpc-example/route"
	"google.golang.org/grpc"
	"google.golang.org/protobuf/proto"
	"log"
	"net"
)

type routeGuidServer struct {
	dbFeartures []*pb.Fearture
	//之所以需要原因是protoc在解析 。proto，创建grpc.pb.go文件时，用UnimplementedXXX完成向前兼容，
	pb.UnimplementedRouteServiceServer
}


func newServer() *routeGuidServer {
	return &routeGuidServer{
		dbFeartures: []*pb.Fearture{
			{
				Name: "湘潭大学",
				Location: &pb.Point{
					Latitude:  12331221,
					Longitude: 23321233,
				},
			},
			{
				Name: "xx学院",
				Location: &pb.Point{
					Latitude:  12331323,
					Longitude: 23323213,
				},
			},
		},
	}
}

func main() {
	listen, err := net.Listen("tcp", "localhost:8080")
	if err != nil {
		log.Fatalf("cant create socket: %v", err)
	}

	grpcServer := grpc.NewServer()
	pb.RegisterRouteServiceServer(grpcServer, newServer())
	log.Fatalln(grpcServer.Serve(listen))
}

GetFearture()

func (r *routeGuidServer) GetFeature(ctx context.Context, point *pb.Point) (*pb.Fearture, error) {
	for _, fearture := range r.dbFeartures {
		if proto.Equal(fearture.Location, point) {
			return fearture, nil
		}

	}
	return nil, nil
}

ListFearture()

func (r *routeGuidServer) ListFeature(rectangle *pb.Rectangle, serverStream pb.RouteService_ListFeatureServer) error {
	for _, fearture := range r.dbFeartures {
		if inRange(fearture.Location, rectangle) {
			if err := serverStream.Send(fearture); err != nil {
				return err
			}
		}
	}
	return nil
}

RecordRoute()

func (r *routeGuidServer) RecordRoute(stream pb.RouteService_RecordRouteServer) error {
	startTime := time.Now()
	var pointCount, distance int32
	var prePoint *pb.Point

	for {
		point, err := stream.Recv()
		if err == io.EOF {
			endTime := time.Now()
			return stream.SendAndClose(&pb.RouteSammary{
				Distance:    distance,
				PointCount:  pointCount,
				ElapsedTime: int32(endTime.Sub(startTime).Seconds())},
			)
		}

		if err != nil {
			return err
		}

		pointCount++
		if prePoint != nil {
			distance += 100
		}
		prePoint = point
	}

	return nil
}

Recommend()

func (r *routeGuidServer) Recommend(stream pb.RouteService_RecommendServer) error {
	for {
		_, err := stream.Recv()
		if err == io.EOF {
			return nil
		}
		if err != nil {
			return err
		}

		reco := &pb.Fearture{
			Name: "recommend",
			Location: &pb.Point{
				Latitude:  int32(rand.Intn(100000)),
				Longitude: int32(rand.Intn(100000)),
			},
		}
		return stream.Send(reco)
	}
	return nil
}

---

client.go

func main() {
	conn, err := grpc.Dial("localhost:8080", grpc.WithInsecure(), grpc.WithBlock())
	if err != nil {
		log.Fatalf("create client error: %v", err)
	}
	defer conn.Close()
	client := pb.NewRouteServiceClient(conn)

	runFirst(client)    //第一个
    //runSecond(client) //第二个
    //runThird(client)  //第三个
    //runFourth(client) //第四个

}

测试运行的函数

runfirst()

func runFirst(clent pb.RouteServiceClient) {
	feature, err := clent.GetFeature(context.Background(), &pb.Point{
		Latitude:  12331221,
		Longitude: 23321233,
	})
	if err != nil {
		log.Fatalln(err)
	}
	fmt.Println(feature)
}

runSecond()

func runSecond(clent pb.RouteServiceClient) {
	serverStream, err := clent.ListFeature(context.Background(), &pb.Rectangle{
		Lo: &pb.Point{Latitude: 12331221, Longitude: 23321233},
		Hi: &pb.Point{Latitude: 12331323, Longitude: 23323213},
	})
	if err != nil {
		log.Fatalln(err)
	}

	for {
		feature, err := serverStream.Recv()
		if err == io.EOF {
			break
		}
		if err != nil {
			log.Fatalln(err)
		}
		fmt.Println(feature)
	}

	return
}

ruThird()

func runThird(client pb.RouteServiceClient) {
	points := []*pb.Point{
		{Latitude: 12331211, Longitude: 23321223},
		{Latitude: 11111111, Longitude: 22222222},
		{Latitude: 12321333, Longitude: 23312312},
	}
	clientStream, err := client.RecordRoute(context.Background())
	if err != nil {
		log.Fatalln(err)
	}

	for _, point := range points {
		if err := clientStream.Send(point); err != nil {
			log.Fatalln(err)
		}
		time.Sleep(time.Second)
	}

	recv, err := clientStream.CloseAndRecv()
	if err != nil {
		log.Fatalln(err)
	}
	fmt.Println(recv)
}

runFourth()

func runFourth(client pb.RouteServiceClient) {
	clientStream, err := client.Recommend(context.Background())
	if err != nil {
		log.Fatalln(err)
	}

	//一直从server拉取
	go func() {
		feature, err := clientStream.Recv()
		if err != nil {
			log.Fatalln(err)
		}
		fmt.Println("Recommended: ", feature)
	}()

	reader := bufio.NewReader(os.Stdin)

	for {
		request := pb.RecommendationRequest{Point: &pb.Point{}}
		var mode int32
		fmt.Println("Enter Recommendation Mode (o for nearest,1 for farthest)")
		readIntFromCommandLine(reader, &mode)
		fmt.Println("Enter Latitude: ")
		readIntFromCommandLine(reader, &request.Point.Latitude)
		fmt.Println("Enter Longitude: : ")
		readIntFromCommandLine(reader, &request.Point.Longitude)
		request.Mode = pb.RecommendationMode(mode)

		if err := clientStream.Send(&request); err != nil {
			log.Fatalln(err)
		}
		//防止可能的overlap
		time.Sleep(100 * time.Millisecond)
	}

}