golang rpc

已于 2024-10-01 11:26:36 修改
阅读量498 收藏 7
点赞数 12
分类专栏： golang 文章标签： golang 开发语言 后端 tcp/ip 网络协议
于 2024-10-01 09:12:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44575660/article/details/142623386
版权

RPC（Remote Procedure Call）远程过程调用，简单的理解是一个节点请求另一个节点提供的服务，对应rpc的是本地过程调用，函数调用是最常用的本地过程调用，将本地过程调用变成远程调用会面临着各种问题。

以两数相加为例

package main

import "fmt"

func add(a, b int) int {
	return a + b
}
func main() {
	fmt.Println(add(1, 2))
}

函数调用过程：
（1）将1和2压入函数的栈中
（2）进入add函数，从栈中取出1和2分别赋值给a和b
（3）执行a+b将结果压栈
（4）将栈中的结果取出打印

远程过程面临的问题
1.原本的本地函数放到另外一个服务器上去运行，但是引入了很多新问题
2.Call的id映射
我们怎么告诉远程机器我们要调用add，而不是sub或者Foo呢？在本地调用中，函数体是直接通过函数指针来指定的，我们调用add，编译器就自动帮我们调用它相应的函数指针。但是在远程调用中，函数指针是不行的，因为两个进程的地址空间是完全不一样的。所以，在RPC中，所有的函数都必须有自己的一个ID。这个ID在所有进程中都是唯一确定的。客户端在做远程过程调用时，必须附上这个ID。然后我们还需要在客户端和服务端分别维护一个（函数＜–>Call ID｝的对应表。两者的表不一定需要完全相同，但相同的函数对应的Call ID必须相同。当客户端需要进行远程调用时，它就查一下这个表，找出相应的Call ID，然后把它传给服务端，服务端也通过查表，来确定客户端需要调用的函数，然后执行相应函数的代码。
3.序列化和反序列化
客户端怎么把参数值传给远程的函数呢？在本地调用中，我们只需要把参数压到栈里，然后让函数自己去栈里读就行。但是在远程过程调用时，客户端跟服务端是不同的进程，不能通过内存来传递参数。甚至有时候客户端和服务端使用的都不是同一种语言（比如服务端用C++，客户端用Java或者Python）。这时候就需要客户端把参数先转成一个字节流，传给服务端后，再把字节流转成自己能读取的格式。这个过程叫序列化和反序列化。同理，从服务端返回的值也需要序列化反序列化的过程。
4.网络传输
远程调用往往用在网络上，客户端和服务端是通过网络连接的。所有的数据都需要通过网络传输，因此就需要有一个网络传输层。网络传输层需要把Call ID和序列化后的参数字节流传给服务端，然后再把序列化后的调用结果传给客户端。只要能完成这两者的，都可以作为传输层使用。因此，他所使用的协议其实是不限的，能完成传输就行，尽管大部分RPC框架都使用TCP协议，但其实UDP也可以，而RPC干脆就用了HTTP2。Java的Netty也属于这层的东西。

RPC第一个要点：数据编码协议

一般采用将数据传输到gin，gin传输到服务端，服务端负责解析数据
客户端流程

	1.建立连接tcp/http
	2.将employee对象序列化成json字符串-序列化
	3.发送json字符串-调用成功后实际上你接受到的是一个二进制的数据
	4.等待服务器发送结果
	5将服务返回的数据解析成PrintResult对象-反序列化

服务端流程

	1.监听网络接口80
	2.读取数据-二进制的json数据
	3.对数据进行反序列化Employee对象
	4.开始处理业务逻辑
	5.将处理的结果PrintReuslt发序列化成json二进制数据-序列化
	6.将数据返回

序列化和反序列化是可以选择的，不一定要采用json、xml、protobuf、msgpack

RPC第二个要点：传输协议

