gRPC的简单应用

最新推荐文章于 2024-09-07 12:56:31 发布
最新推荐文章于 2024-09-07 12:56:31 发布
阅读量536 收藏
点赞数
分类专栏： # gRPC 文章标签： grpc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dawnto/article/details/128978848
版权

gRPC的简单应用

gRPC是由开发的一个高性能、通用的开源RPC框架，主要面向移动应用开发且基于HTTP/2协议标准而设计，同时支持大多数流行的编程语言。
官网：https://grpc.io/

安装protoc 工具

https://protobuf.dev/

安装Go插件

旧版本直接安装protoc-gen-go即可

go install google.golang.org/protobuf/cmd/protoc-gen-go@latest

新版本须同时安装protoc-gen-go，protoc-gen-go-grpc

go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

以下的过程使用旧版本演示，新版本在新版Go插件章节演示

grpc sample

1.创建pb/product.proto文件

product.proto

syntax = "proto3";

option go_package="../service";

package service;

message ProductRequest {
  int32 prod_id = 1;
}

message ProductResponse {
  int32 prod_stock = 1;
}

// 定义接口
service ProductService {
  rpc GetProductStock(ProductRequest) returns(ProductResponse);
}

2.cd 到pb目录执行

protoc --go_out=plugins=grpc:./ product.proto

3.生成了 /service/product.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.26.0
// 	protoc        v3.21.12
// source: product.proto

package service

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	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 ProductRequest struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	ProdId int32 `protobuf:"varint,1,opt,name=prod_id,json=prodId,proto3" json:"prod_id,omitempty"`
}

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

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

func (*ProductRequest) ProtoMessage() {}

func (x *ProductRequest) ProtoReflect() protoreflect.Message {
	mi := &file_product_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 ProductRequest.ProtoReflect.Descriptor instead.
func (*ProductRequest) Descriptor() ([]byte, []int) {
	return file_product_proto_rawDescGZIP(), []int{0}
}

func (x *ProductRequest) GetProdId() int32 {
	if x != nil {
		return x.ProdId
	}
	return 0
}

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

	ProdStock int32 `protobuf:"varint,1,opt,name=prod_stock,json=prodStock,proto3" json:"prod_stock,omitempty"`
}

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

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

func (*ProductResponse) ProtoMessage() {}

func (x *ProductResponse) ProtoReflect() protoreflect.Message {
	mi := &file_product_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 ProductResponse.ProtoReflect.Descriptor instead.
func (*ProductResponse) Descriptor() ([]byte, []int) {
	return file_product_proto_rawDescGZIP(), []int{1}
}

func (x *ProductResponse) GetProdStock() int32 {
	if x != nil {
		return x.ProdStock
	}
	return 0
}

var File_product_proto protoreflect.FileDescriptor

var file_product_proto_rawDesc = []byte{
	0x0a, 0x0d, 0x70, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12,
	0x07, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x22, 0x29, 0x0a, 0x0e, 0x50, 0x72, 0x6f, 0x64,
	0x75, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x70, 0x72,
	0x6f, 0x64, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x70, 0x72, 0x6f,
	0x64, 0x49, 0x64, 0x22, 0x30, 0x0a, 0x0f, 0x50, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x52, 0x65,
	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x70, 0x72, 0x6f, 0x64, 0x5f, 0x73,
	0x74, 0x6f, 0x63, 0x6b, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x70, 0x72, 0x6f, 0x64,
	0x53, 0x74, 0x6f, 0x63, 0x6b, 0x32, 0x56, 0x0a, 0x0e, 0x50, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74,
	0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x44, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x50, 0x72,
	0x6f, 0x64, 0x75, 0x63, 0x74, 0x53, 0x74, 0x6f, 0x63, 0x6b, 0x12, 0x17, 0x2e, 0x73, 0x65, 0x72,
	0x76, 0x69, 0x63, 0x65, 0x2e, 0x50, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75,
	0x65, 0x73, 0x74, 0x1a, 0x18, 0x2e, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x2e, 0x50, 0x72,
	0x6f, 0x64, 0x75, 0x63, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x0c, 0x5a,
	0x0a, 0x2e, 0x2e, 0x2f, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f,
	0x74, 0x6f, 0x33,
}

var (
	file_product_proto_rawDescOnce sync.Once
	file_product_proto_rawDescData = file_product_proto_rawDesc
)

func file_product_proto_rawDescGZIP() []byte {
	file_product_proto_rawDescOnce.Do(func() {
		file_product_proto_rawDescData = protoimpl.X.CompressGZIP(file_product_proto_rawDescData)
	})
	return file_product_proto_rawDescData
}

var file_product_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
var file_product_proto_goTypes = []interface{}{
	(*ProductRequest)(nil),  // 0: service.ProductRequest
	(*ProductResponse)(nil), // 1: service.ProductResponse
}
var file_product_proto_depIdxs = []int32{
	0, // 0: service.ProductService.GetProductStock:input_type -> service.ProductRequest
	1, // 1: service.ProductService.GetProductStock:output_type -> service.ProductResponse
	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_product_proto_init() }
func file_product_proto_init() {
	if File_product_proto != nil {
		return
	}
	if !protoimpl.UnsafeEnabled {
		file_product_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*ProductRequest); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_product_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*ProductResponse); 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_product_proto_rawDesc,
			NumEnums:      0,
			NumMessages:   2,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_product_proto_goTypes,
		DependencyIndexes: file_product_proto_depIdxs,
		MessageInfos:      file_product_proto_msgTypes,
	}.Build()
	File_product_proto = out.File
	file_product_proto_rawDesc = nil
	file_product_proto_goTypes = nil
	file_product_proto_depIdxs = nil
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConnInterface

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6

// ProductServiceClient is the client API for ProductService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ProductServiceClient interface {
	GetProductStock(ctx context.Context, in *ProductRequest, opts ...grpc.CallOption) (*ProductResponse, error)
}

type productServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewProductServiceClient(cc grpc.ClientConnInterface) ProductServiceClient {
	return &productServiceClient{cc}
}

