【Go】五、Grpc 的入门使用

最新推荐文章于 2024-02-27 16:33:33 发布
最新推荐文章于 2024-02-27 16:33:33 发布
阅读量598 收藏 8
点赞数 4
分类专栏： Go 文章标签： golang 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41365204/article/details/136190757
版权

grpc 与 protobuf

grpc 使用的是 protobuf 协议，其是一个通用的 rpc 框架，基本支持主流的所有语言、其底层使用 http/2 进行网络通信，具有较高的效率

protobuf 是一种序列化格式，这种格式具有 序列化以及解码速度快（对比json、xml 速度快 2 - 100 倍），压缩率高等优点，是一个性能炸弹

基础环境配置

我们使用之前，要先安装 protobuf 的相关环境：

在 github 上下载 protoc 并配置好环境变量（环境变量配置到 bin 这一级）（用来生成源码）

记得在编译器中安装 protobuf support 插件

protobuf尝试

对 protobuf 进行尝试：创建一个.proto 文件：

syntax = "proto3";

message HelloRequest {
  string name = 1;  // 注意这里不是赋值，而是指定编号
}

之后使用 protoc 生成源码

protoc -I . --go_out=. --go-grpc_out=require_unimplemented_servers=false:. ./helloworld.proto

测试proto的使用：

func main() {
	req := HelloWorld.HelloRequest{
		Name:    "Chen",
		Age:     16,
		Courses: []string{"C", "Go"},
	}

	rsp, _ := proto.Marshal(&req)       // 编码
	newReq := HelloWorld.HelloRequest{} // 创建一个空的proto
	_ = proto.Unmarshal(rsp, &newReq)   // 解码，解码存储在 newReq 中
	fmt.Println(newReq.Name, newReq.Age, newReq.Courses)
}

实际开发尝试

创建目录结构：

grpc_test

server

server.go

client

proto

helloworld.proto

helloworld.pb.go（自动生成）

helloworld_grpc.pb.go（自动生成）

首先自己编写 helloworld.proto：

syntax = "proto3";
// 生成的包名
option go_package = ".;proto";

// 标注生成的方法接口
service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}

// 生成的结构体
message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

之后使用命令：

protoc -I . --go_out=. --go-grpc_out=require_unimplemented_servers=false:. ./helloworld.proto

生成helloworld.pb.go 文件：

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.32.0
// 	protoc        v4.25.3
// source: helloworld.proto

package proto

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

type HelloRequest struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
}

func (x *HelloRequest) Reset() {
	*x = HelloRequest{}
	if protoimpl.UnsafeEnabled {
		mi := &file_helloworld_proto_msgTypes[0]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *HelloRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*HelloRequest) ProtoMessage() {}

func (x *HelloRequest) ProtoReflect() protoreflect.Message {
	mi := &file_helloworld_proto_msgTypes[0]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use HelloRequest.ProtoReflect.Descriptor instead.
func (*HelloRequest) Descriptor() ([]byte, []int) {
	return file_helloworld_proto_rawDescGZIP(), []int{0}
}

func (x *HelloRequest) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

type HelloReply struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
}

func (x *HelloReply) Reset() {
	*x = HelloReply{}
	if protoimpl.UnsafeEnabled {
		mi := &file_helloworld_proto_msgTypes[1]
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		ms.StoreMessageInfo(mi)
	}
}

func (x *HelloReply) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*HelloReply) ProtoMessage() {}

