Grpc之流模式

一 流模式简介

RPC是远程函数调用，因此每次调用的函数参数和返回值不能太大，否则将严重影响每次调用的响应时间。因此传统的RPC方法调用对于上传和下载较大数据量场景并不适合。同时传统RPC模式也不适用于对时间不确定的订阅和发布模式。为此，gRPC框架针对服务器端和客户端分别提供了流特性。

//hello.proto

syntax = "proto3";
option go_package = "./;proto";

service StreamService{
   // 关键字stream指定启用流特性，参数部分是接收客户端参数的流，返回值是返回给客户端的流。
  //重新生成代码可以看到接口中新增加的Channel方法的定义
  rpc GetStream(StreamRequestData) returns (stream StreamResponsetData){}//服务端流模式
  rpc PostStream(stream StreamRequestData) returns (StreamResponsetData){}//客户端流模式
  rpc AllStream(stream StreamRequestData) returns (stream StreamResponsetData){}//流模式
}

message StreamRequestData{
  string data = 1;
}
message StreamResponsetData{
  string msg = 1;
}
// protoc -I . --go_out=. hello.proto --go-grpc_out=. hello.proto

//server.go
package main

import (
	"fmt"
	"google.golang.org/grpc"
	"net"
	"testgrpc/grpc-ch/proto"
	"time"
)

type Server struct{
	proto.UnimplementedStreamServiceServer
}

//GetStream 服务端流模式:服务端不断的给客户端发数据
func (server  *Server ) GetStream(request *proto.StreamRequestData,s proto.StreamService_GetStreamServer)  (err error) {
	response := &proto.StreamResponsetData{}
	if request.Data == "time" {

		for {
			response.Msg = fmt.Sprintf("当前时间为: %v",time.Now().Unix())
			err = s.Send(response)
			time.Sleep(time.Second)
		}

	}
	return
}


// PostStream 客户端流模式: 客户端不断的给服务端发数据，服务端接收
func (server *Server) PostStream(s proto.StreamService_PostStreamServer) error {
	for {
		//可以发现服务端和客户端的流辅助接口均定义了Send和Recv方法用于流数据的双向通信。
		//服务端在循环中接收客户端发来的数据，如果遇到io.EOF表示客户端流被关闭，
		//如果函数退出表示服务端流关闭。生成返回的数据通过流发送给客户端，双向流数据的发送和接收都是完全独立的行为。
		//需要注意的是，发送和接收的操作并不需要一一对应，用户可以根据真实场景进行组织代码。
		requestData,err := s.Recv()
		if err != nil {
			panic(err)
		}
		fmt.Println(requestData)
	}
	return nil
}


func (server *Server) AllStream(s proto.StreamService_AllStreamServer) error {
	return nil
}

func main() {
	server := grpc.NewServer()
	proto.RegisterStreamServiceServer(server, new(Server))
	lis, err := net.Listen("tcp", "0.0.0.0:9999")
	if err != nil {
		panic("fail to listen port:" + err.Error())
	}
	fmt.Println("启动grpc服务成功:0.0.0.0:9999")
	err = server.Serve(lis)
	if err != nil {
		panic("fail to start grpc:" + err.Error())
	}
}

//client.go
package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	"testgrpc/grpc-ch/proto"
	"time"
)

type Client struct {
	Url string
}

func (c *Client) dial()  *grpc.ClientConn{

	conn ,err := grpc.Dial(c.Url,grpc.WithInsecure())
	if err != nil {
		panic(err)
	}
	return conn

}

func (c *Client) GetStream() {
	conn:= c.dial()
	defer conn.Close()

	client := proto.NewStreamServiceClient(conn)
	stream,err := client.GetStream(context.Background(),&proto.StreamRequestData{
		Data: "time",
	})
	if err != nil {
		return
	}

	for {
		data , _ := stream.Recv()
		fmt.Println(data)

	}

}

func (c *Client) PostStream()  {
	conn := c.dial()
	defer conn.Close()

	client := proto.NewStreamServiceClient(conn)
	stream ,err := client.PostStream(context.Background())
	if err != nil {
		return
	}

	request := &proto.StreamRequestData{}
	for {
		request.Data = fmt.Sprintf("当前时间: %v",time.Now().Unix())
		stream.Send(request)
		time.Sleep(time.Second)
	}
}


func main() {
	client := Client{"127.0.0.1:9999"}
	client.GetStream()
	//client.PostStream()
}

二 发布与订阅模式

我们基于Go内置的RPC库实现了一个简化版的Watch方法。基于Watch的思路虽然也可以构造发布和订阅系统，但是因为RPC缺乏流机制导致每次只能返回一个结果。在发布和订阅模式中，由调用者主动发起的发布行为类似一个普通函数调用，而被动的订阅者则类似gRPC客户端单向流中的接收者。现在我们可以尝试基于gRPC的流特性构造一个发布和订阅系统。

发布订阅是一个常见的设计模式，开源社区中已经存在很多该模式的实现。其中docker项目中提供了一个pubsub的极简实现，下面是基于pubsub包实现的本地发布订阅代码：

//service.proto

syntax = "proto3";
option go_package = "./;proto";