func (c *productServiceClient) GetProductStock(ctx context.Context, in *ProductRequest, opts ...grpc.CallOption) (*ProductResponse, error) {
	out := new(ProductResponse)
	err := c.cc.Invoke(ctx, "/service.ProductService/GetProductStock", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ProductServiceServer is the server API for ProductService service.
type ProductServiceServer interface {
	GetProductStock(context.Context, *ProductRequest) (*ProductResponse, error)
}

// UnimplementedProductServiceServer can be embedded to have forward compatible implementations.
type UnimplementedProductServiceServer struct {
}

func (*UnimplementedProductServiceServer) GetProductStock(context.Context, *ProductRequest) (*ProductResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetProductStock not implemented")
}

func RegisterProductServiceServer(s *grpc.Server, srv ProductServiceServer) {
	s.RegisterService(&_ProductService_serviceDesc, srv)
}

func _ProductService_GetProductStock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ProductRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProductServiceServer).GetProductStock(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/service.ProductService/GetProductStock",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProductServiceServer).GetProductStock(ctx, req.(*ProductRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _ProductService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "service.ProductService",
	HandlerType: (*ProductServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetProductStock",
			Handler:    _ProductService_GetProductStock_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "product.proto",
}

4.创建/service/product.go实现Productserveice

package service

import "context"

var ProductService = &productService{}

type productService struct {
}

// GetProductStock 接口实现
func (p *productService) GetProductStock(context context.Context, request *ProductRequest) (*ProductResponse, error) {
	stock := p.GetStockById(request.ProdId)
	return &ProductResponse{ProdStock: stock}, nil
}

func (p *productService) GetStockById(id int32) int32 {
	return 100
}

5.创建服务端代码

main.go

package main

import (
	"fmt"
	"google.golang.org/grpc"
	"log"
	"net"
	"test_grpc/service"
)

func main() {
	// 创建rpc实例
	rpcServer := grpc.NewServer()

	// 服务注册
	service.RegisterProductServiceServer(rpcServer, service.ProductService)

	// 启动监听
	listener, err := net.Listen("tcp", ":8000")
	if err != nil {
		log.Fatal("启动监听失败", err)
	}

	// 启动服务
	err = rpcServer.Serve(listener)
	if err != nil {
		log.Fatal("启动服务失败", err)
	}
}

6.将/service目录复制到client目录下

client引入service包中的方法，进行使用

7.创建客户端代码 /client/main.go

package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
	"log"
	"test_grpc/client/service"
)

func main() {
	// 创建连接
	conn, err := grpc.Dial(":8888", grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		log.Fatal("服务端连接失败: ", err)
	}

	// 退出时关闭连接
	defer conn.Close()

	// 创建客户端实例
	productServiceClient := service.NewProductServiceClient(conn)

	// 方法请求
	res, err := productServiceClient.GetProductStock(context.Background(), &service.ProductRequest{ProdId: 520})
	if err != nil {
		log.Fatal("调用gRPC方法失败: ", err)
	}

	fmt.Println("调用gRPC方法成功, ProdStock = ", res.ProdStock)
}

8.分别运行服务端与客户端

客户端返回：
调用gRPC方法成功, ProdStock = 100

9.目录结构

在这里插入图片描述

加密通信与认证方式

HTTP是明文传输的，即客户端与服务端之间通信的信息是可见的，这就存在被窃听、冒充或篡改的风险。HTTPS在HTTP和TCP之间加入了TLS协议。

[HTTP]			[HTTP]
				[SSL/TLS]
[TCP]			[TCP]
[IP]			[IP]
[MAC]			[MAC]

TLS协议主要解决了以下三个网络安全问题：
1.信息加密： HTTP 交互信息是被加密的，第三方就无法被窃取；
2.校验机制：校验信息传输过程中是否有被第三方篡改过，如果被篡改过，则会有警告提示；
3.身份证书：双方认证，双方都可以配置证书，防止身份被冒充；
客户端与服务端通过gRPC进行方法调用，也需要加入证书来保证调用的安全。

0.安装openssl工具

安装openssl：http://slproweb.com/products/Win32OpenSSL.html
并将openssl加入环境变量

创建cert目录，以下所有操作均在该目录中进行

1.生成私钥文件

openssl genrsa -des3 -out ca.key 2048

2.创建证书请求

openssl req -new -key ca.key -out ca.csr

3.生成ca.crt

openssl x509 -req -days 365 -in ca.csr -signkey ca.key -out ca.crt

4.修改openssl.cnf

在openssl安装目录中查找openssl.cnf，复制到当前目录下

# 打开copy_extensions
copy_extensions = copy

# 打开req_extensions
req_extensions = v3_req

# 找到[ v3_req ], 添加
subjectAltName = @alt_names

# 添加标签
[ alt_names ]
DNS.1 = *.test.com

5.生成证书私钥

openssl genpkey -algorithm RSA -out server.key

6.通过私钥生成证书请求文件

openssl req -new -nodes -key server.key -out server.csr -days 3650 -config ./openssl.cnf -extensions v3_req

7.生成SAN证书

openssl x509 -req -days 365 -in server.csr -out server.pem -CA ca.crt -CAkey ca.key -CAcreateserial -extfile ./openssl.cnf -extensions v3_req

SAN(Subject Alternative Name) 是 SSL 标准 x509 中定义的一个扩展。使用了 SAN 字段的 SSL 证书，可以扩展此证书支持的域名，使得一个证书可以支持多个不同域名的解析。

说明：
key：服务器上的私钥文件，用于对发送给客户端数据的加密，以及对从客户端接收到数据的解密；
csr：证书签名请求文件，用于提交给证书颁发机构（CA）对证书签名；
crt：由颁发证书机构（CA）签名后的证书，或者是开发者自签名的证书，包含证书持有人的信息，持有人的公钥，以及签署者的签名等信息；
pem：是基于Base64编码的证书格式，扩展名包括PEM、CRT和CER；

单向认证

流程：
1.发送客户端SSL版本等信息到服务端
2.服务端给客户端返回SSL版本，随机数等信息，以及服务器公钥
3.客户端校验服务端证书是否合法，合法继续，否则警告
4.客户端发送自己可支持的对称加密方案给服务端，供其选择
5.服务端选择加密程度高的加密方式
6.服务端将选择好的加密方式以明文方式发送给客户端
7.客户端收到加密方式后，产生随机码，作为对称加密密钥，使用服务端公钥进行加密后，发送给服务端
8.服务端使用私钥对加密信息进行解密，获得对称加密的密钥
9.双端通信，对称加密确保了通信安全

1.修改服务端代码

package main

import (
	"test_grpc/service"

	"google.golang.org/grpc"

	"net"

	"log"

	"fmt"

	"google.golang.org/grpc/credentials"
)

func main() {
	fmt.Println("开始启动服务")

	// 添加证书
	creds, err := credentials.NewServerTLSFromFile("cert/server.pem", "cert/server.key")
	if err != nil {
		log.Fatal("证书获取失败", err)
	}
	// 创建rpc实例(添加认证)
	rpcServer := grpc.NewServer(grpc.Creds(creds))
	// 服务注册
	service.RegisterProductServiceServer(rpcServer, service.ProductService)
	// 启动监听
	listener, err := net.Listen("tcp", ":8888")
	if err != nil {
		log.Fatal("启动监听失败", err)
	}
	// 启动服务
	err = rpcServer.Serve(listener)
	if err != nil {
		log.Fatal("启动服务失败", err)
	}
	fmt.Println("启动服务成功")
}

2.修改客户端代码

package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"log"
	"test_grpc/client/service"
)

func main() {
	// 添加公钥
	creds, err := credentials.NewClientTLSFromFile("../cert/server.pem", "*.test.com")
	if err != nil {
		log.Fatal("证书错误: ", err)
	}

	// 创建连接
	conn, err := grpc.Dial(":8888", grpc.WithTransportCredentials(creds))
	if err != nil {
		log.Fatal("服务端连接失败: ", err)
	}

	fmt.Println("证书认证通过")

	// 退出时关闭连接
	defer conn.Close()

	// 创建客户端实例
	productServiceClient := service.NewProductServiceClient(conn)

	// 方法请求
	resq, err := productServiceClient.GetProductStock(context.Background(), &service.ProductRequest{ProdId: 233})
	if err != nil {
		log.Fatal("调用gRPC方法失败: ", err)
	}

	fmt.Println("调用gRPC方法成功, ProdStock = ", resq.ProdStock)
}

3.使用命令行启动服务端与客户端

客户端执行结果为：
证书认证通过
调用gRPC方法成功, ProdStock = 100

注意：credentials.NewClientTLSFromFile("../cert/server.pem", "*.test.com")，*.test.com应与证书中的域名相对应。

4.目录结构

在这里插入图片描述

双向认证

