GoLong的学习之路，进阶，微服务之原理，RPC

已于 2023-12-01 17:18:32 修改
阅读量1.1k 收藏 22
点赞数 24
分类专栏： GoLong 文章标签： 学习 微服务 rpc golang 架构 rabbitmq
于 2023-12-01 17:18:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cheer_RIO/article/details/134734444
版权

其实我早就很想写这篇文章了，RPC是一切现代计算机应用中非常重要的思想。也是微服务和分布式的总体设计思想。只能说是非常中要，远的不说，就说进的这个是面试必问的。不管用的上不，但是就是非常重要。

文章目录

RPC的原理

RPC（Remote Procedure Call Protocol）远程过程调用协议。一个通俗的描述是：客户端在不知道调用细节的情况下，调用存在于远程计算机上的某个对象，就像调用本地应用程序中的对象一样。

一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。

（这里我做一个解释：是不是有人会将这个与TCP等传输协议放在一起比较，而我想说这么比较是对的。这里献上一篇文章–tcp、http、rpc和grpc总结，但是要注意，这其中的区别）

不过这里我做一个强调，这篇文章必须将这些协议弄清楚了，才能看，他不是雪中送碳，而是锦上添花。

RPC是一种服务器-客户端（Client/Server）模式，经典实现是一个通过发送请求-接受回应进行信息交互的系统。

首先与RPC（远程调用）相对应的是本地调用。

本地调用

先看一个go文件

package main

import "fmt"

func add(x, y int)int{
	return x + y
}

func main(){
	// 调用本地函数add
	a := 10
	b := 20
	ret := add(a, x)
	fmt.Println(ret)
}

在程序中本地调用add函数的执行流程，可以理解为以下四个步骤。

  1. 将变量 a 和 b 的值分别压入堆栈上
  2. 执行 add 函数，从堆栈中获取 a 和 b 的值，并将它们分配给x和 y
  3. 计算 x + y 的值并将其保存到堆栈中
  4. 退出 add 函数并将x + y的值赋给 ret

在这里插入图片描述

定义add函数的代码和调用add函数的代码共享同一个内存空间，所以调用能够正常执行

但是我们无法直接在另一个程序——中调用add函数，因为它们是两个程序——内存空间是相互隔离的。（两个进程不共享内存）

(两个程序可能在一个主机上，也可能在不同的主机上)

在这里插入图片描述

所以RPC就诞生了

RPC就是为了解决类似远程、跨内存空间、的函数或者方法调用的

RPC调用

为什么要用RPC ？

如果我们开发简单的单一应用，逻辑简单、用户不多、流量不大，那我们用不着。

当我们的系统访问量增大、业务增多时，我们会发现一台单机运行此系统已经无法承受。此时，我们可以将业务拆分成几个互不关联的应用，分别部署在各自机器上，以划清逻辑并减小压力。

此时，我们也可以不需要RPC，因为应用之间是互不关联的。

当我们的业务越来越多、应用也越来越多时，自然的，我们会发现有些功能已经不能简单划分开来或者划分不出来。

此时，可以将公共业务逻辑抽离出来，将之组成独立的服务Service应用 。而原有的、新增的应用都可以与那些独立的Service应用 交互，以此来完成完整的业务功能。

所以此时，我们急需一种高效的应用程序之间的通讯手段来完成这种需求.

描述的场景也是服务化 、微服务和分布式系统架构的基础场景。

要实现RPC就需要解决以下三个问题：

  1. 如何确定要执行的函数？

    • 在本地调用中，函数主体通过函数指针函数指定，然后调用 add 函数，编译器通过函数指针函数自动确定 add 函数在内存中的位置。
    • 在 RPC 中，调用不能通过函数指针完成，因为它们的内存地址可能完全不同。因此，调用方和被调用方都需要维护一个{ function <-> ID }映射表，以确保调用正确的函数

  2. 如何表达参数？

    • 本地过程调用中传递的参数是通过堆栈内存结构实现的，但 RPC 不能直接使用内存传递参数，因此参数或返回值需要在传输期间序列化并转换成字节流，反之亦然。

  3. 如何进行网络传输？

    • 函数的调用方和被调用方通常是通过网络连接的，也就是说，function ID 和序列化字节流需要通过网络传输，因此，只要能够完成传输，调用方和被调用方就不受某个网络协议的限制。.
    • 例如，一些 RPC 框架使用 TCP 协议，一些使用 HTTP

