RPC

最新推荐文章于 2023-12-28 09:18:05 发布
最新推荐文章于 2023-12-28 09:18:05 发布
阅读量398 收藏
点赞数
分类专栏： go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43867700/article/details/105862996
版权

在这里插入图片描述
在这里插入图片描述
rpc调用基本流程，client将要调用的方法参数打包通过tcp网络发送给server，server接收到消息解包进行方法执行并将返回的结果打包返回给clent完成rpc调用，实质就是跨域调用（个人初步理解）
在这里插入图片描述
在这里插入图片描述
序列化：指的是将数据转化为字节编码的操作，例如json序列化
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
server

package main

import (
	"math"
	"net"
	"net/http"
	"net/rpc"
)

type MathUtil struct {
}

// 该方法向外暴露，提供计算圆形面积的服务
func (mu *MathUtil) CalculateCircleArea(req float32, resp *float32) error {
	// 圆形面积 s = n * r * r
	*resp = math.Pi * req * req
	return nil
}

func main() {
	// 初始化指针数据类型
	mathUtil := new(MathUtil)
	// 调用net/rpc包功能将服务对象进行注册 在默认服务中发布mathutil方法
	err := rpc.Register(mathUtil)
	if err != nil {
		panic(err.Error())
	}
	// 通过该函数把mathUtil中提供的服务注册到http协议上，方便调用者可以利用http的方式进行数据传递
	rpc.HandleHTTP()
	// 在本地起一个服务
	listen, err := net.Listen("tcp", ":8080")
	if err != nil {
		panic(err.Error())
	}
	http.Serve(listen, nil)
}

client

package main

import (
	"net/rpc"
	"fmt"
)
func main(){
	// 连接localhost:8080 端口服务，监听默认的http rpc 路径
	client,err := rpc.DialHTTP("tcp","localhost:8080")
	if err != nil{
		panic(err.Error())
	}
	var req float32
	req = 3
	var resp *float32
	// 同步调用方式
	// 通过Call方法调用rpc server在服务中发布的方法
	err = client.Call("MathUtil.CalculateCircleArea",req,&resp)
	if err != nil{
		panic(err.Error())
	}
	fmt.Println(*resp)
}

异步调用
client

package main

import (
	"net/rpc"
	"fmt"
)
func main(){
	// 连接localhost:8080 端口服务，监听默认的http rpc 路径
	client,err := rpc.DialHTTP("tcp","localhost:8080")
	if err != nil{
		panic(err.Error())
	}
	var req float32
	req = 3
	// 异步调用方法
	var respSync *float32
	// go方法返回一个指针类型的struct
	syncCall := client.Go("MathUtil.CalculateCircleArea",req,&respSync,nil)
	// Done是一个管道，里边存指针类型的call
	replayDone := <-syncCall.Done
	fmt.Println(replayDone)
	fmt.Println(*respSync)
}

在这里插入图片描述
在这里插入图片描述

rpc调用多参数传递

在这里插入图片描述

server

package main

import (
	"RPC/param"
	"net"
	"net/http"
	"net/rpc"
)

type MathUtil struct {
}

// 该方法向外暴露，提供计算圆形面积的服务
func (mu *MathUtil) Add(param param.AddParma, resp *float32) error {
	*resp = param.Args1 + param.Args2
	return nil
}

func main() {
	// 初始化指针数据类型
	mathUtil := new(MathUtil)
	// 调用net/rpc包功能将服务对象进行注册 在默认服务中发布mathutil方法
	err := rpc.RegisterName("MathUtil", mathUtil)
	if err != nil {
		panic(err.Error())
	}
	// 通过该函数把mathUtil中提供的服务注册到http协议上，方便调用者可以利用http的方式进行数据传递
	rpc.HandleHTTP()
	// 在本地起一个服务
	listen, err := net.Listen("tcp", ":8080")
	if err != nil {
		panic(err.Error())
	}
	http.Serve(listen, nil)
}

client

package main

import (
	"RPC/param"
	"fmt"
	"net/rpc"
)