流程：
1.发送客户端SSL版本等信息到服务端
2.服务端给客户端返回SSL版本，随机数等信息，以及服务器公钥
3.客户端校验服务端证书是否合法，合法继续，否则警告
4.客户端校验通过后，将自己的证书及公钥发送至服务端
5.服务端对客户端证书进行校验，校验结束后获得客户端公钥
6.客户端发送自己可支持的对称加密方案给服务端，供其选择
7.服务端选择加密程度高的加密方式
8.服务端将选择好的加密方式使用客户端公钥进行加密后发送给客户端
9.客户端收到加密方式后，产生随机码，作为对称加密密钥，使用服务端公钥进行加密后，发送给服务端
10.服务端使用私钥对加密信息进行解密，获得对称加密的密钥
11.双端通信，对称加密确保了通信安全

1.生成客户端公钥和私钥

1.1生成私钥
openssl genpkey -algorithm RSA -out client.key
1.2生成证书
openssl req -new -nodes -key client.key -out client.csr -days 3650 -config ./openssl.cnf -extensions v3_req
1.3生成SAN证书
openssl x509 -req -days 365 -in client.csr -out client.pem -CA ca.crt -CAkey ca.key -CAcreateserial -extfile ./openssl.cnf -extensions v3_req

2.修改服务端代码

package main

import (
	"crypto/tls"
	"crypto/x509"
	"fmt"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"io/ioutil"
	"log"
	"net"
	"test_grpc/service"
)

func main() {
	fmt.Println("开始启动服务")

	// 添加证书
	// creds, err0 := credentials.NewServerTLSFromFile("cert/server.pem", "cert/server.key")
	// if err0 != nil {
	// 	log.Fatal("证书生成失败", err0)
	// }

	// 证书认证-双向认证
	cert, err0 := tls.LoadX509KeyPair("cert/server.pem", "cert/server.key")
	if err0 != nil {
		log.Fatal("证书读取失败", err0)
	}

	fmt.Println("证书读取成功")

	// 创建一个新的、空的CertPool
	certPool := x509.NewCertPool()
	ca, err1 := ioutil.ReadFile("cert/ca.crt")
	if err1 != nil {
		log.Fatal("ca证书读取失败", err1)
	}

	fmt.Println("ca证书读取成功")

	// 尝试解析所传入的PEM编码的证书，如果解析成功会将其加到CertPool中，便于后面使用
	certPool.AppendCertsFromPEM(ca)
	// 构建基于TLS的TransportCredentials选项
	creds := credentials.NewTLS(&tls.Config{
		// 设置证书链, 允许包含一个或多个
		Certificates: []tls.Certificate{cert},
		// 要求必须校验客户端的证书
		ClientAuth: tls.RequireAndVerifyClientCert,
		// 设置根证书的集合, 校验方式使用ClientAuth中设定的模式
		ClientCAs: certPool,
	})

	fmt.Println("设置TLS的TransportCredentials选项成功")

	// 创建rpc实例
	rpcServer := grpc.NewServer(grpc.Creds(creds))

	// 服务注册
	service.RegisterProductServiceServer(rpcServer, service.ProductService)

	// 启动监听
	listener, err := net.Listen("tcp", ":8888")
	if err != nil {
		log.Fatal("启动监听失败", err)
	}

	// 启动服务
	err = rpcServer.Serve(listener)
	if err != nil {
		log.Fatal("启动服务失败", err)
	}
}

3.修改客户端代码

package main

import (
	"context"
	"crypto/tls"
	"crypto/x509"
	"fmt"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"io/ioutil"
	"log"
	"test_grpc/client/service"
)

func main() {
	// 添加公钥
	// creds, err0 := credentials.NewClientTLSFromFile("../cert/server.pem", "*.test.com")
	// if err0 != nil {
	// 	log.Fatal("证书错误: ", err0)
	// }

	// 证书认证-双向认证
	// 从证书相关文件中读取解析信息, 得到证书公钥、密钥对
	cert, err0 := tls.LoadX509KeyPair("../cert/client.pem", "../cert/client.key")
	if err0 != nil {
		log.Fatal("证书读取失败", err0)
	}

	fmt.Println("证书读取成功")

	// 创建一个新的、空的CertPool
	certPool := x509.NewCertPool()
	ca, err1 := ioutil.ReadFile("../cert/ca.crt")
	if err1 != nil {
		log.Fatal("ca证书读取失败", err1)
	}

	fmt.Println("ca证书读取成功")

	// 尝试解析所传入的PEM编码的证书，如果解析成功会将其加到CertPool中，便于后面使用
	certPool.AppendCertsFromPEM(ca)
	// 构建基于TLS的TransportCredentials选项
	creds := credentials.NewTLS(&tls.Config{
		// 设置证书链, 允许包含一个或多个
		Certificates: []tls.Certificate{cert},
		ServerName:   "*.test.com",
		RootCAs:      certPool,
	})

	fmt.Println("设置TLS的TransportCredentials选项成功")

	// 创建连接
	conn, err := grpc.Dial(":8888", grpc.WithTransportCredentials(creds))
	if err != nil {
		log.Fatal("服务端连接失败: ", err)
	}

	fmt.Println("证书认证通过")

	// 退出时关闭连接
	defer conn.Close()

	// 创建客户端实例
	productServiceClient := service.NewProductServiceClient(conn)

	// 方法请求
	resq, err := productServiceClient.GetProductStock(context.Background(), &service.ProductRequest{ProdId: 233})
	if err != nil {
		log.Fatal("调用gRPC方法失败: ", err)
	}

	fmt.Println("调用gRPC方法成功, ProdStock = ", resq.ProdStock)
}

4.使用命令行启动服务端与客户端

客户端代码运行结果为：
证书读取成功
ca证书读取成功
设置TLS的TransportCredentials选项成功
证书认证通过
调用gRPC方法成功, ProdStock = 100

5.目录结构

在这里插入图片描述

Token认证

服务端添加用户名密码的校验
或使用jwt或oauth2

1.修改服务端代码

package main

import (
	"context"
	"crypto/tls"
	"crypto/x509"
	"fmt"
	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/credentials"
	"google.golang.org/grpc/metadata"
	"google.golang.org/grpc/status"
	"io/ioutil"
	"log"
	"net"
	"test_grpc/service"
)

func main() {
	fmt.Println("开始启动服务")

	// 添加证书
	// creds, err0 := credentials.NewServerTLSFromFile("cert/server.pem", "cert/server.key")
	// if err0 != nil {
	// 	log.Fatal("证书生成失败", err0)
	// }

	// 证书认证-双向认证
	cert, err0 := tls.LoadX509KeyPair("cert/server.pem", "cert/server.key")
	if err0 != nil {
		log.Fatal("证书读取失败", err0)
	}

	fmt.Println("证书读取成功")

	// 创建一个新的、空的CertPool
	certPool := x509.NewCertPool()
	ca, err1 := ioutil.ReadFile("cert/ca.crt")
	if err1 != nil {
		log.Fatal("ca证书读取失败", err1)
	}

	fmt.Println("ca证书读取成功")

	// 尝试解析所传入的PEM编码的证书，如果解析成功会将其加到CertPool中，便于后面使用
	certPool.AppendCertsFromPEM(ca)
	// 构建基于TLS的TransportCredentials选项
	creds := credentials.NewTLS(&tls.Config{
		// 设置证书链, 允许包含一个或多个
		Certificates: []tls.Certificate{cert},
		// 要求必须校验客户端的证书
		ClientAuth: tls.RequireAndVerifyClientCert,
		// 设置根证书的集合, 校验方式使用ClientAuth中设定的模式
		ClientCAs: certPool,
	})

	fmt.Println("设置TLS的TransportCredentials选项成功")

	// token认证 -- 合法的用户名和密码
	var authInterceptor grpc.UnaryServerInterceptor
	authInterceptor = func(
		ctx context.Context,
		req interface{},
		info *grpc.UnaryServerInfo,
		handler grpc.UnaryHandler,
	) (resp interface{}, err error) {
		// 拦截请求, 验证token
		err = Auth(ctx)
		if err != nil {
			return
		}

		// 继续处理请求
		return handler(ctx, req)
	}

	// 创建rpc实例
	rpcServer := grpc.NewServer(grpc.Creds(creds), grpc.UnaryInterceptor(authInterceptor))

	// 服务注册
	service.RegisterProductServiceServer(rpcServer, service.ProductService)

	// 启动监听
	listener, err := net.Listen("tcp", ":8888")
	if err != nil {
		log.Fatal("启动监听失败", err)
	}

	// 启动服务
	err = rpcServer.Serve(listener)
	if err != nil {
		log.Fatal("启动服务失败", err)
	}
}