http协议：http1.x http2.0协议
http协议底层使用的也是tcp，http现在主流的是http1.x，这种协议有性能问题（一次性），一旦结果返回，连接就断开。我们可以直接基于tcp/udp协议去封装一层协议myhttp，没有通用型，http2.0既有http的特性也有长连接的特性（grpc就是基于http2.0的）
http协议是文本协议，http底层的传输协议是tcp。grpc基于http2.0，传输协议也是tcp
在这里插入图片描述
http协议具有一次性的问题：一旦对方返回了结果，连接断开，http2.0通过长连接解决了这个问题。

基于Http Server实现rpc请求

server端

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"strconv"
)

func add(a, b int) int {
	return a + b
}

func main() {
	//get方法http://127.0.0.1:8000/add?a=1&b=2或http://127.0.0.1:8000?method=add&a=1&b=2
	//返回的格式化：json{"data":3}
	//1、callId的问题：r.URL.Path，2、数据的传输协议：url的参数传输协议，3、网络传输协议：http
	http.HandleFunc("/add", func(w http.ResponseWriter, r *http.Request) {
		err := r.ParseForm() //解析参数
		if err != nil {
			panic("error")
		}
		fmt.Println("path:", r.URL.Path)
		a, err := strconv.Atoi(r.Form["a"][0])
		if err != nil {
			panic("transform error")
		}
		b, err := strconv.Atoi(r.Form["b"][0])
		if err != nil {
			panic("transform error")
		}
		w.Header().Set("Content-Type", "application/json")
		jData, err := json.Marshal(map[string]int{
			"data": a + b,
		})
		w.Write(jData)
	})
	_ = http.ListenAndServe(":8000", nil)
}

在这里插入图片描述
缺点：http1.x，麻烦，性能不高
客户端：

package main

import (
	"encoding/json"
	"fmt"
	"time"

	"github.com/kirinlabs/HttpRequest"
)

type ResponseData struct {
	Data int `json:"data"`
}

func Add(a, b int) int {
	req := HttpRequest.NewRequest()
	res, _ := req.Get(fmt.Sprintf("http://127.0.0.1:8000/%s?a=%d&b=%d", "add", a, b))
	body, _ := res.Body()
	rspData := ResponseData{}
	_ = json.Unmarshal(body, &rspData)
	return rspData.Data
}
func main() {
	fmt.Println(Add(2, 2))
}

这里遇到了一个Get “http://127.0.0.1:8000/add?a=1&b=2”: context deadline exceeded (Client.Timeout exceeded while awaiting headers)的问题，主要是客户端默认网络请求时间太短
修改之后

package main

import (
	"encoding/json"
	"fmt"
	"time"

	"github.com/kirinlabs/HttpRequest"
)

type ResponseData struct {
	Data int `json:"data"`
}

func Add(a, b int) int {
	req := HttpRequest.NewRequest()
	req.SetTimeout(10 * time.Second)
	res, _ := req.Get(fmt.Sprintf("http://127.0.0.1:8000/%s?a=%d&b=%d", "add", a, b))
	body, _ := res.Body()
	rspData := ResponseData{}
	_ = json.Unmarshal(body, &rspData)
	return rspData.Data
}
func main() {
	fmt.Println(Add(2, 2))
}

rpc开发的要素分析

RPC技术在架构设计上有四部分组成，分别是：客户端、客户端存根、服务端、服务端存根。
客户端(Client)：服务调用发起方，也称为服务消费者。
客户端存根(Client Stub)：该程序运行在客户端所在的计算机机器上，主要用来存储要调用的服务器的地址，另外，该程序还负责将客户端请求远端服务器程序的数据信息打包成数据包，通过网络发送给服务端Stub程序；其次，还要接收服务端Stub程序发送的调用结果数据包，并解析返回给客户端。
服务端(Server):远端的计算机机器上运行的程序，其中有客户端要调用的方法。
服务端存根(Server Stub)：接收客户Stub程序通过网络发送的请求消息数据包，并调用服务端中真正的程序功能方法，完成功能调用；其次，将服务端执行调用的结果进行数据处理打包发送给客户端Stub程序。

rpc需要使用到的术语