message String{
  string  value = 1 ;
}
//其中pubsub.NewPublisher构造一个发布对象，p.SubscribeTopic()可以通过函数筛选感兴趣的主题进行订阅。
//现在尝试基于gRPC和pubsub包，提供一个跨网络的发布和订阅系统。首先通过Protobuf定义一个发布订阅服务接口：
service PubsubService {
  //其中Publish是普通的RPC方法，Subscribe则是一个单向的流服务。然后gRPC插件会为服务端和客户端生成对应的接口：
  rpc Publish (String) returns (String);
  //因为Subscribe是服务端的单向流，因此生成的HelloService_SubscribeServer接口中只有Send方法。
  //
  //然后就可以实现发布和订阅服务了：
  rpc Subscribe (String) returns (stream String);
}

//server.go
package main

import (
	"fmt"
	"github.com/moby/moby/pkg/pubsub"
	"google.golang.org/grpc"
	"net"
	"strings"
	"time"
	"context"

	. "testgrpc/grpc-watch/proto"
)

type PubsubService struct {
	pub *pubsub.Publisher
	UnimplementedPubsubServiceServer
}

func NewPubsubService() *PubsubService {
	return &PubsubService{
		pub: pubsub.NewPublisher(100*time.Millisecond, 10),
	}
}

func (p *PubsubService) Publish(
	ctx context.Context, arg *String,
) (*String, error) {
	p.pub.Publish(arg.GetValue())
	return &String{}, nil
}

func (p *PubsubService) Subscribe(
	arg *String, stream PubsubService_SubscribeServer,
) error {
	ch := p.pub.SubscribeTopic(func(v interface{}) bool {
		if key, ok := v.(string); ok {
			if strings.HasPrefix(key,arg.GetValue()) {
				return true
			}
		}
		return false
	})

	for v := range ch {
		if err := stream.Send(&String{Value: v.(string)}); err != nil {
			return err
		}
	}

	return nil
}


func main() {

	p := pubsub.NewPublisher(100*time.Millisecond, 10)

	golang := p.SubscribeTopic(func(v interface{}) bool {
		if key, ok := v.(string); ok {
			if strings.HasPrefix(key, "golang:") {
				return true
			}
		}
		return false
	})
	docker := p.SubscribeTopic(func(v interface{}) bool {
		if key, ok := v.(string); ok {
			if strings.HasPrefix(key, "docker:") {
				return true
			}
		}
		return false
	})

	go p.Publish("hi")
	go p.Publish("golang: https://golang.org")
	go p.Publish("docker: https://www.docker.com/")
	time.Sleep(1)

	go func() {
		fmt.Println("golang topic:", <-golang)
	}()
	go func() {
		fmt.Println("docker topic:", <-docker)
	}()

	server := grpc.NewServer()

	RegisterPubsubServiceServer(server,NewPubsubService())
	lis, err := net.Listen("tcp", "0.0.0.0:1234")
	if err != nil {
		panic("fail to listen port:" + err.Error())
	}
	fmt.Println("启动grpc服务成功:0.0.0.0:9999")
	err = server.Serve(lis)
	if err != nil {
		panic("fail to start grpc:" + err.Error())
	}


	<-make(chan bool)

}

//client1.go   生产
package main

import (
	"google.golang.org/grpc"

	"log"

	"context"

	. "testgrpc/grpc-watch/proto"
)

func main() {
	conn, err := grpc.Dial("localhost:1234", grpc.WithInsecure())
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close()

	client := NewPubsubServiceClient(conn)

	_, err = client.Publish(
		context.Background(), &String{Value: "golang: hello Go"},
	)
	if err != nil {
		log.Fatal(err)
	}
	_, err = client.Publish(
		context.Background(), &String{Value: "docker: hello Docker"},
	)
	if err != nil {
		log.Fatal(err)
	}

	_, err = client.Publish(
		context.Background(), &String{Value: "docker: nizhencai Docker"},
	)
	if err != nil {
		log.Fatal(err)
	}
}

//client2.go 消费
package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	"io"
	"log"
	"time"

	. "testgrpc/grpc-watch/proto"
)

func main() {
	conn, err := grpc.Dial("localhost:1234", grpc.WithInsecure())
	if err != nil {
		log.Fatal(err)
	}
	defer conn.Close()

	client := NewPubsubServiceClient(conn)
	stream1, err := client.Subscribe(
		context.Background(), &String{Value: "golang:"},
	)
	if err != nil {
		log.Fatal(err)
	}
	stream2, err := client.Subscribe(
		context.Background(), &String{Value: "docker:"},
	)
	if err != nil {
		log.Fatal(err)
	}
	go func() {
		for {
			reply, err := stream1.Recv()
			if err != nil {
				if err == io.EOF {
					break
				}
				log.Fatal(err)
			}

			fmt.Println(reply.GetValue())
		}
	}()
	go func() {
		for {
			reply, err := stream2.Recv()
			if err != nil {
				if err == io.EOF {
					break
				}
				log.Fatal(err)
			}

			fmt.Println(reply.GetValue())
		}
	}()
	time.Sleep(time.Hour)
}