func Auth(ctx context.Context) error {
	md, ok := metadata.FromIncomingContext(ctx)
	if !ok {
		return fmt.Errorf("missing credentials")
	}

	var user string
	var passwd string

	if val, ok := md["user"]; ok {
		user = val[0]
	}

	if val, ok := md["passwd"]; ok {
		passwd = val[0]
	}

	if user != "admin" || passwd != "admin@123" {
		return status.Errorf(codes.Unauthenticated, "token认证失败")
	}

	fmt.Println("token认证成功")
	return nil
}

2.在客户端创建/auth目录 auth.go 文件，实现grpc.PerRPCCredentials接口

package auth

import "context"

type Authentication struct {
	User   string
	Passwd string
}

func (a *Authentication) GetRequestMetadata(context.Context, ...string) (
	map[string]string, error,
) {
	return map[string]string{"user": a.User, "passwd": a.Passwd}, nil
}

func (a *Authentication) RequireTransportSecurity() bool {
	return false
}

3.修改客户端代码

package main

import (
	"context"
	"crypto/tls"
	"crypto/x509"
	"fmt"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"io/ioutil"
	"log"
	"test_grpc/client/auth"
	"test_grpc/client/service"
)

func main() {
	// 添加公钥
	// creds, err0 := credentials.NewClientTLSFromFile("../cert/server.pem", "*.test.com")
	// if err0 != nil {
	// 	log.Fatal("证书错误: ", err0)
	// }

	// 证书认证-双向认证
	// 从证书相关文件中读取解析信息, 得到证书公钥、密钥对
	cert, err0 := tls.LoadX509KeyPair("../cert/client.pem", "../cert/client.key")
	if err0 != nil {
		log.Fatal("证书读取失败", err0)
	}

	fmt.Println("证书读取成功")

	// 创建一个新的、空的CertPool
	certPool := x509.NewCertPool()
	ca, err1 := ioutil.ReadFile("../cert/ca.crt")
	if err1 != nil {
		log.Fatal("ca证书读取失败", err1)
	}

	fmt.Println("ca证书读取成功")

	// 尝试解析所传入的PEM编码的证书，如果解析成功会将其加到CertPool中，便于后面使用
	certPool.AppendCertsFromPEM(ca)
	// 构建基于TLS的TransportCredentials选项
	creds := credentials.NewTLS(&tls.Config{
		// 设置证书链, 允许包含一个或多个
		Certificates: []tls.Certificate{cert},
		ServerName:   "*.test.com",
		RootCAs:      certPool,
	})

	fmt.Println("设置TLS的TransportCredentials选项成功")

	token := &auth.Authentication{
		User:   "admin",
		Passwd: "admin@123",
	}

	// 创建连接
	conn, err := grpc.Dial(":8888", grpc.WithTransportCredentials(creds), grpc.WithPerRPCCredentials(token))
	if err != nil {
		log.Fatal("服务端连接失败: ", err)
	}

	fmt.Println("证书认证通过")

	// 退出时关闭连接
	defer conn.Close()

	// 创建客户端实例
	productServiceClient := service.NewProductServiceClient(conn)

	// 方法请求
	resq, err := productServiceClient.GetProductStock(context.Background(), &service.ProductRequest{ProdId: 233})
	if err != nil {
		log.Fatal("调用gRPC方法失败: ", err)
	}

	fmt.Println("调用gRPC方法成功, ProdStock = ", resq.ProdStock)
}

4.使用命令行启动服务端与客户端

客户端执行结果：
证书读取成功
ca证书读取成功
设置TLS的TransportCredentials选项成功
证书认证通过
调用gRPC方法成功, ProdStock = 100

5.目录结构

在这里插入图片描述

新版Go插件

1.官方提醒新版使用以下方式生成

直接在模块根目录执行即可

protoc --go_out=./service --go-grpc_out=./service pb\product.proto

2.生成后目录结构发生改变

在这里插入图片描述

3.直接运行代码会报错

.\main.go:81:50: cannot use service.ProductService (variable of type *service.productService) as service.ProductServiceServer value in argument to service.RegisterProductServiceServer: *service.productService does not implement service.ProductServiceServer (missing method mustEmbedUnimplementedProductServiceServer)

4.解决办法

在product.go文件中使 productService 实现mustEmbedUnimplementedProductServiceServer方法

package service

import (
	"context"
)

var ProductService = &productService{}

type productService struct {
}

// GetProductStock 接口实现
func (p *productService) GetProductStock(context context.Context, request *ProductRequest) (*ProductResponse, error) {
	stock := p.GetStockById(request.ProdId)
	return &ProductResponse{ProdStock: stock}, nil
}

func (p *productService) GetStockById(id int32) int32 {
	return 100
}

func (*productService) mustEmbedUnimplementedProductServiceServer() {}

 UnimplementedProductServiceServer must be embedded to have forward compatible implementations.
//type UnimplementedProductServiceServer struct {
//}
//
//func (UnimplementedProductServiceServer) GetProductStock(context.Context, *ProductRequest) (*ProductResponse, error) {
//	return nil, status.Errorf(codes.Unimplemented, "method GetProductStock not implemented")
//}
//func (UnimplementedProductServiceServer) mustEmbedUnimplementedProductServiceServer() {}

5.同样将生成的目录复制到客户端

在这里插入图片描述

6.使用命令行启动服务端与客户端

客户端执行结果：
证书读取成功
ca证书读取成功
设置TLS的TransportCredentials选项成功
证书认证通过
调用gRPC方法成功, ProdStock = 100

7.最终目录结构

在这里插入图片描述

修改mod文件，规范化模块名为：module test.com/test_grpc

go.mod文件

module test.com/test_grpc

go 1.20

require (
	google.golang.org/grpc v1.53.0
	google.golang.org/protobuf v1.28.1
)

require (
	github.com/golang/protobuf v1.5.2 // indirect
	golang.org/x/net v0.5.0 // indirect
	golang.org/x/sys v0.4.0 // indirect
	golang.org/x/text v0.6.0 // indirect
	google.golang.org/genproto v0.0.0-20230110181048-76db0878b65f // indirect
)

自动更新引用即可

更新proto文件

user.proto

syntax = "proto3";

option go_package="../service";
package service;

message User {
  string name = 1;
  int32  age  = 2;
  optional string password = 3; // optional代表指针
  optional string address = 4;
}

product.proto

syntax = "proto3";

// 从执行protoc这个命令的当前目录开始引入，如果在user.proto文件同级目录，则`import "user.proto";`即可
import "pb/user.proto";

option go_package="../service";

package service; // 将要生成的go文件包名

message ProductRequest {
  int32 prod_id = 1; // 1代表顺序
}

message ProductResponse {
  int32 prod_stock = 1; // 1代表顺序
  User  user = 2; // 导入其他pb文件
}

service ProductService {
  rpc GetProductStock(ProductRequest) returns (ProductResponse);
}

