Golang RPC总结

最新推荐文章于 2023-02-21 14:37:42 发布
最新推荐文章于 2023-02-21 14:37:42 发布
阅读量440 收藏
点赞数
分类专栏： Golang 文章标签： go rpc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/elihe2011/article/details/110224421
版权

Golang RPC总结

1. RPC

  • 客户端(client): 服务调用的发起方
  • 客户端存根(client Stub):
    • 运行在客户端机器上
    • 存储调用服务器地址
    • 将客户端请求数据信息打包
    • 通过网络发给服务端存根程序
    • 接收服务端响应的数据包，解析后给客户端
  • 服务端(server): 服务提供者
  • 服务端存根(server Stub):
    • 存在与服务端机器上
    • 接收客户端Stub程序发送来请求消息数据包
    • 调用服务端的程序方法
    • 将结果打包成数据包发给客户端Stub程序

reflect_1

1.1 Go 语言实现 RPC

  • Golang 提供RPC标准包，支持开发 RPC 服务端和客户端，采用 gob 编码。
  • 支持三种请求方式：HTTP、TCP 和 JSONRPC
  • Golang RPC 函数必须特定的格式写法才能被远程调用，格式如下：
func (t *T) MethodName(argType T1, replyType *T2) error

T1 和 T2 必须能被 encoding/gob 包编码和解码

2. 简单实例

2.1 服务端

  • 新增rpc服务 func (p *HelloService) Hello(request string, reply *string) error{}
  • 注册rpc服务 rpc.Register(HelloService)
  • 开启服务监听 net.Listen("tcp", ":1234")
type HelloService struct{}

func (p *HelloService) Hello(request string, reply *string) error {
	*reply = "hello: " + request
	return nil
}

func main() {
	rpc.RegisterName("HelloService", new(HelloService))

	listener, err := net.Listen("tcp", ":1234")
	if err != nil {
		log.Fatal(err)
	}

	conn, err := listener.Accept()
	if err != nil {
		log.Fatal(err)
	}

	rpc.ServeConn(conn)
}

2.2 客户端

  • 连接rpc服务器 rpc.Dail("tcp", "localhost:1234")
  • 调用rpc服务 client.Call("HelloService.Hello", "chloe", &reply)
func main() {
	client, err := rpc.Dial("tcp", "localhost:1234")
	if err != nil {
		log.Fatal(err)
	}

	var reply string
	err = client.Call("HelloService.Hello", "chloe", &reply)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(reply)
}

3. 接口化拆分

// svc.go
const HelloServiceName = "HelloService"

// 服务端接口
type HelloServiceInterface interface {
	Hello(request string, reply *string) error
}

func RegisterHelloService(svc HelloServiceInterface) error {
	return rpc.RegisterName(HelloServiceName, svc)
}

// 客户端接口
type HelloServiceClient struct {
	*rpc.Client
}

var _ HelloServiceInterface = (*HelloServiceClient)(nil)

func DialHelloService(network, address string) (*HelloServiceClient, error) {
	client, err := rpc.Dial(network, address)
	if err != nil {
		return nil, err
	}

	return &HelloServiceClient{Client: client}, nil
}

func (p *HelloServiceClient) Hello(request string, reply *string) error {
	return p.Client.Call(HelloServiceName+".Hello", request, reply)
}

// server.go
type HelloService struct{}

func (p *HelloService) Hello(request string, reply *string) error {
	*reply = "hello: " + request
	return nil
}

func main() {
	RegisterHelloService(new(HelloService))

	listener, err := net.Listen("tcp", ":1234")
	if err != nil {
		log.Fatal(err)
	}

	for {
		conn, err := listener.Accept()
		if err != nil {
			log.Fatal(err)
		}

		go rpc.ServeConn(conn)
	}
}

// client.go
func main() {
	client, err := DialHelloService("tcp", "localhost:1234")
	if err != nil {
		log.Fatal(err)
	}

	var reply string
	err = client.Hello("chloe", &reply)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(reply)
}

4. 跨语言RPC

4.1 测试服务端

// server.go
func main() {
	rpc.RegisterName("HelloService", new(HelloService))

	listener, err := net.Listen("tcp", ":1234")
	if err != nil {
		log.Fatal(err)
	}

	for {
		conn, err := listener.Accept()
		if err != nil {
			log.Fatal(err)
		}

		//go rpc.ServeConn(conn)
		go rpc.ServeCodec(jsonrpc.NewServerCodec(conn))
	}
}

