之前我们通过Watch机制实现了简化版本的监视服务，这里我们基于这种机制实现一个发布订阅模式，但是因为RPC缺乏流机制导致每次只能返回一个结果，在发布订阅模式中，由调用者主动发起的发布行为类似于一个普通函数调用，而被动的订阅者则类似gRPC客户端单向流中的接收者。现在我们可以尝试基于gRPC的流特性构造一个发布订阅系统。
首先我们需要使用一个第三方模块：go get github.com/docker/docker, 下面我们写一个简单的订阅模式demo：
package main
import (
"fmt"
"github.com/docker/docker/pkg/pubsub"
"strings"
"time"
)
func main(){
p := pubsub.NewPublisher(100*time.Microsecond, 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("wang")
go p.Publish("golang: https://golang.org")
go p.Publish("docker: https://www.docker.com")
time.Sleep(time.Second*2)
go func() {
fmt.Println("golang topic:", <-golang)
}()
go func() {
fmt.Println("docker topic:",<-docker)
}()
time.Sleep(time.Second*3)
fmt.Println("end")
}
以上代码运行后，会通过我们的订阅过滤函数：p.SubscribeTopic过滤调我们不是订阅的信息，最终打印出相关的结果。
gRPC发布订阅实例
我们分别需要有一个proto文件定义服务端和客户端的接口实现，里面定义了传输数据类型和实现方法，紧接着我们需要一个服务端，它用来支撑起整个服务给所有的客户端访问，再然后我们需要两个客户端，一个发布一个订阅（先订阅）。
proto/publish.proto文件：
syntax="proto3";
package proto;
message StringPub{
string value =1;
}
service PubsubService {
// 发布是rpc的普通方法
rpc Publish (StringPub) returns (StringPub);
// 订阅则是一个单向的流服务，服务端返回的数据可能很大
rpc Subscribe (StringPub) returns (stream StringPub);
}
我们使用：protoc --go_out=plugins=grpc:. publish.proto 生成相应的go文件，重点分析：
// 客户端接受体
type pubsubServiceClient struct {
cc *grpc.ClientConn
}
// 客户端调用它生成接受体
func NewPubsubServiceClient(cc *grpc.ClientConn) PubsubServiceClient {
return &pubsubServiceClient{cc}
}
// 客户端的方法实现
func (c *pubsubServiceClient) Publish(ctx context.Context, in *StringPub, opts ...grpc.CallOption) (*StringPub, error) {
out := new(StringPub)
err := c.cc.Invoke(ctx, "/proto.PubsubService/Publish", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *pubsubServiceClient) Subscribe(ctx context.Context, in *StringPub, opts ...grpc.CallOption) (PubsubService_SubscribeClient, error) {
stream, err := c.cc.NewStream(ctx, &_PubsubService_serviceDesc.Streams[0], "/proto.PubsubService/Subscribe", opts...)
if err != nil {
return nil, err
}
x := &pubsubServiceSubscribeClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
// 返回用于发送接受的对象，类似socket
type PubsubService_SubscribeClient interface {
Recv() (*StringPub, error)
grpc.ClientStream
}
type pubsubServiceSubscribeClient struct {
grpc.ClientStream
}
...
func (x *pubsubServiceSubscribeClient) Recv() (*StringPub, error) {
m := new(StringPub)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
// PubsubServiceServer is the server API for PubsubService service.
type PubsubServiceServer interface {
// 发布是rpc的普通方法
Publish(context.Context, *StringPub) (*StringPub, error)
// 订阅则是一个单向的流服务，服务端返回的数据可能很大
Subscribe(*StringPub, PubsubService_SubscribeServer) error
}
func RegisterPubsubServiceServer(s *grpc.Server, srv PubsubServiceServer) {
s.RegisterService(&_PubsubService_serviceDesc, srv)
}
type PubsubService_SubscribeServer interface {
Send(*StringPub) error
grpc.ServerStream
}
接着我们可以实现一个发布的客户端：pub_service.go:
package main
import (
"context"
"gRPC_demo/proto"
"google.golang.org/grpc"
"log"
)
func main() {
conn, err := grpc.Dial("localhost:1234", grpc.WithInsecure())
if err != nil {
log.Fatal(err)
}
defer conn.Close()
client := proto.NewPubsubServiceClient(conn)
_, err = client.Publish(context.Background(), &proto.StringPub{Value: "golang: hello Wang"})
if err != nil {
log.Fatal(err)
}
_, err = client.Publish(context.Background(), &proto.StringPub{Value: "docker: hello Wang"})
if err != nil {
log.Fatal(err)
}
}
最后我们实现订阅客户端：sub_client.go:
package main
import (
"context"
"fmt"
"gRPC_demo/proto"
"google.golang.org/grpc"
"io"
"log"
)
func main() {
conn, err := grpc.Dial("localhost:1234", grpc.WithInsecure())
if err != nil {
log.Fatal(err)
}
defer conn.Close()
client := proto.NewPubsubServiceClient(conn)
stream, err := client.Subscribe(context.Background(),&proto.StringPub{Value:"golang: "})
if err != nil {
log.Fatal(err)
}
for {
reply, err := stream.Recv()
if err != nil {
if err == io.EOF{
break
}
log.Fatal(err)
}
fmt.Println(reply.GetValue())
}
}
到此发布订阅功能就基本实现了，依次启动服务端，订阅客户端，发布客户端就可以查看结果了。
手写发布订阅
分别由服务端、客户端代码，以及一个调用文件。（此实例是摘抄于：http://www.itkeyword.com/doc/602627406483745x914/golang-pubsub）感觉写的不错，所以摘抄。
服务端代码：service.go
package pubsub
import (
"errors"
"sync"
)
type Client struct {
Id int
Ip string
}
type Server struct {
Dict map[string]*Channel //map[Channel.Name]*Channel
sync.RWMutex
}
func NewServer() *Server {
s := &Server{}
s.Dict = make(map[string]*Channel) //所有channel
return s
}
//订阅
func (srv *Server) Subscribe(client *Client, channelName string) {
// 客户是否在Channel的客户列表中
srv.RLock()
ch, found := srv.Dict[channelName]
srv.RUnlock()
if !found {
ch = NewChannel(channelName)
ch.AddClient(client)
srv.Lock()
srv.Dict[channelName] = ch
srv.Unlock()
} else {
ch.AddClient(client)
}
}
//取消订阅
func (srv *Server) Unsubscribe(client *Client, channelName string) {
srv.RLock()
ch, found := srv.Dict[channelName]
srv.RUnlock()
if found {
if ch.DeleteClient(client) == 0 {
ch.Exit()
srv.Lock()
delete(srv.Dict, channelName)
srv.Unlock()
}
}
}
//发布消息
func (srv *Server) PublishMessage(channelName, message string) (bool, error) {
srv.RLock()
ch, found := srv.Dict[channelName]
if !found {
srv.RUnlock()
return false, errors.New("channelName不存在!")
}
srv.RUnlock()
ch.Notify(message)
ch.Wait()
return true, nil
}
客户端代码：client.go
import (
"fmt"
"sync"
"sync/atomic"
)
type Channel struct {
Name string
clients map[int]*Client
// exitChan chan int
sync.RWMutex
waitGroup WaitGroupWrapper
messageCount uint64
exitFlag int32
}
func NewChannel(channelName string) *Channel {
return &Channel{
Name: channelName,
// exitChan: make(chan int),
clients: make(map[int]*Client),
}
}
func (ch *Channel) AddClient(client *Client) bool {
ch.RLock()
_, found := ch.clients[client.Id]
ch.RUnlock()
ch.Lock()
if !found {
ch.clients[client.Id] = client
}
ch.Unlock()
return found
}
func (ch *Channel) DeleteClient(client *Client) int {
var ret int
ch.ReplyMsg(
fmt.Sprintf("从channel:%s 中删除client:%d ", ch.Name, client.Id))
ch.Lock()
delete(ch.clients, client.Id)
ch.Unlock()
ch.RLock()
ret = len(ch.clients)
ch.RUnlock()
return ret
}
func (ch *Channel) Notify(message string) bool {
ch.RLock()
defer ch.RUnlock()
for cid, _ := range ch.clients {
ch.ReplyMsg(
fmt.Sprintf("channel:%s client:%d message:%s", ch.Name, cid, message))
}
return true
}
func (ch *Channel) ReplyMsg(message string) {
ch.waitGroup.Wrap(func() { fmt.Println(message) })
}
func (ch *Channel) Wait() {
ch.waitGroup.Wait()
}
func (ch *Channel) Exiting() bool {
return atomic.LoadInt32(&ch.exitFlag) == 1
}
func (ch *Channel) Exit() {
if !atomic.CompareAndSwapInt32(&ch.exitFlag, 0, 1) {
return
}
//close(ch.exitChan)
ch.Wait()
}
func (ch *Channel) PutMessage(clientID int, message string) {
ch.RLock()
defer ch.RUnlock()
if ch.Exiting() {
return
}
//select {
// case <-t.exitChan:
// return
//}
fmt.Println(ch.Name, ":", message)
atomic.AddUint64(&ch.messageCount, 1)
return
}
最后是主函数文件：
package main
import (
. "pubsub"
)
func main(){
c1 := &Client{Id:100,Ip:"172.18.1.1"}
c3:= &Client{Id:300,Ip:"172.18.1.3"}
srv := NewServer()
srv.Subscribe(c1,"Topic")
srv.Subscribe(c3,"Topic")
srv.PublishMessage("Topic","测试信息1")
srv.Unsubscribe(c3,"Topic")
srv.PublishMessage("Topic","测试信息2222")
srv.Subscribe(c1,"Topic2")
srv.Subscribe(c3,"Topic2")
srv.PublishMessage("Topic2"," Topic2的测试信息")
}