重新生成Go代码：protoc --go_out=./service --go-grpc_out=./service pb\*.proto
*.proto代表该目录下的所有proto文件

google.protobuf.Any与anypb.New()的使用

message Content { // 定义新结构
  string msg = 1;
}

message ProductResponse {
  int32 prod_stock = 1; // 1代表顺序
  User  user = 2;
  google.protobuf.Any data = 3; // Any 类型
}

// GetProductStock 接口实现
func (p *productService) GetProductStock(context context.Context, request *ProductRequest) (*ProductResponse, error) {
	stock := p.GetStockById(request.ProdId)
	addr := "beijing"
	user := &User{Address: &addr}
	
	a, _ := anypb.New(&Content{Msg: "hello"}) // 转换成Any类型
	return &ProductResponse{ProdStock: stock, User: user,Data: a}, nil

}

Stream

使用stream关键字修饰来表示流程传输。当该关键字修饰参数时，表示为客户端流式的gRPC接口；

普通RPC

rpc SimplePing(PingRequest) returns (PingReply);

客户端流式RPC

rpc SimplePing(stream PingRequest) returns (PingReply);
1.修改product.proto文件，重新生成Go文件，复制到客户端
syntax = "proto3";

// 从执行protoc这个命令的当前目录开始引入
import "pbfile/user.proto";
import "google/protobuf/any.proto"; //引入Any类型
option go_package="../service";

package service; // 将要生成的go文件包名

message ProductRequest {
  int32 prod_id = 1; // 1代表顺序
}

message Content {
  string msg = 1;
}

message ProductResponse {
  int32 prod_stock = 1; // 1代表顺序
  User  user = 2;
  google.protobuf.Any data = 3;
}
// 导入其他pb文件


service ProductService {
  rpc GetProductStock(ProductRequest) returns (ProductResponse);
  // 增加客户端流定义方法
  rpc UpdateProductStockClientStream(stream ProductRequest) returns(ProductResponse);
}
2.修改服务端product.go文件
package service

import (
	"context"
	"fmt"
	"google.golang.org/protobuf/types/known/anypb"
	"io"
)

var ProductService = &productService{}

type productService struct {
}

// GetProductStock 接口实现
func (p *productService) GetProductStock(context context.Context, request *ProductRequest) (*ProductResponse, error) {
	stock := p.GetStockById(request.ProdId)
	addr := "beijing"
	user := &User{Address: &addr}
	a, _ := anypb.New(&Content{Msg: "hello"}) // 转换成Any类型
	return &ProductResponse{ProdStock: stock, User: user, Data: a}, nil
}

func (p *productService) GetStockById(id int32) int32 {
	return 100
}

func (*productService) mustEmbedUnimplementedProductServiceServer() {}

func (*productService) UpdateProductStockClientStream(stream ProductService_UpdateProductStockClientStreamServer) error {
	count := 0
	for {
		recv, err := stream.Recv()
		if err != nil {
			if err == io.EOF {
				return nil
			}
			return err
		}

		fmt.Println("服务端接收到的流", recv.ProdId)
		count++
		if count > 10 {
			rsq := &ProductResponse{ProdStock: recv.ProdId}
			err := stream.SendAndClose(rsq) // 发送响应
			if err != nil {
				return err
			}
			return nil
		}
	}
}

 UnimplementedProductServiceServer must be embedded to have forward compatible implementations.
//type UnimplementedProductServiceServer struct {
//}
//
//func (UnimplementedProductServiceServer) GetProductStock(context.Context, *ProductRequest) (*ProductResponse, error) {
//	return nil, status.Errorf(codes.Unimplemented, "method GetProductStock not implemented")
//}
//func (UnimplementedProductServiceServer) mustEmbedUnimplementedProductServiceServer() {}
3.修改客户端文件
package main

import (
	"context"
	"crypto/tls"
	"crypto/x509"
	"fmt"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"io/ioutil"
	"log"
	"test.com/test_grpc/client/auth"
	"test.com/test_grpc/client/service"
	"time"
)

func main() {
	// 添加公钥
	// creds, err0 := credentials.NewClientTLSFromFile("../cert/server.pem", "*.test.com")
	// if err0 != nil {
	// 	log.Fatal("证书错误: ", err0)
	// }

	// 证书认证-双向认证
	// 从证书相关文件中读取解析信息, 得到证书公钥、密钥对
	cert, err0 := tls.LoadX509KeyPair("../cert/client.pem", "../cert/client.key")
	if err0 != nil {
		log.Fatal("证书读取失败", err0)
	}

	fmt.Println("证书读取成功")

	// 创建一个新的、空的CertPool
	certPool := x509.NewCertPool()
	ca, err1 := ioutil.ReadFile("../cert/ca.crt")
	if err1 != nil {
		log.Fatal("ca证书读取失败", err1)
	}

	fmt.Println("ca证书读取成功")

	// 尝试解析所传入的PEM编码的证书，如果解析成功会将其加到CertPool中，便于后面使用
	certPool.AppendCertsFromPEM(ca)
	// 构建基于TLS的TransportCredentials选项
	creds := credentials.NewTLS(&tls.Config{
		// 设置证书链, 允许包含一个或多个
		Certificates: []tls.Certificate{cert},
		ServerName:   "*.test.com",
		RootCAs:      certPool,
	})

	fmt.Println("设置TLS的TransportCredentials选项成功")

	token := &auth.Authentication{
		User:   "admin",
		Passwd: "admin@123",
	}

	// 创建连接
	conn, err := grpc.Dial(":8888", grpc.WithTransportCredentials(creds), grpc.WithPerRPCCredentials(token))
	if err != nil {
		log.Fatal("服务端连接失败: ", err)
	}

	fmt.Println("证书认证通过")

	// 退出时关闭连接
	defer conn.Close()

	// 创建客户端实例
	productServiceClient := service.NewProductServiceClient(conn)

	// 方法请求
	// resq, err := productServiceClient.GetProductStock(context.Background(), &service.ProductRequest{ProdId: 233})
	// if err != nil {
	// 	log.Fatal("调用gRPC方法失败: ", err)
	// }

	// fmt.Println("调用gRPC方法成功, ProdStock = ", resq.ProdStock)

	// 获取流
	stream, err := productServiceClient.UpdateProductStockClientStream(context.Background())
	if err != nil {
		log.Fatal("获取流失败", err)
	}

	// 定义切片，设置请求
	rsq := make(chan struct{}, 1)
	go prodRequest(stream, rsq)

	// 等待数据接收
	select {
	case <-rsq:
		// 接收数据
		recv, err := stream.CloseAndRecv()
		if err != nil {
			log.Fatal(err)
		}

		stock := recv.ProdStock
		fmt.Println("客户端收到响应: ", stock)
	}
}

// 请求接口
func prodRequest(stream service.ProductService_UpdateProductStockClientStreamClient, rsq chan struct{}) {
	count := 0
	for {
		request := &service.ProductRequest{
			ProdId: 100,
		}

		// 发送数据
		err := stream.SendMsg(request)
		if err != nil {
			log.Fatal(err)
		}

		time.Sleep(time.Second)
		count++
		if count > 10 {
			rsq <- struct{}{}
			break
		}
	}
}
4.执行结果

客户端：
证书读取成功
ca证书读取成功
设置TLS的TransportCredentials选项成功
证书认证通过
客户端收到响应: 100

服务端流式RPC

rpc SimplePing(PingRequest) returns (stream PingReply);
1.修改product.proto文件，重新生成Go文件，复制到客户端
syntax = "proto3";