func (x *HelloReply) ProtoReflect() protoreflect.Message {
	mi := &file_helloworld_proto_msgTypes[1]
	if protoimpl.UnsafeEnabled && x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use HelloReply.ProtoReflect.Descriptor instead.
func (*HelloReply) Descriptor() ([]byte, []int) {
	return file_helloworld_proto_rawDescGZIP(), []int{1}
}

func (x *HelloReply) GetMessage() string {
	if x != nil {
		return x.Message
	}
	return ""
}

var File_helloworld_proto protoreflect.FileDescriptor

var file_helloworld_proto_rawDesc = []byte{
	0x0a, 0x10, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x2e, 0x70, 0x72, 0x6f,
	0x74, 0x6f, 0x22, 0x22, 0x0a, 0x0c, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65,
	0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
	0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x26, 0x0a, 0x0a, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x52,
	0x65, 0x70, 0x6c, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18,
	0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0x31,
	0x0a, 0x07, 0x47, 0x72, 0x65, 0x65, 0x74, 0x65, 0x72, 0x12, 0x26, 0x0a, 0x08, 0x53, 0x61, 0x79,
	0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x12, 0x0d, 0x2e, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x52, 0x65, 0x71,
	0x75, 0x65, 0x73, 0x74, 0x1a, 0x0b, 0x2e, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x52, 0x65, 0x70, 0x6c,
	0x79, 0x42, 0x09, 0x5a, 0x07, 0x2e, 0x3b, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x06, 0x70, 0x72,
	0x6f, 0x74, 0x6f, 0x33,
}

var (
	file_helloworld_proto_rawDescOnce sync.Once
	file_helloworld_proto_rawDescData = file_helloworld_proto_rawDesc
)

func file_helloworld_proto_rawDescGZIP() []byte {
	file_helloworld_proto_rawDescOnce.Do(func() {
		file_helloworld_proto_rawDescData = protoimpl.X.CompressGZIP(file_helloworld_proto_rawDescData)
	})
	return file_helloworld_proto_rawDescData
}

var file_helloworld_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
var file_helloworld_proto_goTypes = []interface{}{
	(*HelloRequest)(nil), // 0: HelloRequest
	(*HelloReply)(nil),   // 1: HelloReply
}
var file_helloworld_proto_depIdxs = []int32{
	0, // 0: Greeter.SayHello:input_type -> HelloRequest
	1, // 1: Greeter.SayHello:output_type -> HelloReply
	1, // [1:2] is the sub-list for method output_type
	0, // [0:1] is the sub-list for method input_type
	0, // [0:0] is the sub-list for extension type_name
	0, // [0:0] is the sub-list for extension extendee
	0, // [0:0] is the sub-list for field type_name
}

func init() { file_helloworld_proto_init() }
func file_helloworld_proto_init() {
	if File_helloworld_proto != nil {
		return
	}
	if !protoimpl.UnsafeEnabled {
		file_helloworld_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*HelloRequest); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_helloworld_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*HelloReply); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: file_helloworld_proto_rawDesc,
			NumEnums:      0,
			NumMessages:   2,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_helloworld_proto_goTypes,
		DependencyIndexes: file_helloworld_proto_depIdxs,
		MessageInfos:      file_helloworld_proto_msgTypes,
	}.Build()
	File_helloworld_proto = out.File
	file_helloworld_proto_rawDesc = nil
	file_helloworld_proto_goTypes = nil
	file_helloworld_proto_depIdxs = nil
}

以及：

helloworld_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc             v4.25.3
// source: helloworld.proto

package proto

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7

const (
	Greeter_SayHello_FullMethodName = "/Greeter/SayHello"
)

// GreeterClient is the client API for Greeter service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type GreeterClient interface {
	SayHello(ctx context.Context, in *HelloRequest, opts ...grpc.CallOption) (*HelloReply, error)
}

type greeterClient struct {
	cc grpc.ClientConnInterface
}

func NewGreeterClient(cc grpc.ClientConnInterface) GreeterClient {
	return &greeterClient{cc}
}