1、动态代理技术： 上文中我们提到的Client Stub和Sever Stub程序，在具体的编码和开发实践过程中，都是使用动态代理技术自动生成的一段程序。
序列化和反序列化： 在RPC调用的过程中，我们可以看到数据需要在一台机器上传输到另外一台机器上。在互联网上，所有的数据都是以字节的形式进行传输的。而我们在编程的过程中，往往都是使用数据对象，因此想要在网络上将数据对象和相关变量进行传输，就需要对数据对象做序列化和反序列化的操作。
序列化：把对象转换为字节序列的过程称为对象的序列化，也就是编码的过程。
反序列化：把字节序列恢复为对象的过程称为对象的反序列化，也就是解码的过程。
我们常见的Json,XML等相关框架都可以对数据做序列化和反序列化编解码操作。后面我们要学习的Protobuf协议，这也是一种数据编解码的协议，在RPC框架中使用的更广泛。

简单的rpc实例

服务端

package main

import (
	"net"
	"net/rpc"
)

type HelloService struct {
}

func (s *HelloService) Hello(request string, reply *string) error {
	//返回值是通过修改reply的值
	*reply = "hello, " + request
	return nil
}
func main() {
	//rpc快速开发体验
	//1.实例化一个server
	listener, _ := net.Listen("tcp", ":1234")
	//2.注册处理逻辑
	_ = rpc.RegisterName("HelloService", &HelloService{})
	//3.启动服务
	conn, _ := listener.Accept() //当一个新的连接进来的时候
	rpc.ServeConn(conn)
}

客户端

package main

import (
	"encoding/json"
	"fmt"
	"net/rpc"
	"time"
)

func main() {

	//1.建立连接
	client, err := rpc.Dial("tcp", "localhost:1234")
	if err != nil {
		panic("连接失败")
	}
	var reply *string = new(string)
	err = client.Call("HelloService.Hello", "bobby", reply)
	if err != nil {
		panic("调用失败")
	}
	fmt.Println(*reply)
}

替换rpc的序列化协议为json

序列化协议为json，各种语言都可以调用服务端的内容
服务端

package main

import (
	"net"
	"net/rpc"
	"net/rpc/jsonrpc"
)

type HelloService struct {
}

func (s *HelloService) Hello(request string, reply *string) error {
	//返回值是通过修改reply的值
	*reply = "hello, " + request
	return nil
}
func main() {
	//替换rpc的序列化协议为json
	//1.实例化一个server
	listener, _ := net.Listen("tcp", ":1234")
	//2.注册处理逻辑
	_ = rpc.RegisterName("HelloService", &HelloService{})
	//3.启动服务
	conn, _ := listener.Accept() //当一个新的连接进来的时候
	rpc.ServeCodec(jsonrpc.NewServerCodec(conn))

}

客户端

package main

import (
	"encoding/json"
	"fmt"
	"net"
	"net/rpc"
	"net/rpc/jsonrpc"
	"time"

	"github.com/kirinlabs/HttpRequest"
)

func main() {
	//替换rpc的序列化协议为json
	//1.建立连接
	conn, err := net.Dial("tcp", "localhost:1234")
	if err != nil {
		panic("连接失败")
	}
	var reply *string = new(string)
	client := rpc.NewClientWithCodec(jsonrpc.NewClientCodec(conn))
	err = client.Call("HelloService.Hello", "bobby", reply)
	if err != nil {
		panic("调用失败")
	}
	fmt.Println(*reply)
}

python连接rpc，序列化协议为json

服务端

package main

import (
	"net"
	"net/rpc"
	"net/rpc/jsonrpc"
)

type HelloService struct {
}

func (s *HelloService) Hello(request string, reply *string) error {
	//返回值是通过修改reply的值
	*reply = "hello, " + request
	return nil
}
func main() {
	//替换rpc的序列化协议为json
	//1.实例化一个server
	listener, _ := net.Listen("tcp", ":1234")
	//2.注册处理逻辑
	_ = rpc.RegisterName("HelloService", &HelloService{})
	//3.启动服务
	conn, _ := listener.Accept() //当一个新的连接进来的时候
	rpc.ServeCodec(jsonrpc.NewServerCodec(conn))

}

客户端