// 从执行protoc这个命令的当前目录开始引入
import "pbfile/user.proto";
import "google/protobuf/any.proto"; //引入Any类型
option go_package="../service";

package service; // 将要生成的go文件包名

message ProductRequest {
  int32 prod_id = 1; // 1代表顺序
}

message Content {
  string msg = 1;
}

message ProductResponse {
  int32 prod_stock = 1; // 1代表顺序
  User  user = 2;
  google.protobuf.Any data = 3;
}
// 导入其他pb文件


service ProductService {
  rpc GetProductStock(ProductRequest) returns (ProductResponse);
  // 增加客户端流定义方法
  rpc UpdateProductStockClientStream(stream ProductRequest) returns(ProductResponse);

  // 服务端流定义方法
  rpc GetProductStockServerStream(ProductRequest) returns(stream ProductResponse);
}
2.修改服务端product.go文件
package service

import (
	"context"
	"fmt"
	"google.golang.org/protobuf/types/known/anypb"
	"io"
	"time"
)

var ProductService = &productService{}

type productService struct {
}

// GetProductStock 接口实现
func (p *productService) GetProductStock(context context.Context, request *ProductRequest) (*ProductResponse, error) {
	stock := p.GetStockById(request.ProdId)
	addr := "beijing"
	user := &User{Address: &addr}
	a, _ := anypb.New(&Content{Msg: "hello"}) // 转换成Any类型
	return &ProductResponse{ProdStock: stock, User: user, Data: a}, nil
}

func (p *productService) GetStockById(id int32) int32 {
	return 100
}

func (*productService) mustEmbedUnimplementedProductServiceServer() {}

func (*productService) UpdateProductStockClientStream(stream ProductService_UpdateProductStockClientStreamServer) error {
	count := 0
	for {
		recv, err := stream.Recv()
		if err != nil {
			if err == io.EOF {
				return nil
			}
			return err
		}

		fmt.Println("服务端接收到的流", recv.ProdId)
		count++
		if count > 10 {
			rsq := &ProductResponse{ProdStock: recv.ProdId}
			err := stream.SendAndClose(rsq) // 发送响应
			if err != nil {
				return err
			}
			return nil
		}
	}
}

// GetProductStockServerStream 新增服务端接口实现
func (p *productService) GetProductStockServerStream(request *ProductRequest, stream ProductService_GetProductStockServerStreamServer) error {
	count := 0
	for {
		rsp := &ProductResponse{ProdStock: request.ProdId}
		err := stream.SendMsg(rsp)
		if err != nil {
			return err
		}
		time.Sleep(time.Second)
		count++
		if count > 10 {
			return nil
		}
	}
}

 UnimplementedProductServiceServer must be embedded to have forward compatible implementations.
//type UnimplementedProductServiceServer struct {
//}
//
//func (UnimplementedProductServiceServer) GetProductStock(context.Context, *ProductRequest) (*ProductResponse, error) {
//	return nil, status.Errorf(codes.Unimplemented, "method GetProductStock not implemented")
//}
//func (UnimplementedProductServiceServer) mustEmbedUnimplementedProductServiceServer() {}
3.修改客户端文件
package main

import (
	"context"
	"crypto/tls"
	"crypto/x509"
	"fmt"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"io"
	"io/ioutil"
	"log"
	"test.com/test_grpc/client/auth"
	"test.com/test_grpc/client/service"
	"time"
)

func main() {
	// 添加公钥
	// creds, err0 := credentials.NewClientTLSFromFile("../cert/server.pem", "*.test.com")
	// if err0 != nil {
	// 	log.Fatal("证书错误: ", err0)
	// }

	// 证书认证-双向认证
	// 从证书相关文件中读取解析信息, 得到证书公钥、密钥对
	cert, err0 := tls.LoadX509KeyPair("../cert/client.pem", "../cert/client.key")
	if err0 != nil {
		log.Fatal("证书读取失败", err0)
	}

	fmt.Println("证书读取成功")

	// 创建一个新的、空的CertPool
	certPool := x509.NewCertPool()
	ca, err1 := ioutil.ReadFile("../cert/ca.crt")
	if err1 != nil {
		log.Fatal("ca证书读取失败", err1)
	}

	fmt.Println("ca证书读取成功")

	// 尝试解析所传入的PEM编码的证书，如果解析成功会将其加到CertPool中，便于后面使用
	certPool.AppendCertsFromPEM(ca)
	// 构建基于TLS的TransportCredentials选项
	creds := credentials.NewTLS(&tls.Config{
		// 设置证书链, 允许包含一个或多个
		Certificates: []tls.Certificate{cert},
		ServerName:   "*.test.com",
		RootCAs:      certPool,
	})

	fmt.Println("设置TLS的TransportCredentials选项成功")

	token := &auth.Authentication{
		User:   "admin",
		Passwd: "admin@123",
	}

	// 创建连接
	conn, err := grpc.Dial(":8888", grpc.WithTransportCredentials(creds), grpc.WithPerRPCCredentials(token))
	if err != nil {
		log.Fatal("服务端连接失败: ", err)
	}

	fmt.Println("证书认证通过")

	// 退出时关闭连接
	defer conn.Close()

	// 创建客户端实例
	productServiceClient := service.NewProductServiceClient(conn)

	// 方法请求
	// resq, err := productServiceClient.GetProductStock(context.Background(), &service.ProductRequest{ProdId: 233})
	// if err != nil {
	// 	log.Fatal("调用gRPC方法失败: ", err)
	// }

	// fmt.Println("调用gRPC方法成功, ProdStock = ", resq.ProdStock)

	// 获取流
	// stream, err := productServiceClient.UpdateProductStockClientStream(context.Background())
	// if err != nil {
	// 	log.Fatal("获取流失败", err)
	// }

	// rsq := make(chan struct{}, 1)
	// go prodRequest(stream, rsq)
	// select {
	// case <-rsq:
	// 	recv, err := stream.CloseAndRecv()
	// 	if err != nil {
	// 		log.Fatal(err)
	// 	}

	// 	stock := recv.ProdStock
	// 	fmt.Println("客户端收到响应: ", stock)
	// }

	request := &service.ProductRequest{
		ProdId: 100,
	}

	// 调用服务端接口获取流
	stream, err := productServiceClient.GetProductStockServerStream(context.Background(), request)
	if err != nil {
		log.Fatal("获取流失败")
	}

	// 循环获取流
	for {
		recv, err := stream.Recv()
		if err != nil {
			// 流数据接收完成标志
			if err == io.EOF {
				fmt.Println("客户端接收数据完成")
				stream.CloseSend()
				break
			}

			log.Fatal(err)
		}
		fmt.Println("客户端收到的流", recv.ProdStock)
	}
}

func prodRequest(stream service.ProductService_UpdateProductStockClientStreamClient, rsq chan struct{}) {
	count := 0
	for {
		request := &service.ProductRequest{
			ProdId: 100,
		}

		err := stream.Send(request)
		if err != nil {
			log.Fatal(err)
		}

		time.Sleep(time.Second)
		count++
		if count > 10 {
			rsq <- struct{}{}
			break
		}
	}
}
4.执行结果

客户端：
证书读取成功
ca证书读取成功
设置TLS的TransportCredentials选项成功
证书认证通过
客户端收到的流 100
客户端收到的流 100
客户端收到的流 100
客户端收到的流 100
客户端收到的流 100
客户端收到的流 100
客户端收到的流 100
客户端收到的流 100
客户端收到的流 100
客户端收到的流 100
客户端收到的流 100
客户端接收数据完成

双向流式RPC