以往实现跨服务调用的时候，我们会采用RESTful API的方式，被调用方会对外提供一个HTTP接口，调用方按要求发起HTTP请求并接收API接口返回的响应数据。

server服务

// server/main.go

package main

import (
	"encoding/json"
	"io/ioutil"
	"log"
	"net/http"
)

type addParam struct {
	X int `json:"x"`
	Y int `json:"y"`
}

type addResult struct {
	Code int `json:"code"`
	Data int `json:"data"`
}

func add(x, y int) int {
	return x + y
}

func addHandler(w http.ResponseWriter, r *http.Request) {
	// 解析参数
	b, _ := ioutil.ReadAll(r.Body)
	var param addParam
	json.Unmarshal(b, &param)
	// 业务逻辑
	ret := add(param.X, param.Y)
	// 返回响应
	respBytes , _ := json.Marshal(addResult{Code: 0, Data: ret})
	w.Write(respBytes)
}

func main() {
	http.HandleFunc("/add", addHandler)
	log.Fatal(http.ListenAndServe(":9090", nil))
}

客户端来请求上述HTTP服务

// client/main.go

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
)

type addParam struct {
	X int `json:"x"`
	Y int `json:"y"`
}

type addResult struct {
	Code int `json:"code"`
	Data int `json:"data"`
}

func main() {
	// 通过HTTP请求调用其他服务器上的add服务
	url := "http://127.0.0.1:9090/add"
	param := addParam{
		X: 10,
		Y: 20,
	}
	paramBytes, _ := json.Marshal(param)
	resp, _ := http.Post(url, "application/json", bytes.NewReader(paramBytes))
	defer resp.Body.Close()

	respBytes, _ := ioutil.ReadAll(resp.Body)
	var respData addResult
	json.Unmarshal(respBytes, &respData)
	fmt.Println(respData.Data) // 30
}

这中交互模式，应该是非常常见了。

这种模式是我们目前比较常见的跨服务或跨语言之间基于RESTful API的服务调用模式。

既然使用API调用也能实现类似远程调用的目的，为什么还要用RPC呢？

使用 RPC 的目的是让我们调用远程方法像调用本地方法一样无差别

并且基于RESTful API通常是基于HTTP协议，传输数据采用JSON等文本协议，相较于RPC 直接使用TCP协议，传输数据多采用二进制协议来说，RPC通常相比RESTful API性能会更好。(在我的rabbitMQ文章中有体现)

RESTful API多用于前后端之间的数据传输，而目前微服务架构下各个微服务之间多采用RPC调用

使用场景

  1. 服务化/微服务
  2. 分布式系统架构
  3. 服务可重用
  4. 系统间交互调用

总结一下：

  1. 内部子系统较多 ：
    • 众多的内部子系统是驱动采用RPC架构的原因之一，订单系统，支付系统，商品系统，用户系统…， 每个可独立单独布署。 RPC主要使用在大型企业内部子系统之间的调用。
    • 基于HTTP协议的接口，包括Webservice等主要作为对外接口服务。
  2. 接口访问量巨大：
    • 要求满足支持 “负载均衡”，“熔断降级” 一类面向服务的高级特性
  3. 接口非常多：
    • 服务发现

RPC原理

在这里插入图片描述

  1. 服务调用方（client）以本地调用方式调用服务
  2. client stub接收到调用后负责将方法、参数等组装成能够进行网络传输的消息体，
  3. client stub找到服务地址，并将消息发送到服务端
  4. server端接收到消息
  5. server stub收到消息后进行解码
  6. server stub根据解码结果调用本地的服务
  7. 本地服务执行并将结果返回给server stub
  8. server stub将返回结果打包成能够进行网络传输的消息体
  9. 按地址将消息发送至调用方
  10. client 端接收到消息
  11. client stub收到消息并进行解码
  12. 调用方得到最终结果

使用RPC框架的目标是只需要关心第1步和第12步，中间的其他步骤统统封装起来，让使用者无需关心。

例如社区中各式RPC框架（grpc、thrift等）就是为了让RPC调用更方便。