import json
import socket
request={
    "id":0,
    "params":["bobby"],
    "method":"HelloService.Hello"
}
client=socket.create_connection(("localhost",1234))
client.sendall(json.dumps(request).encode())
#获取服务器返回的数据
rsp=client.recv(4096)
rsp=json.loads(rsp.decode())
print(rsp)

替换rpc的传输协议为http

服务端

package main

import (
	"io"
	"net/http"
	"net/rpc"
	"net/rpc/jsonrpc"
)
type HelloService struct {
}

func (s *HelloService) Hello(request string, reply *string) error {
	//返回值是通过修改reply的值
	*reply = "hello, " + request
	return nil
}
func main() {
	//替换rpc的序列化协议为http
	//2.注册处理逻辑
	_ = rpc.RegisterName("HelloService", &HelloService{})
	http.HandleFunc("/jsonrpc", func(w http.ResponseWriter, r *http.Request) {
		var conn io.ReadWriteCloser = struct {
			io.Writer
			io.ReadCloser
		}{
			ReadCloser: r.Body,
			Writer:     w,
		}
		rpc.ServeRequest(jsonrpc.NewServerCodec(conn))
	})
	http.ListenAndServe(":1234", nil)
}

客户端

import requests
request={
    "id":0,
    "params":["bobby"],
    "method":"HelloService.Hello"
}
rsp=requests.post("http://localhost:1234/jsonrpc",json=request)
print(rsp.text)

客户端

package main

import (
	"encoding/json"
	"fmt"
	"net/rpc"
	"time"

	"github.com/kirinlabs/HttpRequest"
)

func main() {
	//1.实例化一个
	client, err := rpc.Dial("tcp", "127.0.0.1:1234")
	if err != nil {
		panic("连接失败")
	}
	var reply string
	err = client.Call("HelloService.Hello", "bobby", &reply)
	if err != nil {
		// panic("调用失败")
		fmt.Println(err)
	}
	fmt.Println(reply)
}

代理封装

代理类

package handler

import "net/rpc"

const HelloServiceName = "HelloServiceName"

type HelloServiceStub struct {
	*rpc.Client
}

func NewHelloServiceClient(protcol, address string) HelloServiceStub {
	conn, err := rpc.Dial(protcol, address)
	if err != nil {
		panic("connect error!")
	}
	return HelloServiceStub{conn}
}
func (c *HelloServiceStub) Hello(request string, reply *string) error {
	err := c.Call(HelloServiceName+".Hello", request, reply)
	if err != nil {
		return err
	}
	return nil
}

type HelloService struct {
}

func (s *HelloService) Hello(request string, reply *string) error {
	//返回值是通过修改reply的值
	*reply = "hello, " + request
	return nil
}

func RegisterHelloService() error {
	return rpc.RegisterName(HelloServiceName, &HelloService{})
}

服务端

package main

import (
	"TEMP/handler"
	"net"
	"net/rpc"
)

func main() {
	//进一步改造rpc调用的代码
	//1.实例化一个server
	listener, _ := net.Listen("tcp", ":1234")
	//2.注册处理逻辑handler
	_ = handler.RegisterHelloService()
	//3.启动服务
	conn, _ := listener.Accept() //当一个新的连接进来的时候
	rpc.ServeConn(conn)

}

客户端

package main

import (
	"TEMP/handler"
	"fmt"
)

func main() {
	//进一步改造rpc调用的代码
	//1.实例化一个
	client := handler.NewHelloServiceClient("tcp", "127.0.0.1:1234")
	var reply string
	err := client.Hello("bobby", &reply)
	if err != nil {
		// panic("调用失败")
		fmt.Println(err)
	}
	fmt.Println(reply)
}

解耦合

将服务端的Hello函数传递变换成接口类型
代理类

package handler

import "net/rpc"

const HelloServiceName = "HelloServiceName"

type HelloServiceStub struct {
	*rpc.Client
}

func NewHelloServiceClient(protcol, address string) HelloServiceStub {
	conn, err := rpc.Dial(protcol, address)
	if err != nil {
		panic("connect error!")
	}
	return HelloServiceStub{conn}
}
func (c *HelloServiceStub) Hello(request string, reply *string) error {
	err := c.Call(HelloServiceName+".Hello", request, reply)
	if err != nil {
		return err
	}
	return nil
}