// 双向流式RPC
rpc SimplePing(stream PingRequest) returns (stream PingReply);
1.修改product.proto文件，重新生成Go文件，复制到客户端
syntax = "proto3";

// 从执行protoc这个命令的当前目录开始引入
import "pbfile/user.proto";
import "google/protobuf/any.proto"; //引入Any类型
option go_package="../service";

package service; // 将要生成的go文件包名

message ProductRequest {
  int32 prod_id = 1; // 1代表顺序
}

message Content {
  string msg = 1;
}

message ProductResponse {
  int32 prod_stock = 1; // 1代表顺序
  User  user = 2;
  google.protobuf.Any data = 3;
}
// 导入其他pb文件


service ProductService {
  rpc GetProductStock(ProductRequest) returns (ProductResponse);

  // 增加客户端流定义方法
  rpc UpdateProductStockClientStream(stream ProductRequest) returns(ProductResponse);

  // 服务端流定义方法
  rpc GetProductStockServerStream(ProductRequest) returns(stream ProductResponse);

  // 双向流定义方法
  rpc SayHelloStream(stream ProductRequest) returns(stream ProductResponse);
}
2.修改服务端product.go文件
package service

import (
	"context"
	"fmt"
	"google.golang.org/protobuf/types/known/anypb"
	"io"
	"time"
)

var ProductService = &productService{}

type productService struct {
}

// GetProductStock 接口实现
func (p *productService) GetProductStock(context context.Context, request *ProductRequest) (*ProductResponse, error) {
	stock := p.GetStockById(request.ProdId)
	addr := "beijing"
	user := &User{Address: &addr}
	a, _ := anypb.New(&Content{Msg: "hello"}) // 转换成Any类型
	return &ProductResponse{ProdStock: stock, User: user, Data: a}, nil
}

func (p *productService) GetStockById(id int32) int32 {
	return 100
}

func (*productService) mustEmbedUnimplementedProductServiceServer() {}

func (*productService) UpdateProductStockClientStream(stream ProductService_UpdateProductStockClientStreamServer) error {
	count := 0
	for {
		recv, err := stream.Recv()
		if err != nil {
			if err == io.EOF {
				return nil
			}
			return err
		}

		fmt.Println("服务端接收到的流", recv.ProdId)
		count++
		if count > 10 {
			rsq := &ProductResponse{ProdStock: recv.ProdId}
			err := stream.SendAndClose(rsq) // 发送响应
			if err != nil {
				return err
			}
			return nil
		}
	}
}

// GetProductStockServerStream 新增服务端接口实现
func (p *productService) GetProductStockServerStream(request *ProductRequest, stream ProductService_GetProductStockServerStreamServer) error {
	count := 0
	for {
		rsp := &ProductResponse{ProdStock: request.ProdId}
		err := stream.SendMsg(rsp)
		if err != nil {
			return err
		}
		time.Sleep(time.Second)
		count++
		if count > 10 {
			return nil
		}
	}
}

func (p *productService) SayHelloStream(stream ProductService_SayHelloStreamServer) error {
	for {
		// 接收消息
		recv, err := stream.Recv()
		if err != nil {
			return nil
		}

		fmt.Println("服务端接收客户端的消息", recv.ProdId)
		time.Sleep(time.Second)

		// 发送消息
		rsp := &ProductResponse{ProdStock: recv.ProdId}
		err = stream.Send(rsp)
		if err != nil {
			return err
		}
	}
}

 UnimplementedProductServiceServer must be embedded to have forward compatible implementations.
//type UnimplementedProductServiceServer struct {
//}
//
//func (UnimplementedProductServiceServer) GetProductStock(context.Context, *ProductRequest) (*ProductResponse, error) {
//	return nil, status.Errorf(codes.Unimplemented, "method GetProductStock not implemented")
//}
//func (UnimplementedProductServiceServer) mustEmbedUnimplementedProductServiceServer() {}
3.修改客户端文件
package main

import (
	"google.golang.org/grpc"

	"log"

	"test.com/test_grpc/client/service"

	"context"

	"fmt"

	"google.golang.org/grpc/credentials"

	"crypto/tls"

	"crypto/x509"

	"io/ioutil"

	//	"io"

	"test.com/test_grpc/client/auth"

	"time"
)

func main() {
	// 添加公钥
	// creds, err0 := credentials.NewClientTLSFromFile("../cert/server.pem", "*.test.com")
	// if err0 != nil {
	// 	log.Fatal("证书错误: ", err0)
	// }

	// 证书认证-双向认证
	// 从证书相关文件中读取解析信息, 得到证书公钥、密钥对
	cert, err0 := tls.LoadX509KeyPair("../cert/client.pem", "../cert/client.key")
	if err0 != nil {
		log.Fatal("证书读取失败", err0)
	}

	fmt.Println("证书读取成功")

	// 创建一个新的、空的CertPool
	certPool := x509.NewCertPool()
	ca, err1 := ioutil.ReadFile("../cert/ca.crt")
	if err1 != nil {
		log.Fatal("ca证书读取失败", err1)
	}

	fmt.Println("ca证书读取成功")

	// 尝试解析所传入的PEM编码的证书，如果解析成功会将其加到CertPool中，便于后面使用
	certPool.AppendCertsFromPEM(ca)
	// 构建基于TLS的TransportCredentials选项
	creds := credentials.NewTLS(&tls.Config{
		// 设置证书链, 允许包含一个或多个
		Certificates: []tls.Certificate{cert},
		ServerName:   "*.test.com",
		RootCAs:      certPool,
	})

	fmt.Println("设置TLS的TransportCredentials选项成功")

	token := &auth.Authentication{
		User:   "admin",
		Passwd: "admin@123",
	}

	// 创建连接
	conn, err := grpc.Dial(":8888", grpc.WithTransportCredentials(creds), grpc.WithPerRPCCredentials(token))
	if err != nil {
		log.Fatal("服务端连接失败: ", err)
	}

	fmt.Println("证书认证通过")

	// 退出时关闭连接
	defer conn.Close()

	// 创建客户端实例
	productServiceClient := service.NewProductServiceClient(conn)

	// 方法请求
	// resq, err := productServiceClient.GetProductStock(context.Background(), &service.ProductRequest{ProdId: 233})
	// if err != nil {
	// 	log.Fatal("调用gRPC方法失败: ", err)
	// }

	// fmt.Println("调用gRPC方法成功, ProdStock = ", resq.ProdStock)

	// 获取流
	// stream, err := productServiceClient.UpdateProductStockClientStream(context.Background())
	// if err != nil {
	// 	log.Fatal("获取流失败", err)
	// }

	// rsq := make(chan struct{}, 1)
	// go prodRequest(stream, rsq)
	// select {
	// case <-rsq:
	// 	recv, err := stream.CloseAndRecv()
	// 	if err != nil {
	// 		log.Fatal(err)
	// 	}

	// 	stock := recv.ProdStock
	// 	fmt.Println("客户端收到响应: ", stock)
	// }

	// request := &service.ProductRequest{
	// 	ProdId: 100,
	// }

	// stream, err := productServiceClient.GetProductStockServerStream(context.Background(), request)
	// if err != nil {
	// 	log.Fatal("获取流失败")
	// }

	// for {
	// 	recv, err := stream.Recv()
	// 	if err != nil {
	// 		if err == io.EOF {
	// 			fmt.Println("客户端接收数据完成")
	// 			stream.CloseSend()
	// 			break
	// 		}

	// 		log.Fatal(err)
	// 	}
	// 	fmt.Println("客户端收到的流", recv.ProdStock)
	// }

	// 获取双向流
	stream, err := productServiceClient.SayHelloStream(context.Background())

	for {
		// 发送消息
		request := &service.ProductRequest{
			ProdId: 100,
		}
		err = stream.Send(request)
		if err != nil {
			log.Fatal(err)
		}
		time.Sleep(time.Second)
		recv, err := stream.Recv()
		if err != nil {
			log.Fatal(err)
		}

		fmt.Println("客户端接收服务端的消息", recv.ProdStock)
	}
}