RPC的目标就是要2~8这些步骤都封装起来，让用户对这些细节透明。

如何做到透明化（封装）远程服务调用

怎么封装通信细节才能让用户像以本地调用方式调用远程服务呢？

这部分有点像我用java实现的MQ一样。

就是定义一个结构体。

如果我们需要从A调用B的方法，那么意味着B需要A传来的参数和方法名等，然后通过反射来解析。

所以我们就可以这么做。

能看到这里的人相信对如何设置数据结构已经了熟与心了，所以就不写代码了。(用web实现数据结构的肯定没少做这个事)

如果还是不知道。可以看我的这篇文章，并找到创建请求和响应协议参数这一节，当然看完也可。

对消息进行编码和解码

客户端的请求消息结构一般需要包括以下内容：

  • 接口名称：在我们的例子里接口名是“HelloWorldService”，如果不传，服务端就不知道调用哪个接口了；
  • 方法名：一个接口内可能有很多方法，如果不传方法名服务端也就不知道调用哪个方法；
  • 参数类型和参数值：参数类型有很多，比如有 bool、int、long、double、string、map、list，甚至如struct等，以及相应的参数值；
  • 超时时间 + requestID（标识唯一请求id）

服务端返回的消息结构一般包括以下内容：

  • 状态code
  • 返回值
  • requestID

一旦确定了消息的数据结构后，下一步就是要考虑序列化与反序列化了。

序列化

什么是序列化？

  • 序列化就是将数据结构或对象转换成二进制串的过程，也就是编码的过程。

什么是反序列化？

  • 将在序列化过程中所生成的二进制串转换成数据结构或者对象的过程。

为什么需要序列化？

  • 转换为二进制串后才好进行网络传输(快)

为什么需要反序列化？

  • 将二进制转换为对象才好进行后续处理(方便)

现如今序列化的方案越来越多，每种序列化方案都有优点和缺点，它们在设计之初有自己独特的应用场景，那到底选择哪种呢？

从RPC的角度上看，主要看三点：

  • 通用性：比如是否能支持Map等复杂的数据结构；
  • 性能：包括时间复杂度和空间复杂度，由于RPC框架将会被公司几乎所有服务使用，如果序列化上能节约一点时间，对整个公司的收益都将非常可观，同理如果序列化上能节约一点内存，网络带宽也能省下不少
  • 可扩展性：对互联网公司而言，业务变化飞快，如果序列化协议具有良好的可扩展性，支持自动增加新的业务字段，而不影响老的服务，这将大大提供系统的灵活度。

目前互联网公司广泛使用Protobuf、Thrift、Avro等成熟的序列化解决方案来搭建RPC框架，这些都是久经考验的解决方案。

这里就不介绍了。

如果想要知道如何创建，搭建一个框架的，个人建议可以去这里，极客兔兔的文章。

下一章介绍如何使用go中的RPC的包