type NewHelloService struct {
}
type HelloServicer interface {
	Hello(request string, reply *string) error
}

func (s *NewHelloService) Hello(request string, reply *string) error {
	//返回值是通过修改reply的值
	*reply = "hello, " + request
	return nil
}

func RegisterHelloService() error {
	return rpc.RegisterName(HelloServiceName, &NewHelloService{})
}

服务端

package main

import (
	"TEMP/handler"
	"net"
	"net/rpc"
)

func main() {
	//进一步改造rpc调用的代码
	//1.实例化一个server
	listener, _ := net.Listen("tcp", ":1234")
	//2.注册处理逻辑handler
	_ = handler.RegisterHelloService()
	//3.启动服务
	conn, _ := listener.Accept() //当一个新的连接进来的时候
	rpc.ServeConn(conn)

}

客户端

package main

import (
	"TEMP/handler"
	"fmt"
)

func main() {
	//进一步改造rpc调用的代码
	//1.实例化一个
	client := handler.NewHelloServiceClient("tcp", "127.0.0.1:1234")
	var reply string
	err := client.Hello("bobby", &reply)
	if err != nil {
		// panic("调用失败")
		fmt.Println(err)
	}
	fmt.Println(reply)
}
虽千万人 吾往矣
关注
专栏目录
stack:Golang RPC开发框架
03-19
service := stack.NewService(stack.Name("stack.rpc.greeter")) service.Init() service.Run() } 我们封装了微服务内部在的复杂度，某些服务注册与发现，配置管理等。用户只需要花极小的成本学习如何暴露接口，...
stack-rpc：Golang RPC开发框架
02-04
堆栈RPC Stack-RPC领先为中国开发者提供通用的分布式服务微服务开发库（如配置管理，服务发现，熔断降级，路由，服务代理，安全，主从选举等）。基于Stack，开发者可以快速堆栈适用于中小规模的开发场景，她可以轻易...
twisk：具有Twirp的Golang RPC入门套件
02-05
Twisk-Golang RPC入门套件 Twisk是的入门工具包-一种强调简单性和简约性的服务到服务通信框架。 它包含启动项目所需的一切-结构化打包，日志记录，自动生成的swagger文档，用于登录/刷新的处理程序以及用户CRUD。 ...
gorpc:一个为大型分布式系统设计的golang rpc框架
03-11
戈尔普一个为大型分布式系统设计的golang rpc框架运行gorpc测试go test -v github.com/johntech-o/gorpc 上面的命令将在测试输出的末尾显示性能信息client conn status: {"Result":{"127.0.0.1:6668":{"creating":0,...
golang两种调用rpc的方法
09-21
在Golang中，远程过程调用（Remote Procedure Call, RPC）是一种常见的进程间通信机制，允许客户端通过网络调用远程服务器上的函数或方法。这里主要介绍两种在Golang中调用RPC的方法。 第一种方法是使用`rpc....
golang学习笔记17-切片
技术卷的博客
09-25 353
切片的定义，与数组的区别，切片的三种创建方式，两种遍历方式，还有一些细节
GO语言中make与new的区别
lisus2007的专栏
09-25 295
new 可以为任何类型的值开辟内存并返回此值的指针new申请的值均为零值，对创建映射和切处没有意义实际工作中通常使用字面量来创建数组而很少使用new。
Golang | Leetcode Golang题解之第445题两数相加II
weixin_66442839的博客
09-29 341
Golang | Leetcode Golang题解之第445题两数相加II
golang学习笔记26-管道（Channel）【重要】
技术卷的博客
09-28 823
本节也是GO核心部分，很重要。介绍了管道的读数据，写数据，关闭，遍历操作，协程和管道如何协同工作，管道的只读/只写声明，select多路复用，for监听管道。
golang小项目1-家庭收支记账系统
最新发布
技术卷的博客
09-30 745
用面向对象的方式实现基于命令行界面的《家庭收支记账系统》，该软件能实现注册、登录、记录家庭的收入与支出、打印收支明细表、转账、注销、修改密码等功能。其中收支明细表显示所有交易记录，一条交易记录由交易类型（收入/支出）、用户余额（交易后）、交易金额、备注组成。所有数据都存在本地的 TXT 文件中，软件要实现对文件数据的读和写。
【Golang】Go语言中type关键字到底是什么？
景天科技苑
09-26 5399
在Go语言中，`type`关键字是构建自定义数据类型和声明新类型的基础。通过`type`，我们可以定义类型别名、结构体、接口、函数类型等多种数据类型，这些自定义类型极大地增强了Go语言的灵活性和表达能力。本文将结合实际案例，详细探讨`type`在Go语言中的多种用法。
golang实现getRegion获取ip所属地区的函数
GoppViper的博客
09-27 404
这个函数接受一个 IP 地址作为参数，使用ip2region库查询并返回该 IP 地址对应的地区信息。注意，代码中的ip2region.xdb文件需要你自行下载或者从其他途径获取，并确保在运行代码时该文件能够被正确读取到。首先，确保安装了github.com/lionsoul2014/ip2region/binding/golang/xdb库。希望本文对你有所帮助！如果你有任何问题或建议，欢迎在评论区留言。你可以使用以下方式调用这个函数。
go 安装三方库
weixin_40548182的博客
09-25 424
【代码】go 安装三方库。
Go基础学习07-map注意事项；多协程对map的资源竞争；sync.Mutex避免竟态条件
FLJS_T的博客
09-27 845
思考一：Go语言的map的键类型为什么不能是相信学习过其他语言比如Java语言的朋友对于Java中的HashMap都比较熟悉，对于所有键值对元素的数据结构来说，存储过程先计算key的哈希值，随后使用哈希值定位到对应的bucket，将key和value作为元素存储到对应的bucket中。在这个过程中可能会发生，在Java中对于哈希碰撞常见的解决方案有，由于哈希碰撞的存在对于哈希表的键的要求，不仅仅能够计算哈希值，同时能够对键进行判等操作（解决哈希碰撞时key重复的问题）。。
互联网前后端分离的开发场景，一般会员和数据权限的判断是放在前端还是后端？
GoppViper的博客
09-30 544
在互联网前后端分离的开发场景中，一般将会员和数据权限的判断放在后端。希望本文对你有所帮助！如果你有任何问题或建议，欢迎在评论区留言。
【Golang】Go语言中如何面向对象?
景天科技苑
09-25 6137
Go语言（Golang）虽然不是一个纯粹的面向对象编程语言，但它通过结构体（Struct）、接口（Interface）等机制，提供了面向对象的编程范式。 在实际的项目开发中，使用面向对象的理念可以显著提高代码的可维护性、可扩展性和可复用性。
Go语言接口与多态
hai40587的博客
09-27 1103
Go语言通过接口和匿名组合提供了类似面向对象编程中的多态性。接口定义了一组方法的契约，而不同类型的实例只要实现了这些方法，就可以被当作接口类型的变量来使用，从而实现多态性。在实际开发中，我们应该充分利用接口和多态性的优势，遵循最佳实践，编写出高质量的Go语言程序。通过接口和多态性，我们可以实现代码的灵活性、可扩展性和可维护性，从而提高开发效率和代码质量。
Goland无法使用debug的修复
渡江客涂鸦板
09-30 256
查看其他博客说是当使用老版本的goland，golang版本为高版本时就会出现debug问题，需要手动更换dlv。原文链接：https://blog.csdn.net/qq_42961251/article/details/138633170/现象goland在debug的时候，一直卡在打的断点处，释放断点程序就执行结束。用everything搜索dlv.exe。找到goland应用按照这个地址去替换。找到刚才下载好的dlv。可以debug了，完美。
golang reflect
weixin_39289004的博客
09-25 508
Go 的reflect包提供了强大的功能，可以在运行时处理类型和变量。尽管反射很有用，但应谨慎使用，因为它可能会影响性能，并且代码的可读性可能降低。通常情况下，尽量使用静态类型和接口来保持代码的清晰和高效。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值