func prodRequest(stream service.ProductService_UpdateProductStockClientStreamClient, rsq chan struct{}) {
	count := 0
	for {
		request := &service.ProductRequest{
			ProdId: 100,
		}

		err := stream.Send(request)
		if err != nil {
			log.Fatal(err)
		}

		time.Sleep(time.Second)
		count++
		if count > 10 {
			rsq <- struct{}{}
			break
		}
	}
}
4.执行结果

客户端与服务端互相发数据

纠正

proto文件生成后，拷贝*.pb.go文件到客户端即可

Reference

https://www.bilibili.com/video/BV16Z4y117yz

gRPC使用简介
benben的博客
04-26 791
概览 gRPC是一款语言中立、平台中立、开源的远程过程调用（RPC）系统。在gRPC里，客户端应用程序可以像调用本地对象一样直接调用另一台不同机器上，服务端应用的方法，使得你能够更容易的创建分布式应用和服务。与许多RPC系统类似，gRPC也是基于以下理念：定义一个服务，指定其能够被远程调用的方法（包括参数和返回类型）。在服务端实现这个接口，并运行一个gRPC服务器来处理客户端调用。 先决条件 ...
GRPC的简单应用
Jacson__的博客
06-03 276
GRPC的简单应用
gRPC 四种模式及应用场景
最新发布
qq_38269333的博客
09-07 906
gRPC 四种模式及应用场景
Grpc应用，基本实现
zk_chs的博客
07-01 449
使用grpc可以用来进行不同系统之间的信息交互，而且grpc不限于java，使用同一个proto文件可以在不同的编程语言之间交互。 上面这张图介绍了proto文件的语法，对应proto3.0，具体更多的内容请参考文档： http://www.grpc.io/docs/#generating-grpc-code     下面我们先讲一下如何在java中通过proto文件生成java...
gRPC应用场景
极客神殿
09-24 770
gRPC（gRPC Remote Procedure Call）是一种高性能、跨语言的远程过程调用框架，通常用于构建分布式系统和微服务架构中的通信层。总之，gRPC是一个灵活且高性能的通信框架，适用于各种分布式系统和服务间通信的场景。它的使用不仅可以提高性能和效率，还可以减少通信协议的开发和维护成本。
gRPC简单应用——Hello World 超详细版本
weixin_45894608的博客
05-23 1161
超级详细的gRPC简单实现
GRPC简单应用（Java+Python）
07-26
在本文中，我们将深入探讨如何在Java和Python中实现GRPC的基本应用。 一、GRPC简介 GRPC的核心理念是定义服务接口，这些接口可以在不同的语言中实现，客户端和服务端通过这些接口进行通信。接口定义文件通常使用....
django-grpc：基于Django应用程序的简单gRPC服务
02-04
启动gRPC服务器的简单方法，可以访问Django ORM和其他方便的东西。 gRPC调用比传统的HTTP请求要快得多，因为它通过持久连接进行通信并被压缩。 底层gRPC库是用C编写的，这使其比任何需要花费大量时间进行序列化/反...
grpc-swagger:使用swagger-ui调试gRPC应用程序
05-14
gRPC-swagger 服务清单 ... 简单地调用gRPC方法。 屏幕截图 现场演示 演示 生成并运行 使用释放的罐子 wget https://github.com/grpc-swagger/grpc-swagger/releases/latest/download/grpc-s
flutter_grpc:Flutter应用程序使用grpc框架
05-12
总结来说，`flutter_grpc`使得在Flutter应用中使用gRPC变得简单。通过protobuf定义服务，生成Dart代码，创建客户端实例，以及在服务端实现接口，开发者可以构建出高性能的分布式系统，为用户提供无缝的跨平台体验。...
grpcdemo:该应用程序演示了gRPC通信
04-01
这由一个具有的简单应用程序组成。 网关服务 演示服务 网关服务 它具有一个Web终结点，该终结点除外使用（http1.1）的Web请求 与GRPC服务器通信的GRPC客户端（演示服务） 它暴露端口8080（默认） 演示服务 这是一...
grpc使用及意义
MarryOnlyQueen的博客
05-22 1366
学习使用GRPC远程过程调用 RPC为何使用grpcprotobuf的使用及规范protobuf介绍字段规则默认值标识号嵌套消息 远程过程调用 RPC RPC（Remote Procedure Call）远程过程调用协议，一种通过网络从远程计算机上请求服务，而不需要了解底层网络技术的协议。RPC假定了某些协议的存在，例如TCP/UDP等，为通信程序之间携带信息数据。在OSI七层模型中，RPC跨越了传输层和应用层，RPC使得开发，包括网络分布式多程序在内的应用程序更加容易。 为何使用grpc protob
gRPC 入门
qq_46457076的博客
02-11 543
关于 gRPC 的基本使用的介绍！
go 与 protobuf的安装与使用
dept123的专栏
05-24 514
go 与 protobuf的安装与使用
【Golang | gRPC】使用protoc编译.proto文件
土豆
06-14 7974
环境： Golang： go1.18.2 windows/amd64 protoc：libprotoc 3.21.1使用编译.proto文件，首先需要正确安装编译器。如果使用预编译的二进制文件方式安装，注意添加环境变量，具体可以参考【Golang | gRPC】protocol buffer compiler\protoc的安装protoc本身并不支持Golang，需要额外安装对应的插件 方法1，使用安装 方法2，在一个已经包含go.mod文件的项目里使用 安装成功后，会在目录下生成两个2进制文件3.1.1
go语言生成.proto生成go文件
了迹奇有没
05-09 2736
go通过.proto生成对应go文件，最新实操可用
gRPC教程与应用
个人学习笔记库，一篇一篇记录成长的足迹
06-21 7346
grpc直接实现了新的服务器，并允许用户自定义接口，在服务器中暴露这些接口，在程序中整合grpc服务器，然后将接口绑定到程序的方法，客户端在连接rpc服务器是调用接口，则会直接指向服务器程序的方法，因此就行在本地调用一样。grpc是使用期本身的语法定义接口的，在上面的例子中使用了go语言，将接口绑定到go语言的接口中，那么如果将grpc的接口绑定到其他语言中也是可以使用的。由于Go语言都是基于源码进行的，在其他语言中需要下载protobuf的工具包，帮助将proto的接口转换为对应语言的接口。
grpc 在golang 介绍 （2）
星星点灯的博客
01-20 236
上一章我们简单介绍了一下grpc 概念方面的信息，这一章我们具体学习grpc 在golang的知识。 源码地址： https://github.com/grpc/grpc-go/tree/master/examples/route_guide 关于protocol buffers的相关信息我们这里暂不赘述，如果有读者对这部分的知识不熟悉可以参看以下链接学习。 http://doc.osc...
gRPC Stream
啦啦啦啦 la
04-04 2494
gRPC Stream Stream 在 gRPC 中代表一个真正的请求，包含要发送的 消息；Stream 分为 ClientStream 和 ServerStream ClientStream ClientStream 接口继承 Stream 接口，有多个实现类或抽象实现类： ForwardingClientStream: 用于转发的 ClientStream，支持代理真正的流，可以用于触发一些动作，如统计等 NoopClientStream: 不做任何操作的 ClientStream，用于空实现
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

metabit

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值