func (c *greeterClient) SayHello(ctx context.Context, in *HelloRequest, opts ...grpc.CallOption) (*HelloReply, error) {
	out := new(HelloReply)
	err := c.cc.Invoke(ctx, Greeter_SayHello_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// GreeterServer is the server API for Greeter service.
// All implementations should embed UnimplementedGreeterServer
// for forward compatibility
type GreeterServer interface {
	SayHello(context.Context, *HelloRequest) (*HelloReply, error)
}

// UnimplementedGreeterServer should be embedded to have forward compatible implementations.
type UnimplementedGreeterServer struct {
}

func (UnimplementedGreeterServer) SayHello(context.Context, *HelloRequest) (*HelloReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SayHello not implemented")
}

// UnsafeGreeterServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to GreeterServer will
// result in compilation errors.
type UnsafeGreeterServer interface {
	mustEmbedUnimplementedGreeterServer()
}

func RegisterGreeterServer(s grpc.ServiceRegistrar, srv GreeterServer) {
	s.RegisterService(&Greeter_ServiceDesc, srv)
}

func _Greeter_SayHello_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(HelloRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GreeterServer).SayHello(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Greeter_SayHello_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GreeterServer).SayHello(ctx, req.(*HelloRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// Greeter_ServiceDesc is the grpc.ServiceDesc for Greeter service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Greeter_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "Greeter",
	HandlerType: (*GreeterServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "SayHello",
			Handler:    _Greeter_SayHello_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "helloworld.proto",
}

尝试编写业务逻辑（这里应该写在handler中，由于业务过于简单，先写在server中）：

server.go：

注意这里 grpc 帮我们处理了服务器不能连续被访问的问题，不需要我们手动通过一个死循环进行处理

package main

import (
	"context"
	"net"

	"google.golang.org/grpc"

	"FirstGo/goon/grpc_test/proto"
)

type Server struct{}

// 业务逻辑
// 第一个参数必须是context，error必须加
func (s *Server) SayHello(ctx context.Context, request *proto.HelloRequest) (*proto.HelloReply, error) {
	return &proto.HelloReply{
		Message: "hello " + request.Name,
	}, nil
}

func main() {
	g := grpc.NewServer()
	proto.RegisterGreeterServer(g, &Server{})
	lis, err := net.Listen("tcp", "0.0.0.0:8080")
	if err != nil {
		panic("failed to listen: " + err.Error())
	}
	err = g.Serve(lis)
	if err != nil {
		panic("failed to start grpc: " + err.Error())
	}
}

编写客户端

client.go：

package main

import (
	"FirstGo/goon/grpc_test/proto"
	"context"
	"fmt"
	"google.golang.org/grpc"
)

func main() {
	// 尝试拨号
	conn, err := grpc.Dial("127.0.0.1:8080", grpc.WithInsecure())
	if err != nil {
		panic(err)
	}
	defer conn.Close()

	// 创建客户端
	c := proto.NewGreeterClient(conn)
	// 调用对应的方法
	r, err := c.SayHello(context.Background(), &proto.HelloRequest{Name: "Chen"})
	if err != nil {
		panic(err)
	}
	fmt.Println(r.Message)
}

GRPC的四种数据传输模式

RPC 还具有四种数据模式，其分别是：

  1. 简单模式（上述模式）

    客户端发起一次请求，服务器返回一次响应

  2. 服务端数据流模式

    客户发起一次请求，服务器返回一段连续的数据流，最典型的例子是：客户发送一段股票代码，服务端实时将股票的数据源源不断的返回给客户端

  3. 客户端数据流模式

    与服务端数据流模式相反，这种是由客户端源源不断的向服务端发送数据流，在发送结束后，由服务端发送一个响应，这种的典型例子是：物联网终端向服务器报送数据

  4. 双向数据流模式

    这种是客户端和服务端都可以向双方发送数据流，这个时候双方的数据都可以相互发送，也就是可以实时交互，这种最典型的例子就是聊天机器人

实际测试：
建立文件结构：

stream_grpc_test

server

server.go

client

client.go

proto

stream.pb.gp

stream.proto

stream_grpc.pb.go

stream.proto：

syntax = "proto3";

option go_package = ".;proto";

service Greeter {
  rpc GetStream(StreamReqData) returns (stream StreamResData);  //  服务端流模式，返回的响应数据是流
  rpc PutStream(stream StreamReqData) returns (StreamResData);  // 客户端流模式，传给服务器的数据是流
  rpc AllStream(stream StreamReqData) returns (stream StreamResData);   // 双向流模式
}

message StreamReqData {
  string data = 1;
}

message StreamResData {
  string data = 1;
}

服务端流模式简单使用

只写了 服务端流模式的 server,go：

const PORT = ":50052"

type server struct {
}

// 对于服务端数据传输模式，参考以下内容：
// 没有 context 参数，而是将返回作为入参传入
func (s *server) GetStream(req *proto.StreamReqData, res proto.Greeter_GetStreamServer) error {
	i := 0
	for {
		i++
		_ = res.Send(&proto.StreamResData{
			Data: fmt.Sprintf("%v", time.Now().Unix()),
		})
		time.Sleep(time.Second)
		if i > 10 {
			break
		}
	}
	return nil
}

// 客户端数据流模式
// 只有一个用来不断接收的入参
func (s *server) PutStream(cliStr proto.Greeter_PutStreamServer) error {
	return nil
}

// 双向数据流模式，和客户端模式相同，只有一个入参
func (s *server) AllStream(allStr proto.Greeter_AllStreamServer) error {
	return nil
}

func main() {
	lis, err := net.Listen("tcp", PORT)
	if err != nil {
		panic(err)
	}

	s := grpc.NewServer()
	proto.RegisterGreeterServer(s, &server{})
	s.Serve(lis)

}

只针对于服务端流的client.go

func main() {
	// 拨号
	conn, err := grpc.Dial("localhost:50052", grpc.WithInsecure())
	if err != nil {
		panic(err)
	}
	defer conn.Close()

	c := proto.NewGreeterClient(conn)
	// 这里要注意：我们在进行调用的时候使用的仍让是 simple 的模式，而不是服务端的函数模式
	res, _ := c.GetStream(context.Background(), &proto.StreamReqData{Data: "Chen"})
	// 使用一个死循环来接收客户端传进来的数据
	for {
		a, err := res.Recv()
		if err != nil {
			fmt.Println(err)
			break
		}
		fmt.Println(a)
	}
}

客户端流模式的简单使用

server.go：

package main

import (
	"FirstGo/goon/stream_grpc_test/proto"
	"fmt"
	"google.golang.org/grpc"
	"net"
	"time"
)

const PORT = ":50052"

type server struct {
}

// 对于服务端数据传输模式，参考以下内容：
// 没有 context 参数，而是将返回作为入参传入
func (s *server) GetStream(req *proto.StreamReqData, res proto.Greeter_GetStreamServer) error {
	i := 0
	for {
		i++
		_ = res.Send(&proto.StreamResData{
			Data: fmt.Sprintf("%v", time.Now().Unix()),
		})
		time.Sleep(time.Second)
		if i > 10 {
			break
		}
	}
	return nil
}

// 客户端数据流模式
// 只有一个用来不断接收的入参
func (s *server) PutStream(cliStr proto.Greeter_PutStreamServer) error {
	// 客户端流模式，客户端不断的发送数据给服务器
	for {
		if a, err := cliStr.Recv(); err != nil {
			fmt.Println(err)
		} else {
			fmt.Println(a.Data)
		}
	}
	return nil
}

// 双向数据流模式，和客户端模式相同，只有一个入参
func (s *server) AllStream(allStr proto.Greeter_AllStreamServer) error {
	return nil
}

func main() {
	lis, err := net.Listen("tcp", PORT)
	if err != nil {
		panic(err)
	}

	s := grpc.NewServer()
	proto.RegisterGreeterServer(s, &server{})
	s.Serve(lis)

}

client.go：

package main

import (
	"FirstGo/goon/stream_grpc_test/proto"
	"context"
	"fmt"
	"google.golang.org/grpc"
	"time"
)

func main() {
	// 拨号
	conn, err := grpc.Dial("localhost:50052", grpc.WithInsecure())
	if err != nil {
		panic(err)
	}
	defer conn.Close()

	c := proto.NewGreeterClient(conn)

	putS, _ := c.PutStream(context.Background())
	i := 0
	for {
		i++
		putS.Send(&proto.StreamReqData{Data: fmt.Sprintf("Chen %d", i)})
		time.Sleep(time.Second)
		if i > 10 {
			break
		}
	}
}

双向流模式的简单使用

server.go：

package main

import (
	"FirstGo/goon/stream_grpc_test/proto"
	"fmt"
	"google.golang.org/grpc"
	"net"
	"sync"
	"time"
)

const PORT = ":50052"

type server struct {
}

// 对于服务端数据传输模式，参考以下内容：
// 没有 context 参数，而是将返回作为入参传入
func (s *server) GetStream(req *proto.StreamReqData, res proto.Greeter_GetStreamServer) error {
	i := 0
	for {
		i++
		_ = res.Send(&proto.StreamResData{
			Data: fmt.Sprintf("%v", time.Now().Unix()),
		})
		time.Sleep(time.Second)
		if i > 10 {
			break
		}
	}
	return nil
}

// 客户端数据流模式
// 只有一个用来不断接收的入参
func (s *server) PutStream(cliStr proto.Greeter_PutStreamServer) error {
	// 客户端流模式，客户端不断的发送数据给服务器
	for {
		if a, err := cliStr.Recv(); err != nil {
			fmt.Println(err)
		} else {
			fmt.Println(a.Data)
		}
	}
	return nil
}

// 双向数据流模式，和客户端模式相同，只有一个入参
func (s *server) AllStream(allStr proto.Greeter_AllStreamServer) error {
	// 不可以像下面这样简单使用，因为 Recv() 会阻塞主线程
	//allStr.Recv()
	//allStr.Send()

	wg := sync.WaitGroup{}
	wg.Add(2) // 添加两个等待线程

	go func() {
		defer wg.Done()
		for {
			data, _ := allStr.Recv()
			fmt.Println("收到客户端消息：" + data.Data)
		}
	}()

	go func() {
		defer wg.Done()
		for {
			_ = allStr.Send(&proto.StreamResData{Data: "我是服务器"})
			time.Sleep(time.Second)
		}
	}()

	wg.Wait()
	return nil
}

func main() {
	lis, err := net.Listen("tcp", PORT)
	if err != nil {
		panic(err)
	}

	s := grpc.NewServer()
	proto.RegisterGreeterServer(s, &server{})
	s.Serve(lis)

}

client.go:

package main

import (
	"FirstGo/goon/stream_grpc_test/proto"
	"context"
	"fmt"
	"google.golang.org/grpc"
	"sync"
	"time"
)

func main() {
	// 拨号
	conn, err := grpc.Dial("localhost:50052", grpc.WithInsecure())
	if err != nil {
		panic(err)
	}
	defer conn.Close()

	c := proto.NewGreeterClient(conn)
	// // 这里要注意：我们在进行调用的时候使用的仍让是 simple 的模式，而不是服务端的函数模式
	// 服务端模式的客户端
	//res, _ := c.GetStream(context.Background(), &proto.StreamReqData{Data: "Chen"})
	// // 使用一个死循环来接收客户端传进来的数据
	//for {
	//	a, err := res.Recv()
	//	if err != nil {
	//		fmt.Println(err)
	//		break
	//	}
	//	fmt.Println(a)
	//}

	// 客户端数据流模式
	//putS, _ := c.PutStream(context.Background())
	//i := 0
	//for {
	//	i++
	//	putS.Send(&proto.StreamReqData{Data: fmt.Sprintf("Chen %d", i)})
	//	time.Sleep(time.Second)
	//	if i > 10 {
	//		break
	//	}
	//}

	// 双向流模式
	allStr, _ := c.AllStream(context.Background())
	wg := sync.WaitGroup{}
	wg.Add(2) // 添加两个等待线程

	go func() {
		defer wg.Done()
		for {
			data, _ := allStr.Recv()
			fmt.Println("收到客户端消息：" + data.Data)
		}
	}()

	go func() {
		defer wg.Done()
		for {
			_ = allStr.Send(&proto.StreamReqData{Data: "我是Chen (客户端)"})
			time.Sleep(time.Second)
		}
	}()

	wg.Wait()
}
清河__
关注
  • 4
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Go语言入门教程-golang与gRpc
01-20
gRpc 文章目录gRpc1. gRpc 概述2. gRpc执行概述3. gRpc-go 安装4. gRpc使用 1. gRpc 概述 gRpc是什么 ? gRPC是Google开源的可以在任何环境中运行的现代开源高性能RPC框架。它可以通过可插拔的支持来有效地连接数据中心内和跨数据中心的服务，以实现负载平衡，跟踪，健康检查和身份验证。它也适用于分布式计算的最后一英里，以将设备，移动应用程序和浏览器连接到后端服务。 主要使用场景 在微服务风格架构中有效连接多语种服务 将移动设备，浏览器客户端连接到后端服务 生成高效的客户端库 gRpc官方地址 https://grpc.io/ gRpc源码托管
gRPC 入门使用教程
海纳百川
10-28 5194
在 gRPC 里客户端应用可以像调用本地对象一样直接调用另一台不同的机器上服务端应用的方法，使得您能够更容易地创建分布式应用和服务。与许多 RPC 系统类似，gRPC 也是基于以下理念：定义一个服务，指定其能够被远程调用的方法（包含参数和返回类型）。在服务端实现这个接口，并运行一个 gRPC 服务器来处理客户端调用。在客户端拥有一个存根能够像服务端一样的方法。
【GO开发工程师】grpc进阶#golang
最新发布
席万里的博客
02-27 1282
我想在每一个 RPC 方法的前面或后面做某些操作，我想针对某个业务模块的 RPC 方法进行统一的特殊处理，我想对 RPC 方法进行鉴权校验，我想对 RPC 方法进行上下文的超时控制，我想对每个 RPC 方法的请求都做日志记录，怎么做呢？开发者可以根据自己的需求，在请求和响应中传递任意类型的元数据，以实现各种功能，比如身份验证、流量控制、跟踪、日志记录等。元数据是键值对的集合，可以包含请求的附加信息，比如身份验证凭据、请求标识符、客户端信息等。元数据以键值对的形式存在，键是字符串，值可以是任意的序列化数据。
[golang 微服务] 4. gRPC介绍,Protobuf结合gRPC 创建微服务
zhoupenghui168的博客
06-02 2108
gRPC介绍, Protobuf结合gRPC创建微服务,gRPC实现微服务案例
go使用protoc-gen插件编译protobuf文件及构建gRPC的服务
程序猿CKeen的专栏
04-15 1817
目录 1. 安装最新版本release版本的go环境 2. 安装最新版本protoc文件，我们使用version 3。 3. 默认protoc不支持go，需要安装go的扩展插件 4. 配置系统环境变量 5. 编写proto文件 6. 执行命令，生成go的pb文件 7. 编写RPC的server和client 8.遇到问题 参考文章 gRPC使用参考： Quick start | Go | gRPC proto 3的语法参考： https://developers.goog.
golang使用grpc实现服务调用(入门级二)
小飞哥的博客
08-08 873
golang使用grpc实现服务调用(入门级二) 学习目标 服务端编写 客户端编写 实现客户端调用服务端并返回数据 首先解决一下上个章节的作业(数组结构体) 通过关键字repeated 来定义 说明：上一章节的proto内容被博主增加了其他信息，所以今天列子是新写的，可能和上个文件存在出入 接下来我们一起来通过golang代码实现服务端和客户端的编写 上节和大家一起做了pd.go文件生成，那么我们怎么利用这个文件做交互呢？ 以下为客户端代码： func main() { // 连接服务端地址 co
【gRPC】grpc和protobuf快速入门 - 基于「Python」「Golang」
Jzin的博客
12-11 1523
gRPC是一个高性能、开源和通用的RPC框架，面向移动和HTTP/2设计。目前提供C、Java和Go语言版本，分别是: grpc, grpc-java, grpc-go.其中C版本支持C,C++，Node.js，Python, Ruby, Objective-C，PHP和C#支持.
ProtoBuf之在GoLang中实现GRPC服务
smart_ferry的博客
10-16 1017
ProtoBuf之在GoLang中实现GRPC服务
写给go开发者的gRPC教程系列-protobuf基础
luckyllliang的博客
02-13 519
protobuf是一种语言无关、平台无关的可扩展的序列化协议。gRPC使用protobuf作为其序列化协议，理解pb是使用gRPC的第一步。
写给go开发者的gRPC教程-protobuf基础
Go中国
03-03 982
gRPC是谷歌开源的一款高性能、支持多种开发语言的服务框架，对于一个rpc我们关注如下几方面：序列化协议。gRPC使用protobuf，首先使用protobuf定义服务，然后使用这个文件来生成客户端和服务端的代码。因为pb是跨语言的，因此即使服务端和客户端语言并不一致也是可以互相序列化和反序列化的网络传输层。gRPC使用http2.0协议，http2.0相比于HTTP 1.x ，大幅度的提升了 w...
go-lang-grpc:Golang用于GRPC测试
04-06
Golang用于GRPC测试入门
go_grpc_flutter:gRPC ToDo API的首次测试
05-01
使用Flutter构建的待办事项应用程序的gRPC API 这是即将发布的博客文章的API，该博客文章有关构建与gRPC后端连接的待办事项移动应用程序。 我已经使用来生成入门项目
ng2-gRPC:使用gRPC-web的Angular 2项目入门工具包
05-02
ng2-gRPC 起步并运行： git clone https://github.com/b3ntly/ng2-grpc.git yarn install ./scripts/get_go_deps.sh ./scripts/install_protobuf.sh npm run start 该项目还包含角材料和Craft.io路线。
micro-starter-kit：Cloud Native GoLang微服务-gRPC，GraphQL
02-03
用于Golang的微服务入门套件，旨在对开发人员友好。 建立状态 质量 总览 你得到什么 Monorepo-微服务之间的共享代码 带有REST Gateway的gRPC微服务 使用输入验证 配置-可插拔源，可合并配置，安全恢复 可自定义...
golang-protobuf和内置rpc_grpc的配置和使用
weixin_41395435的博客
03-16 872
1.下载对应zip包, 解压 https://github.com/protocolbuffers/protobuf/releases -2. 配置环境变量: 在用户系统变量Path最后添加刚刚解压的bin目录，例如: G:\soft\protobuf\bin -3. 验证是否配置正确： 打开终端，输入protoc，如果输出下面内容，代码配置成功。 4.安装protoc-gen-go库 在此之前要设置go的环境变量: GO111MODULE=on GOPROXY=https://gopro.
Golang中gRPC使用及原理探究
Peerless__的博客
10-14 1696
gRPC是一种进程间通信技术，在微服务和云原生领域都有着广泛的应用。在使用之前需要使用proto文件来定义出message类型和service接口，比如下面的greeter";syntax表示proto语法版本，在此使用proto3版本第3行用于声明生成的go代码的package第9行和第13行定义了两个消息，都包含一个data的字段，类型为string第5行定义了一个名为Greeter的service，该service包含一个rpc方法为SayHello为请求类型，HelloReply。
史上最细gRPC(Go)入门教程(一)---Protobuf介绍及其编译原理
探索云原生
01-04 1706
本文主要记录了 Protobuf 的基本使用。包括 编译器 protoc 、Go Plugins 安装及 .proto文件定义、编译等。 gRPC 系列文章欢迎访问我的个人博客 指月山瀑 1. 概述 Protocol buffers 是一种语言无关、平台无关的可扩展机制或者说是数据交换格式，用于序列化结构化数据。与 XML、JSON 相比，Protocol buffers 序列化后的码流更小、速度更快、操作更简单。 Protocol buffers are a language-neutral, p
golang grpc protobuf搭建和使用
gitxuzan
04-12 2786
安装 protobuf 和 protoc-gen-go 插件 安装 protobuf https://github.com/protocolbuffers/protobuf/releases 安装golang 插件 go get -u github.com/golang/protobuf/protoc-gen-go // 安装在 $GOPATH/bin 目录下面，记得需要把这个目录加入环境变量 放入 .zshrc export GOPATH=$HOME/go # 换成自己go代码的路径,这是我自己设置的
go 使用 grpc
02-06
Go 使用 gRPC 是很简单的。首先，你需要使用 `go get` 命令来安装 gRPC 包和 protobuf 编译器： ``` go get -u google.golang.org/grpc go get -u github.com/golang/protobuf/protoc-gen-go ``` 然后，你可以使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值