func main() {
	// 连接localhost:8080 端口服务，监听默认的http rpc 路径
	client, err := rpc.DialHTTP("tcp", ":8080")
	if err != nil {
		panic(err.Error())
	}

	var result *float32

	addParma := &param.AddParma{Args1: 1.2, Args2: 2.3}
	err = client.Call("MathUtil.Add", addParma, &result)
	if err != nil {
		panic(err.Error())
	}
	fmt.Println("计算结果", *result)
}

addparam.go

package param

type AddParma struct {
	Args1 float32 // 第一个参数
	Args2 float32 // 第二个参数
}

protobuf和RPC结合使用

在这里插入图片描述

protobuf环境安装使用

点击查看protobuf环境安装

protobuf结合RPC使用

在这里插入图片描述
message.proto

syntax = "proto3";

package message;

message OrderRequest{
    string orderId = 1;
    int64 timeStamp = 2;
}

// 订单信息
message OrderInfo{
    string OrderId = 1;
    string OrderName = 2;
    string OrderStatus = 3;
}

message.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.22.0
// 	protoc        v3.11.4
// source: message.proto

package message

import (
	reflect "reflect"
	sync "sync"

	proto "github.com/golang/protobuf/proto"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
)

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)
)

// This is a compile-time assertion that a sufficiently up-to-date version
// of the legacy proto package is being used.
const _ = proto.ProtoPackageIsVersion4

// 生成struct
type OrderRequest struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	OrderId   string `protobuf:"bytes,1,opt,name=orderId,proto3" json:"orderId,omitempty"`
	TimeStamp int64  `protobuf:"varint,2,opt,name=timeStamp,proto3" json:"timeStamp,omitempty"`
}

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

// 结构体转为string类型
func (x *OrderRequest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*OrderRequest) ProtoMessage() {}

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

// 获取orderId
func (x *OrderRequest) GetOrderId() string {
	if x != nil {
		return x.OrderId
	}
	return ""
}

// 获取TimeStamp
func (x *OrderRequest) GetTimeStamp() int64 {
	if x != nil {
		return x.TimeStamp
	}
	return 0
}

// 订单信息
type OrderInfo struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

	OrderId     string `protobuf:"bytes,1,opt,name=OrderId,proto3" json:"OrderId,omitempty"`
	OrderName   string `protobuf:"bytes,2,opt,name=OrderName,proto3" json:"OrderName,omitempty"`
	OrderStatus string `protobuf:"bytes,3,opt,name=OrderStatus,proto3" json:"OrderStatus,omitempty"`
}

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

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

func (*OrderInfo) ProtoMessage() {}

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

func (x *OrderInfo) GetOrderId() string {
	if x != nil {
		return x.OrderId
	}
	return ""
}

func (x *OrderInfo) GetOrderName() string {
	if x != nil {
		return x.OrderName
	}
	return ""
}

func (x *OrderInfo) GetOrderStatus() string {
	if x != nil {
		return x.OrderStatus
	}
	return ""
}

var File_message_proto protoreflect.FileDescriptor

var file_message_proto_rawDesc = []byte{
	0x0a, 0x0d, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12,
	0x05, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x22, 0x46, 0x0a, 0x0c, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x52,
	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x49,
	0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x49, 0x64,
	0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x53, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x02, 0x20,
	0x01, 0x28, 0x03, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x53, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x65,
	0x0a, 0x09, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x18, 0x0a, 0x07, 0x4f,
	0x72, 0x64, 0x65, 0x72, 0x49, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x4f, 0x72,
	0x64, 0x65, 0x72, 0x49, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x4e, 0x61,
	0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x4e,
	0x61, 0x6d, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x53, 0x74, 0x61, 0x74,
	0x75, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x4f, 0x72, 0x64, 0x65, 0x72, 0x53,
	0x74, 0x61, 0x74, 0x75, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}

var (
	file_message_proto_rawDescOnce sync.Once
	file_message_proto_rawDescData = file_message_proto_rawDesc
)

func file_message_proto_rawDescGZIP() []byte {
	file_message_proto_rawDescOnce.Do(func() {
		file_message_proto_rawDescData = protoimpl.X.CompressGZIP(file_message_proto_rawDescData)
	})
	return file_message_proto_rawDescData
}