# 启动服务
$ go run server.go

# 测试服务
$ echo -e '{"method":"HelloService.Hello","params":["eli"],"id":0}' | nc localhost 1234
{"id":0,"result":"hello: eli","error":null}

4.2 测试客户端

// client.go
func main() {
	//client, err := rpc.Dial("tcp", "localhost:1234")
	conn, err := net.Dial("tcp", "localhost:1234")
	if err != nil {
		log.Fatal(err)
	}

	client := rpc.NewClientWithCodec(jsonrpc.NewClientCodec(conn))

	var reply string
	err = client.Call("HelloService.Hello", "chloe", &reply)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(reply)
}

# 启动1234端口
$ nc -l 1234

# 客户端发起请求
$ go run client.go

# nc服务收到请求
{"method":"HelloService.Hello","params":["chloe"],"id":0}

5. RPC over HTTP

// server.go
func main() {
	rpc.RegisterName("HelloService", new(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)
}

 $ curl localhost:1234/jsonrpc -X POST \
 --data '{"method":"HelloService.Hello","params":["sara"],"id":1}'
 {"id":1,"result":"hello: sara","error":null}

6. 实战示例

6.1 基于RPC实现Watch功能

// server.go
type KVStoreService struct {
	m      map[string]string
	filter map[string]func(key string)
	mu     sync.Mutex
}

func NewKVStoreService() *KVStoreService {
	return &KVStoreService{
		m:      make(map[string]string),
		filter: make(map[string]func(key string)),
	}
}

func (p *KVStoreService) Get(key string, value *string) error {
	p.mu.Lock()
	defer p.mu.Unlock()

	if v, ok := p.m[key]; ok {
		*value = v
		return nil
	}

	return errors.New("not found")
}

func (p *KVStoreService) Set(kv [2]string, reply *struct{}) error {
	p.mu.Lock()
	defer p.mu.Unlock()

	key, value := kv[0], kv[1]

	if oldValue := p.m[key]; oldValue != value {
		for _, fn := range p.filter {
			fn(key)
		}
	}

	p.m[key] = value
	return nil
}

func (p *KVStoreService) Watch(timeoutSecond int, keyChanged *string) error {
	id := fmt.Sprintf("watch-%s-%03d", time.Now(), rand.Int())
	ch := make(chan string, 10) // buffered

	p.mu.Lock()
	p.filter[id] = func(key string) {
		ch <- key
	}
	p.mu.Unlock()

	select {
	case <-time.After(time.Duration(timeoutSecond) * time.Second):
		return fmt.Errorf("timeout")
	case key := <-ch:
		*keyChanged = key
		return nil
	}

	return nil
}

func main() {
	rpc.RegisterName("KVStoreService", NewKVStoreService())

	listener, err := net.Listen("tcp", ":1234")
	if err != nil {
		log.Fatal(err)
	}

	for {
		conn, err := listener.Accept()
		if err != nil {
			log.Fatal(err)
		}

		rpc.ServeConn(conn)
	}
}

// client.go
func main() {
	client, err := rpc.Dial("tcp", "localhost:1234")
	if err != nil {
		log.Fatal(err)
	}

	doClientWork(client)
}

func doClientWork(client *rpc.Client) {
	go func() {
		var keyChanged string
		err := client.Call("KVStoreService.Watch", 30, &keyChanged)
		if err != nil {
			log.Fatal(err)
		}
		fmt.Println("watch:", keyChanged)
	}()

	err := client.Call(
		"KVStoreService.Set",
		[2]string{"abc", "abc-value-1"},
		new(struct{}),
	)
	if err != nil {
		log.Fatal(err)
	}

	time.Sleep(3 * time.Second)
}

6.2 反向RPC

服务端主动向客户端发起请求

// server.go
type HelloService struct{}

func (p *HelloService) Hello(request string, reply *string) error {
	*reply = "hello: " + request
	return nil
}

func main() {
	rpc.RegisterName("HelloService", new(HelloService))

	for {
		conn, _ := net.Dial("tcp", "localhost:1234")
		if conn == nil {
			time.Sleep(time.Second)
			continue
		}

		rpc.ServeConn(conn)
		conn.Close()
	}
}

// client.go
func main() {
	listener, err := net.Listen("tcp", ":1234")
	if err != nil {
		log.Fatal(err)
	}

	clientChan := make(chan *rpc.Client)

	go func() {
		for {
			conn, err := listener.Accept()
			if err != nil {
				log.Fatal(err)
			}

			clientChan <- rpc.NewClient(conn)
		}
	}()

	doClientWork(clientChan)
}

func doClientWork(clientChan <-chan *rpc.Client) {
	client := <-clientChan
	defer client.Close()

	var reply string
	err := client.Call("HelloService.Hello", "chloe", &reply)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(reply)
}

6.3 上下文信息

上下文支持为每个链接提供独立的RPC服务

// server.go
type HelloService struct {
	conn    net.Conn
	isLogin bool
}

func (p *HelloService) Login(request string, reply *string) error {
	if request != "admin:123456" {
		return fmt.Errorf("auth failed")
	}

	log.Info("Login ok")
	*reply = "login: ok"
	p.isLogin = true
	return nil
}

func (p *HelloService) Hello(request string, reply *string) error {
	if !p.isLogin {
		return fmt.Errorf("please login")
	}
	*reply = "hello: " + request + ", from " + p.conn.RemoteAddr().String()
	return nil
}

func main() {
	listener, err := net.Listen("tcp", ":1234")
	if err != nil {
		log.Fatal(err)
	}

	for {
		conn, err := listener.Accept()
		if err != nil {
			log.Fatal(err)
		}

		go func() {
			defer conn.Close()

			p := rpc.NewServer()
			p.Register(&HelloService{conn: conn})
			p.ServeConn(conn)
		}()
	}
}

// client.go
func main() {
	client, err := rpc.Dial("tcp", "localhost:1234")
	if err != nil {
		log.Fatal(err)
	}

	var reply string

	err = client.Call("HelloService.Login", "admin:123456", &reply)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(reply)

	err = client.Call("HelloService.Hello", "chloe", &reply)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(reply)
}
elihe2011
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
golang两种调用rpc的方法
09-21
总结一下，Golang中的RPC调用主要有两种方式：一种是使用默认的RPC服务器并结合HTTP，另一种是创建自定义的RPC服务器。这两种方法都允许客户端通过网络调用远程服务的方法，但自定义服务器提供了更多的灵活性，例如...
rpc-golang：在Golang中使用RPC来体验不同的库
02-10
在Golang中，RPC的实现非常简单且高效，这是因为Go语言内置了对RPC的支持。本文将深入探讨如何在Golang中使用RPC以及相关的库，以便更好地理解和应用这一强大的技术。 ### Go语言中的RPC基础 Go的`net/rpc`包提供...
Go进阶(3)：上下文context
最新发布
黄规速博客:学如逆水行舟，不进则退
02-21 785
Context 也叫作“上下文”，是一个比较抽象的概念，一般理解为程序单元的一个运行状态、现场、快照。其中上下是指存在上下层的传递，上会把内容传递给下，程序单元则指的是 Goroutine。每个 Goroutine 在执行之前，都要先知道程序当前的执行状态，通常将这些执行状态封装在一个 Context 变量中，传递给要执行的 Goroutine 中。当一个goroutine在衍生一个goroutine时，context可以跟踪到子goroutine，从而达到控制他们的目的；
golang下的rpc框架jsonrpc理解和使用示例
kouryoushine的博客
04-05 3022
说明 本文的目的 理解一下rpc协议使用上的区别 golang下jsonrpc框架的使用 示例 定义RPC协议 import "github.com/pkg/errors" //定义一个叫做Demo的Rpc服务协议 //包含参数结构和2个不同的参数处理协议 // 返回值通过result指针获取，这点是由RPC服务来定义的 type DemoService struct { } //包含1： 参数的个数和类型 type Args struct { A, B int } //包含2: 参数的处理协议
【RPC】Golang的rpc体验
Jzin的博客
11-27 734
go快速体验rpc开发,替换rpc的序列化协议为json,替换rpc的传输协议为http,进一步改造rpc调用的代码
golang RPC简单使用
kanglujie的博客
08-15 241
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结学习目标：学习内容：学习时间：学习产出：前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重
Golang-RPC（二）：golang中的rpc实现之json-rpc
猛犸象
11-03 2185
因为内置net/rpc包接口设计的缺陷，我们无法使用jsonrpc等定制的编码作为rpc.DialHTTP的底层协议，如果需要让jsonrpc支持rpc.DialHTTP函数，需要调整rpc的接口。 除了传输协议，还有可以指定一个RPC编码协议，用于编码/解码RPC调用的函数参数和返回值，RPC调用不指定编码协议时，默认采用Go语言特有的gob编码协议。 因为，, 其他语言一般都不支持Go语言的gob协议，因此如果需要跨语言RPC调用就需要采用通用的编码协议。 Go的标准库还提供了一个"net/rpc/js
jsonrpc:通过websocket的jsonrpc用于golang和打字稿
03-11
在本文中，我们将深入探讨如何在Golang（Go语言）和TypeScript环境中利用WebSocket实现JSON-RPC通信。 ### JSON-RPC简介 JSON-RPC允许客户端通过发送请求到服务器来调用服务端的方法，并等待响应。它支持单向调用...
golang写的grpc实例demo
10-25
总结一下，gRPC结合了Golang的强大性能和protobuf的高效序列化能力，提供了现代微服务架构中的理想解决方案。通过阅读、理解和运行"demo_grpc"，你可以掌握gRPC服务的创建、实现和调用，从而提升你的Golang编程和...
Go实现简易RPC框架的方法步骤
09-19
总结，构建一个简易的Go RPC框架，主要涉及服务端的函数映射和调用、客户端的函数调用代理、数据传输格式的设计以及反射技术的运用。这个过程既展示了Go语言的强类型特性，也体现了其在处理网络通信时的灵活性。
【微服务】RPC和HTTP
王大阳的博客
08-06 4982
文章目录RPCRPC工作模式gRPCgRPC的特性与优缺点1.基于HTTP/22.IDL使用ProtoBuf3.多语言支持HTTP和RPC的优缺点Go语言中的RPC支持与处理grpcprotobuffer 为什么高效Protocol buffers 反序列化 RPC RPC(Remote ProcedureCall，远程过程调用) 是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络细节的应用程序通信协议。 RPC协议假定某些传输协议的存在，如TCP或UDP，为通信程序之间携带信息数据。在OS
Go RPC
tianyi520jx的博客
10-22 254
Socketa编程序列化(json/xml/…)
var _ HelloServiceInterface = (*HelloServiceClient)(nil)的特殊含义
sinat_40292249的博客
11-29 1170
1.     (*HelloServiceClient)(nil) var _ HelloServiceInterface = (*HelloServiceClient)(nil) 创建一个HelloServiceInterface地址，但不会分配内存的,并且如果给字段赋值会报错。 ...
线上golang grpc服务资源泄露问题排查
liyunlonghere
04-02 4566
前几天告警群里报出一个go服务grpc接口出现很多超时现象，排查发现是服务有内存泄露与cpu占用高的问题，在这里将排查的过程记录一下，给大家提供排查问题的方向与思路，同时借鉴教训，优化自己服务代码。 发现超时现象后，登录机器看了下top，该服务总共有两台机器，发现02机器的cpu与内存占用很高（如下图第一个进程），而01机器都很低。 正常情况下不会有这么高的资源占用，可能是服务有资源泄露的问题，资...
Go语言学习之下划线_作用分析
CharlesYan的博客
12-26 845
主要记录golang中下划线的作用
Golang RPC初体验
ALakers的博客
11-25 193
本篇转自：https://zhuanlan.zhihu.com/p/183231254 请大家尊重原创 RPC概念：      在分布式计算，远程过程调用（英语：Remote Procedure Call，缩写为 RPC）是一个计算机通信协议。该协议允许运行于一台计算机的程序调用另一个地址空间（通常为一个开放网络的一台计算机）的子程序，而程序员就像调用本地程序一样，无需额外地为这个交互作用编程（无需关注细节）。RPC 是一种服务器-客户端（ Client/.
GO RPC 远程过程调用
ndzjx的专栏
11-18 163
/rpcintf/intf.go package rpcintf import "net/rpc" // 代码可以自动生成，通过protoc，插件可以自己写 // Server // ServerName const HelloServiceName = "path/to/pkg.HelloService" // Function list type HelloServiceInterface = interface { Hello(request string, reply *string)
"Golang初级笔记及常用命令总结
初级golang个人笔记 初级golang的学习者可以通过一些常用命令来快速地了解和使用golang编程语言。在终端中输入go help可以显示所有的go命令以及相应的功能简介。主要的命令包括build、clean、doc、env、bug、fix、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值