网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
func (p *PubsubService) Publish(ctx context.Context, arg *proto.String) (*proto.String, error) {
p.pub.Publish(arg.GetValue())
return &proto.String{}, nil
}
func (p *PubsubService) SubscribeTopic(arg *proto.String, stream proto.PubsubService_SubscribeTopicServer) 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(&proto.String{Value: v.(string)}); nil != err {
return err
}
}
return nil
}
func (p *PubsubService) Subscribe(arg *proto.String, stream proto.PubsubService_SubscribeServer) error {
ch := p.pub.Subscribe()
for v := range ch {
if err := stream.Send(&proto.String{Value: v.(string)}); nil != err {
return err
}
}
return nil
}
func NewPubsubService() *PubsubService {
return &PubsubService{pub: pubsub.NewPublisher(100*time.Millisecond, 10)}
}
func main() {
lis, err := net.Listen(“tcp”, “:50051”)
if err != nil {
log.Fatalf(“failed to listen: %v”, err)
}
// 简单调用
server := grpc.NewServer()
// 注册 grpcurl 所需的 reflection 服务
reflection.Register(server)
// 注册业务服务
proto.RegisterPubsubServiceServer(server, NewPubsubService())
fmt.Println(“grpc server start …”)
if err := server.Serve(lis); err != nil {
log.Fatalf(“failed to serve: %v”, err)
}
}
对比之前的发布订阅程序,其实这里是将 *pubsub.Publisher
作为了 gRPC 的结构体 PubsubService
的一个成员。
然后还是按照 gRPC 的开发流程,实现结构体对应的三个方法。
最后,在注册服务时,将 NewPubsubService()
服务注入,实现本地发布订阅功能。
订阅客户端
package main
import (
“client/proto”
“context”
“fmt”
“io”
“log”
“google.golang.org/grpc”
)
func main() {
conn, err := grpc.Dial(“localhost:50051”, grpc.WithInsecure())
if err != nil {
log.Fatal(err)
}
defer conn.Close()
client := proto.NewPubsubServiceClient(conn)
stream, err := client.Subscribe(
context.Background(), &proto.String{Value: “golang:”},
)
if nil != err {
log.Fatal(err)
}
go func() {
for {
reply, err := stream.Recv()
if nil != err {
if io.EOF == err {
break
}
log.Fatal(err)
}
fmt.Println("sub1: ", reply.GetValue())
}
}()
streamTopic, err := client.SubscribeTopic(
context.Background(), &proto.String{Value: “golang:”},
)
if nil != err {
log.Fatal(err)
}
go func() {
for {
reply, err := streamTopic.Recv()
if nil != err {
if io.EOF == err {
break
}
log.Fatal(err)
}
fmt.Println("subTopic: ", reply.GetValue())
}
}()
<-make(chan bool)
}
新建一个 NewPubsubServiceClient
对象,然后分别实现 client.Subscribe
和 client.SubscribeTopic
方法,再通过 goroutine 不停接收消息。
发布客户端
package main
import (
“client/proto”
“context”
“log”
“google.golang.org/grpc”
)
func main() {
conn, err := grpc.Dial(“localhost:50051”, grpc.WithInsecure())
if err != nil {
log.Fatal(err)
}
defer conn.Close()
client := proto.NewPubsubServiceClient(conn)
_, err = client.Publish(
context.Background(), &proto.String{Value: “golang: hello Go”},
)
if err != nil {
log.Fatal(err)
}
_, err = client.Publish(
context.Background(), &proto.String{Value: “docker: hello Docker”},
)
if nil != err {
log.Fatal(err)
}
}
新建一个 NewPubsubServiceClient
对象,然后通过 client.Publish
方法发布消息。
当代码全部写好之后,我们开三个终端来测试一下:
终端1 上启动服务端:
go run main.go
终端2 上启动订阅客户端:
go run sub_client.go
终端3 上执行发布客户端:
go run pub_client.go
这样,在 终端2 上就有对应的输出了:
subTopic: golang: hello Go
sub1: golang: hello Go
sub1: docker: hello Docker
也可以再多开几个订阅终端,那么每一个订阅终端上都会有相同的内容输出。
源码地址: GitHub
REST 接口
gRPC 一般用于集群内部通信,如果需要对外提供服务,大部分都是通过 REST 接口的方式。开源项目 grpc-gateway 提供了将 gRPC 服务转换成 REST 服务的能力,通过这种方式,就可以直接访问 gRPC API 了。
但我觉得,实际上这么用的应该还是比较少的。如果提供 REST 接口的话,直接写一个 HTTP 服务会方便很多。
proto 文件
第一步还是创建一个 proto 文件:
syntax = “proto3”;
package proto;
import “google/api/annotations.proto”;
message StringMessage {
string value = 1;
}
service RestService {
rpc Get(StringMessage) returns (StringMessage) {
option (google.api.http) = {
get: “/get/{value}”
};
}
rpc Post(StringMessage) returns (StringMessage) {
option (google.api.http) = {
post: “/post”
body: “*”
};
}
}
定义一个 REST 服务 RestService
,分别实现 GET
和 POST
方法。
安装插件:
go get -u github.com/grpc-ecosystem/grpc-gateway/protoc-gen-grpc-gateway
生成对应代码:
protoc -I/usr/local/include -I. \
-I$GOPATH/pkg/mod \
-I$GOPATH/pkg/mod/github.com/grpc-ecosystem/grpc-gateway@v1.16.0/third_party/googleapis \
–grpc-gateway_out=. --go_out=plugins=grpc:.\
–swagger_out=. \
helloworld.proto
--grpc-gateway_out
参数可生成对应的 gw 文件,--swagger_out
参数可生成对应的 API 文档。
在我这里生成的两个文件如下:
helloworld.pb.gw.go
helloworld.swagger.json
REST 服务
package main
import (
“context”
“log”
“net/http”
“rest/proto”
“github.com/grpc-ecosystem/grpc-gateway/runtime”
“google.golang.org/grpc”
)
func main() {
ctx := context.Background()
ctx, cancel := context.WithCancel(ctx)
defer cancel()
mux := runtime.NewServeMux()
err := proto.RegisterRestServiceHandlerFromEndpoint(
ctx, mux, “localhost:50051”,
[]grpc.DialOption{grpc.WithInsecure()},
)
if err != nil {
log.Fatal(err)
}
http.ListenAndServe(“:8080”, mux)
}
这里主要是通过实现 gw 文件中的 RegisterRestServiceHandlerFromEndpoint
方法来连接 gRPC 服务。
gRPC 服务
package main
import (
“context”
“net”
“rest/proto”
“google.golang.org/grpc”
)
type RestServiceImpl struct{}
func (r *RestServiceImpl) Get(ctx context.Context, message *proto.StringMessage) (*proto.StringMessage, error) {
return &proto.StringMessage{Value: “Get hi:” + message.Value + “#”}, nil
}
func (r *RestServiceImpl) Post(ctx context.Context, message *proto.StringMessage) (*proto.StringMessage, error) {
return &proto.StringMessage{Value: “Post hi:” + message.Value + “@”}, nil
}
func main() {
grpcServer := grpc.NewServer()
proto.RegisterRestServiceServer(grpcServer, new(RestServiceImpl))
lis, _ := net.Listen(“tcp”, “:50051”)
grpcServer.Serve(lis)
}
gRPC 服务的实现方式还是和以前一样。
以上就是全部代码,现在来测试一下:
启动三个终端:
终端1 启动 gRPC 服务:
go run grpc_service.go
终端2 启动 REST 服务:
go run rest_service.go
终端3 来请求 REST 服务:
$ curl localhost:8080/get/gopher
{“value”:“Get hi:gopher”}
$ curl localhost:8080/post -X POST --data ‘{“value”:“grpc”}’
{“value”:“Post hi:grpc”}
源码地址: GitHub
超时控制
最后一部分介绍一下超时控制,这部分内容是非常重要的。
一般的 WEB 服务 API,或者是 Nginx 都会设置一个超时时间,超过这个时间,如果还没有数据返回,服务端可能直接返回一个超时错误,或者客户端也可能结束这个连接。
如果没有这个超时时间,那是相当危险的。所有请求都阻塞在服务端,会消耗大量资源,比如内存。如果资源耗尽的话,甚至可能会导致整个服务崩溃。
那么,在 gRPC 中怎么设置超时时间呢?主要是通过上下文 context.Context
参数,具体来说就是 context.WithDeadline
函数。
proto 文件
创建最简单的 proto 文件,这个不多说。
syntax = “proto3”;
package proto;
// The greeting service definition.
service Greeter {
// Sends a greeting
rpc SayHello (HelloRequest) returns (HelloReply) {}
}
// The request message containing the user’s name.
message HelloRequest {
string name = 1;
}
// The response message containing the greetings
message HelloReply {
string message = 1;
}
客户端
package main
import (
“client/proto”
“context”
“fmt”
“log”
“time”
“google.golang.org/grpc”
“google.golang.org/grpc/codes”
“google.golang.org/grpc/status”
)
func main() {
// 简单调用
conn, err := grpc.Dial(“localhost:50051”, grpc.WithInsecure())
defer conn.Close()
ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(time.Duration(3*time.Second)))
defer cancel()
client := proto.NewGreeterClient(conn)
// 简单调用
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
string message = 1;
}
客户端
package main
import (
“client/proto”
“context”
“fmt”
“log”
“time”
“google.golang.org/grpc”
“google.golang.org/grpc/codes”
“google.golang.org/grpc/status”
)
func main() {
// 简单调用
conn, err := grpc.Dial(“localhost:50051”, grpc.WithInsecure())
defer conn.Close()
ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(time.Duration(3*time.Second)))
defer cancel()
client := proto.NewGreeterClient(conn)
// 简单调用
[外链图片转存中…(img-4Ak952sN-1715501106198)]
[外链图片转存中…(img-wI4cTJA0-1715501106198)]
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!