var file_message_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
var file_message_proto_goTypes = []interface{}{
	(*OrderRequest)(nil), // 0: param.OrderRequest
	(*OrderInfo)(nil),    // 1: param.OrderInfo
}
var file_message_proto_depIdxs = []int32{
	0, // [0:0] is the sub-list for method output_type
	0, // [0:0] 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_message_proto_init() }
func file_message_proto_init() {
	if File_message_proto != nil {
		return
	}
	if !protoimpl.UnsafeEnabled {
		file_message_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*OrderRequest); i {
			case 0:
				return &v.state
			case 1:
				return &v.sizeCache
			case 2:
				return &v.unknownFields
			default:
				return nil
			}
		}
		file_message_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
			switch v := v.(*OrderInfo); 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_message_proto_rawDesc,
			NumEnums:      0,
			NumMessages:   2,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_message_proto_goTypes,
		DependencyIndexes: file_message_proto_depIdxs,
		MessageInfos:      file_message_proto_msgTypes,
	}.Build()
	File_message_proto = out.File
	file_message_proto_rawDesc = nil
	file_message_proto_goTypes = nil
	file_message_proto_depIdxs = nil
}

client.go

package main

import (
	"fmt"
	"net/rpc"
	"object/RPC/message"
	"time"
)

func main() {
	// 连接localhost:8080 端口服务，监听默认的http rpc 路径
	client, err := rpc.DialHTTP("tcp", ":8080")
	if err != nil {
		panic(err.Error())
	}

	timeStamp := time.Now().Unix()

	request := message.OrderRequest{OrderId: "202005060001", TimeStamp: timeStamp}

	var response message.OrderInfo
	err = client.Call("OrderService.GetOrderInfo", request, &response)
	if err != nil {
		panic(err.Error())
	}
	fmt.Println(response)
}

server.go

package main

import (
	"errors"
	"net"
	"net/http"
	"net/rpc"
	"object/RPC/message"
	"time"
)

type OrderService struct {
}

// 该方法向外暴露
func (os *OrderService) GetOrderInfo(request message.OrderRequest, response *message.OrderInfo) error {
	orderMap := map[string]message.OrderInfo{
		"202005060001": message.OrderInfo{OrderId: "202005060001", OrderName: "衣服", OrderStatus: "已付款"},
		"202005060002": message.OrderInfo{OrderId: "202005060002", OrderName: "零食", OrderStatus: "已付款"},
		"202005060003": message.OrderInfo{OrderId: "202005060003", OrderName: "日用品", OrderStatus: "未付款"},
	}

	current := time.Now().Unix()
	if request.TimeStamp > current {
		*response = message.OrderInfo{OrderId: "0", OrderName: "", OrderStatus: "订单状态异常"}
	} else {
		result := orderMap[request.OrderId]
		if result.OrderId != "" {
			*response = orderMap[request.OrderId]
		} else {
			return errors.New("server error")
		}
	}
	return nil
}