红蒲公英
关注
  • 24
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
如何系统的学习golang(附学习资料)
wxkongkong的博客
10-31 317
针对go的学习，不同阶段采用的方式是不一样的。本文把go的学习分为入门、实战、进阶三个阶段。下面分开来说。
golang 微服务之gRPC与Protobuf的使用
12-20
RPC是什么？ 所谓RPC(remote procedure call 远程过程调用)框架实际是提供了一套机制，使得应用程序之间可以进行通信，而且也遵从server/client模型。使用的时候客户端调用server端提供的接口就像是调用本地的函数...
GoLong的学习之路，进阶，微服务之使用，RPC包（包括源码分析）
Cheer_RIO的博客
12-10 1190
对象重用。Request和Response都是可重用的，通过Lock处理竞争。这在大并发的情况下很有效。使用了大量的goroutine。如果使用一定数量的goroutine作为worker池去处理这个case，可能还会有些性能的提升，但是更复杂了。使用goroutine可以获得了非常好的性能。业务处理是异步的，服务的执行不会阻塞其它消息的读取。一个codec实例必然和一个相关，因为它需要从connection中读取request和发送response。go的rpc官方库的消息(request和。
GoLong的学习之路，进阶，微服务之序列化协议，Protocol Buffers V3
Cheer_RIO的博客
12-11 1154
这章是接上一章，使用RPC包，序列化中没有详细去讲，因为这一块需要看的和学习的地方很多。并且这一块是RPC中可以说是最重要的一块，也是性能的重要影响因子。今天这篇主要会讲其使用方式。当对象需要跨进程、跨语言、跨节点传输、持久化、状态读写、复制时，都需要进行序列化，其性能和易用性影响运行效率和开发效率。 但是对于序列化框架而言，业内将其分为两类：静态序列化框架，动态序列化框架。
2021年后端学习路线书籍-自我进阶之路
我是阿沐的博客
06-06 904
最近也有不少小伙伴们在公众号发消息问我，如何去学好一门后端语言？怎么才能进阶？在公司如何才能快速的晋级晋升？你作为一个后端是如何学习的呢？ 其实我正儿八经的工作也就 4 年多了，但是如果算上大三实习大四工作的话满打满算大概 5 年之久。你会发现自己工作 3 年以后再到 5 年可能会觉得自己学不到东西，很多东西从表面上看你会了，深入一点你基本就回答不上来而且脑海搜索不到任何的相关知识点。小伙伴们问的最多的是下面几个问题(不以语言论英雄)： - 我工作 1年 ，3年， 5年 进入了迷茫期，完全不知道自.
go中使用grpc之心得 - go微服务进阶之路
泡泡茶壶的博客
07-11 2461
文章目录前言编写proto 前言 上次发文章是什么时候的事儿了，笔者懒癌又发作了。最近这段时间公司进行项目重构，主要是从python往go方面迁移。理由是python项目在目前的web服务中遭遇了一些瓶颈，包括： 代码规范混乱（写python的都知道，一个人就是一个风格） 系统运行性能低下（这倒不一定就是python 的锅） 语言老旧（原项目采用的是python2） 由于项目是本身是一个微服务的架构，各个服务件本身是通过rpc去调用。原项目本身使用的rpc框架是grpc，在新项目中，仍然继续选择grpc
golang进阶必知问题
海豹姥爷的博客
08-26 274
总之，GMP 模型是 Go 语言并发编程的核心，通过轻量级的 Goroutines 和通信机制 Channels，以及调度器的协调管理，使得并发编程在 Go 中变得更加简单和高效。在 Go 语言中，"本地队列"和"全局队列"通常指的是调度器（Scheduler）中的工作队列，用于管理待执行的 Goroutine。这可以在短时间内减少锁的竞争，提高性能。使用普通的 map 数据结构时，如果需要在多个 Goroutine 中进行并发访问，通常需要使用 mutex 来保护 map 的读写操作，以避免并发问题。
项目实战：用Go构建微服务
m0_61568580的博客
02-17 2784
想必各位Gopher都知道Go的主要优势在于云原生、微服务、区块链、中间件上。这次冬奥会重点项目之一的“5G+4K/8K超高清云转播”就采用了“双中台+微服务”架构，实现转播设备云端化和人员服务远程化，从而降低转播门槛、缩减成本，敏捷部署，实现轻资产、专业级的转播服务。 Go微服务在国内发展得如火如荼，大量的互联网厂商也都逐步采用Go作为主力开发语言，往期分享的不少招聘也都点明需要微服务实战的经验要求。 说到这里，就不得不说一下gRPC框架了。gRPC是由Google公司开源一款开源RPC框架，引用官网
Go 语言进阶（一） -- Go hertz http框架、kitex RPC微服务框架、gorm 数据库框架三件套用法详解
yllblog的博客
03-02 666
hert、gorm、kitex框架用法指引
go 进阶 go-zero相关: 三. go-zero 微服务基础示例
qq_29799655的博客
05-10 1381
编译命令执行完毕后,会生成一下代码:其中 types/XXX/xxx.pb.go文件与types/XXX/xxx_grpc.pb.go是通过proto生成的,参考grpc“xxx.pb.go”: 内部是编写这个rpc服务时自定义的结构体相关处理“xxx_grpc.pb.go”: 内部是启动这个rpc服务端,启动访问这个rpc客户端的相关代码通过go-zero生成的其中user.proto是用来生成rpc服务的IDL文件。
golang基础到进阶系列教程学习
08-20
golang基础到进阶系列教程学习
Golang学习之平滑重启
09-20
主要介绍了Golang学习之平滑重启，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
TarsGo:Golang中的高性能微服务框架。 一个Linux基础项目
04-01
Tarsgo是使用tars协议的Golang编程语言中的高性能RPC框架。 随着容器化技术（例如docker，k8s和etcd）的兴起，Go在编程中变得很流行。 Go的goroutine并发机制意味着Go非常适合大规模的高并发后端服务器程序开发。 ...
FME学习之旅---day27
最新发布
summer_corner的博客
05-17 199
我们付出一些成本，时间的或者其他，最终总能收获一些什么。
使用多实例学习进行乳腺癌组织病理学图像分类和定位
qq_47896523的博客
05-16 1103
乳腺癌是女性最主要的死亡原因，病理学家根据病理切片中观察到的各种视觉特征（例如细胞核的形态特征、细胞核的微观和宏观结构等）做出决定。计算机辅助诊断（CAD）系统可以帮助病理学家自动做出决策。卷积神经网络是最广泛使用的深度学习框架，用于学习图像类别之间的复杂判别特征。多年来，VGG16 [3] 和 ResNet18 [4] 等各种 CNN 架构在海量 ImageNet 数据集上产生了出色的结果。CNN 被用于医学图像以产生最先进的结果。为图像中存在的所有类别提供了定位信息。
WEB转Flutter基础学习笔记（内含vue和flutter对比）
小易不止于搬砖的博客
05-17 675
笔者是一名web前端，记录在转栈flutter时的学习笔记，内涵和vue的对比，能够辅助前端同学更容易理解flutter
Page对象的学习
2301_77523055的博客
05-14 1005
ASP.NET允许开发者创建自定义控件和用户控件来扩展页面的功能。自定义控件是从现有的ASP.NET控件派生出来的新控件，而用户控件则是将多个控件组合成一个可重用的单元。这些控件可以像其他ASP.NET控件一样在页面上使用，并通过Page对象进行交互。Page_Init主要用于在控件加载之前进行初始化设置和添加事件处理程序。Page_Load主要用于处理页面回发和加载数据，以及执行其他需要在页面加载时完成的逻辑。由于Page_Init在Page_Load之前触发，因此在Page_Init。
学习kong官方文档
好好学习日记
05-17 275
当然，我会用更简洁的方式重新解释这两个概念：Helm和Kubectl是Kubernetes生态系统中常用的两个工具，它们各自有不同的用途：
golang语法进阶
08-19
很高兴回答你关于Golang语法进阶的问题！Golang是一门简洁高效的编程语言，下面我将分享一些Golang语法的进阶知识。 1. 嵌套结构体：在Golang中，你可以在一个结构体中嵌套另一个结构体。这样可以更好地组织和管理代码。例如： ```go type Person struct { Name string Age int } type Employee struct { Person Salary int } ``` 这里的Employee结构体嵌套了Person结构体，可以通过Employee结构体访问Person结构体的字段。 2. 接口和类型断言：Golang中的接口是一种约定，定义了一组方法。通过接口，你可以实现多态性。类型断言则用于检查接口变量是否实现了某个接口。例如： ```go type Shape interface { Area() float64 } type Circle struct { Radius float64 } func (c Circle) Area() float64 { return math.Pi * c.Radius * c.Radius } func main() { var shape Shape = Circle{Radius: 5} if circle, ok := shape.(Circle); ok { fmt.Println("Area of circle:", circle.Area()) } } ``` 3. 并发编程：Golang内置了并发编程的支持，通过goroutine和通道(channel)可以实现轻量级线程间通信。例如： ```go func worker(id int, jobs <-chan int, results chan<- int) { for j := range jobs { fmt.Println("Worker", id, "processing job", j) time.Sleep(time.Second) // 模拟耗时操作 results <- j * 2 } } func main() { jobs := make(chan int, 5) results := make(chan int, 5) // 启动三个goroutine for w := 1; w <= 3; w++ { go worker(w, jobs, results) } // 发送5个任务 for j := 1; j <= 5; j++ { jobs <- j } close(jobs) // 输出结果 for r := 1; r <= 5; r++ { fmt.Println(<-results) } } ``` 以上是Golang语法进阶的一些例子，希望对你有帮助！如果你有更多问题，欢迎继续提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值