func main() {
	// 初始化指针数据类型
	orderService := new(OrderService)
	// 调用net/rpc包功能将服务对象进行注册 在默认服务中发布mathutil方法
	err := rpc.Register(orderService)
	if err != nil {
		panic(err.Error())
	}
	// 通过该函数把mathUtil中提供的服务注册到http协议上，方便调用者可以利用http的方式进行数据传递
	rpc.HandleHTTP()
	// 在本地起一个服务
	listen, err := net.Listen("tcp", ":8080")
	if err != nil {
		panic(err.Error())
	}
	http.Serve(listen, nil)
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
![在这里插入图片描述](https://img-blog.csdnimg.cn/20200507162126214.png
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
生成兼容grpc框架的proto文件

protoc --go_out=plugins=grpc:. message.proto

在这里插入图片描述

一条金枪鱼
关注
专栏目录
protoreflect库介绍
csdner_lv的博客
04-25 2053
文章目录简介使用方式包内的重要类型ParserFileDescriptorMessageDescriptorFieldDescriptor例子demo1：打印出 proto 文件内所有的 messagedemo2：为 proto message 生成其对应的 json 形式 简介 它的作用正如它的名字，是一个用来反射proto文件的库。 仓库原地址：https://github.com/jhump/protoreflect 来自官方的介绍 This repo provides reflection API
探索 Protoreflect：强大的 Protocol Buffers 工具库
最新发布
gitblog_00030的博客
03-26 1032
探索 Protoreflect：强大的 Protocol Buffers 工具库 protoreflectReflection (Rich Descriptors) for Go Protocol Buffers项目地址:https://gitcode.com/gh_mirrors/pr/protoreflect 是一个由 JHUMP 团队开发的开源项目，旨在提供一个高效、灵活且易于使用的工具库...
【微服务系列】Protocol buffer和grpc动态解析
shanxiaoshuai的博客
06-02 1399
protobuf and grpc的动态解析
grpc-http-proxy：反向代理服务器，它基于protoreflect将JSON HTTP请求转换为gRPC调用
02-03
grpc-http-proxy :warning_selector: 这还没准备好生产 grpc-http-proxy是一个反向代理，无需太多配置即可将JSON HTTP请求转换为gRPC调用。 它旨在在Kubernetes集群中运行，并使用Kubernetes API使用自定义Kubernetes批注查找提供所需gRPC服务的集群内服务器。 背景 尽管现有解决方案（例如 ）会生成将JSON HTTP请求转换为gRPC调用的反向代理，但它们需要以下各项才能起作用： 必须手动添加gRPC服务定义的自定义注释，以定义HTTP端点到gRPC方法的映射。 必须为每个gRPC服务生成反向代理。 随着gRPC服务定义的变大和创建更多服务，这将很快变得难以管理。 grpc-http-proxy被创建为单个反向代理，可与所有gRPC服务一起使用，而无需所有手动映射。 这使得通过HTTP请求访问gRPC服务的麻烦比以前更少了。 这个怎么运作 对grpc-http-proxy的端点/v1/<service>/<method>的请求将使代理调用<service> gRPC服务的<method>方
ONCRPC.rar_ONCRPC_code rpc_onc_onc rpc
09-21
这个"ONCRPC.rar_ONCRPC_code rpc_onc_onc rpc"文件包含的是关于ONC RPC协议的实现代码，主要针对的是JAVA平台，旨在实现不同编程语言之间的RPC调用。 在RPC（Remote Procedure Call）机制中，客户端可以透明地调用...
jsonrpc-frontend:前端应用程序发送 json-rpc 请求进行测试
05-24
JSON-RPC（JavaScript Object Notation Remote Procedure Call）是一种轻量级的远程过程调用协议，常用于客户端-服务器通信，特别是在Web应用中。它利用JSON作为数据交换格式，因为JSON易于阅读、编写，并且对机器...
oncrpc.rar_RPC. VC++_oncrpc windows_windows RPC_ycnian的博客
09-24
RPC（Remote Procedure Call）是一种分布式计算技术，允许一个程序在一台计算机上执行远程操作，就像它在本地执行一样。在Windows环境下，RPC是系统服务的重要组成部分，广泛用于进程间通信和系统组件之间的交互。本...
QtRO (分布式RPC)
05-11
QtRO（分布式RPC）是一种基于网络的远程过程调用（RPC）框架，它允许不同的应用程序在分布式环境中相互通信，仿佛它们是在同一台计算机上运行。RPC使得客户端可以通过调用远程服务器上的方法来执行功能，而无需关心...
jsonrpc-c-master 基于 json rpc 1.0 纯C开发的服务端代码和示例
03-27
JSON-RPC（JavaScript Object Notation Remote Procedure Call）是一种轻量级的远程过程调用协议，它使用JSON（JavaScript Object Notation）作为数据交换格式。基于JSON-RPC 1.0的C语言实现，如"jsonrpc-c-master...
protoreflect：Go协议缓冲区的反射（丰富的描述符）
02-03
协议缓冲区和gRPC反射 此为（简称“ protobufs”）和提供了反射API。 protobufs中反射的核心是。 描述符本身就是protobuf消息，它描述.proto源文件或其中的任何元素。 因此，描述符的集合可以描述protobuf类型的整个架构，包括RPC服务。 描述符：协议缓冲区的语言模型 import "github.com/jhump/protoreflect/desc" 本文的desc包介绍了Descriptor接口及其对应于每种描述符类型的实现。 这些新类型是围绕有效的智能包装 ，使他们更加有用，更容易使用。 您可以从文件描述符集（可以由protoc生成）构造描述符，还可以为链接到当前二进制文件的消息和服务加载描述符。 “链接消息和服务意味着什么？” 你可能会问。 这意味着您的二进制文件将导入由protoc生成的软件包。 从.proto源生成Go代码时，结果包.proto嵌入描述符信息。 desc软件包使您可以轻松提取那些嵌入式描述符。 描述符也可以直接从.proto源文件（使用protoparse子包）获取，也可以通过以编程方式构造它们（使用builde
Protobuf(二)[环境搭建-Golang]
weixin_42366378的博客
04-23 3254
protobuf-环境搭建-Golang支持
protobuf实例运行proto: cannot use m.ProtoMethods() (type *protoreflect.Message) as type *struct ...解决方案
Elemyin的博客
06-09 2464
项目中用到了 canal-go去监听mysql的binlog，在使用protobuf运行实例时报错 275…/…/…/gopath/src/google.golang.org/protobuf/proto/proto_methods.go:18:23: cannot use m.ProtoMethods() (type *protoreflect.Message) as type *struct { pragma.NoUnkeyedLiterals; Flags uint64; Size func(str
巧用 Protobuf 反射来优化代码，拒做 PB Boy
腾讯技术工程
11-26 2406
作者：iversonluo，腾讯 WXG 应用开发工程师有些后台同学将自己称为 SQL Boy，因为负责的业务主要是对数据库进行增删改查。经常和 Proto 打交道的同学，是不是也会叫自...
protoc生成xxx.pb.go后出现“google.golang.org/protobuf/reflect/protoreflect“导入不成功问题
微积冰
05-09 1635
protoc -I . 文件名.proto --go_out=plugins=grpc:. 通过以上命令生成"文件名.pb.go"后，"文件名.pb.go"里面出现下面两个包飘红： ------------------------------------------------------------------------------------------------------------------------ 首先： 找到你的GOPATH/src目录，新建google.gola...
protoc: does not implement protoreflect.ProtoMessage (missing ProtoReflect method)
qq_40531074的博客
05-19 4395
在学习protobuf做第一个小例子时出现如下错误： # command-line-arguments ./test_proto.go:23:29: cannot use test (type *Student) as type protoreflect.ProtoMessage in argument to marshaler.Marshal: *Student does not implement protoreflect.ProtoMessage (missing ProtoRefle
使用Go和gRPC构建通信协议：实例教程
Fly的博客
12-28 1156
gRPC相对于传统的HTTP有几个优势：性能：gRPC使用了高效的二进制协议（Protocol Buffers）和基于HTTP/2的传输协议。这使得gRPC具有更小的消息体积和更高的传输效率，从而提供更好的性能和更低的延迟。可扩展性：gRPC支持双向流、流式传输和连接复用等特性，使得它非常适合构建实时应用程序和大规模的分布式系统。它可以轻松处理大量的并发请求，而不会对服务器资源造成过大的负担。
GRPC的四种数据流以及案例
人工智能
07-03 920
1、简单模式（Simple RPC）2、服务端数据流模式（Server-side Streaming RPC）3、客户端数据流模式（Client-side Streaming RPC）4、双向数据流模式（Bidirectional Streaming RPC）如果对GRPC和protobuf不了解的话，可以参看一下文章：protobuf与grpc_天龙至尊的博客-CSDN博客这里介绍protobuf的工具的下载与使用，以及结合grpc进行微服务框架的编写！！！protoc的程序的下载链接如下：Release
gRPC学习之简单模式（第三十九天）
刘森林l的博客
04-20 2275
简单模式：简单模式只是使用参数和返回值作为服务器与客户端传递数据的方式 建立如下工程： 编写文件proto文件 syntax="proto3"; package Model; message execlResponse{ int32 sid=1; int32 age=2; string name=3; string telephone=4; stri...
RPC漏洞分析详解
"RPC漏洞分析，深入探讨了远程过程调用（RPC）协议中的安全漏洞问题，适合对漏洞分析和挖掘感兴趣的读者。本书由springer出版社出版，详细介绍了RPC协议的工作原理及其在网络应用中的安全风险。" RPC（远程过程调用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值