多平台统一管理软件接口，如何实现多平台统一管理软件接口
313
2022-06-14
RPC系列之基本概念及go语言使用实现（go语言rpc框架）
1、基本使用
1.1、概念梳理
TPC/IP协议是传输层协议，主要解决数据如何在网络中传输，而HTTP是应用层协议，主要解决如何包装数据。
什么是RPC？
远程过程调用（Remote Procedure Call，缩写为 RPC）是一个计算机通信协议。该协议允许运行于一台计算机的程序调用另一台计算机的子程序，而程序员无需额外地为这个交互作用编程。如果涉及的软件采用面向对象编程，那么远程过程调用亦可称作远程调用或远程方法调用。
web3 和 http ， RPC 之间的关系。
HttpProvider should be used to send rpc calls over http
web3有两种Provider, 一种是HttpProvider, 一种是IpcProvider
web3是通过http, ws, 发送Rpc调用，然后把Rpc调用的结果通过http,或者WS返回回来。
RPC主要是基于TCP/IP协议，而http服务则是基于HTTP协议
RPC（即Remote Procedure Call，远程过程调用）和HTTP（HyperText Transfer Protocol，超文本传输协议）他们最本质的区别，就是RPC主要工作在TCP协议之上，而HTTP服务主要是工作在HTTP协议之上，我们都知道HTTP协议是在传输层协议TCP之上的，所以效率来看的话，RPC当然是要更胜一筹。
HTTP与RPC存在重大不同的是：请求是使用具有标准语义的通用的接口定向到资源的，这些语义能够被中间组件和提供服务的来源机器进行解释。结果是使得一个应用支持分层的转换（layers of transformation）和间接层（indirection），并且独立于消息的来源，这对于一个Internet规模、多个组织、无法控制的可伸缩性的信息系统来说，是非常有用的。与之相比较，RPC的机制是根据语言的API（language API）来定义的，而不是根据基于网络的应用来定义的。
调用远程机器上的一个过程（procedure）的观念，是RPC与其他形式的基于网络的应用通信的区别所在。
RPC(Remote Procedure Call，远程过程调用)是建立在Socket之上的,出于一种类比的愿望,在一台机器上运行的主程序,可以调用另一台机器上准备好的子程序,就像 LPC(本地过程调用).RPC带来了开发C/S程序的简单可靠的手段,它通过一种叫XDR的数据表达方法描述数据,程序员书写伪代码,然后由 rpcgen程序翻译为真正的可编译的C语言源代码,再编译成真正的Client端和Server端程序。
RPC是在Socket的基础上实现的,它比socket需要更多的网络和系统资源.另外,在对程序优化时,程序员虽然可以直接修改由rpcgen产生的令人费解的源程序,但对于追求程序设计高效率的RPC而言,获得的简单性则被大大削弱.
1.2、go 语言 RPC实现方式
1. net/rpc库
rpc.server
package main
import (
"net/rpc"
"net"
)
type HelloService struct {
}
func (this *HelloService) SayHello(req string, reply *string) error {
*reply = "hello:" + req
return nil
}
func main() {
rpc.RegisterName("HelloService", new(HelloService))
listerner, err := net.Listen("tcp", ":9900")
if err != nil {
panic(err)
}
for {
conn, err := listerner.Accept()
if err != nil {
panic(err)
}
rpc.ServeConn(conn)
}
}
rpc_client.go
package main
import "net/rpc"
func main() {
client, err := rpc.Dial("tcp", "localhost:9900")
if err != nil {
panic(err)
}
reply := ""
err = client.Call("HelloService.SayHello", "alice", &reply)
if err != nil {
panic(err)
}
println(reply)
}
2.net/rpc/jsonrpc库
rpc_server.go
package main
import (
"net"
"net/rpc"
"net/rpc/jsonrpc"
)
//注意字段必须是导出
type Params struct {
Width, Height int
}
type Rect struct{}
func (r *Rect) Area(p Params, ret *int) error {
*ret = p.Width * p.Height
return nil
}
func main() {
rect := new(Rect)
//注册rpc服务
rpc.Register(rect)
//监听端口
tcplisten, _ := net.Listen("tcp", ":8080")
for {
conn, err3 := tcplisten.Accept()
if err3 != nil {
continue
}
//这里使用jsonrpc进行处理
go rpc.ServeCodec(jsonrpc.NewServerCodec(conn))
//go jsonrpc.ServeConn(conn)
}
}
rpc_client.go
package main
import (
"fmt"
"log"
"net/rpc/jsonrpc"
)
//注意字段必须是导出
type Params1 struct {
Width, Height int
}
func main() {
//连接远程rpc服务
//这里使用jsonrpc.Dial
rpc, err := jsonrpc.Dial("tcp", "127.0.0.1:8080")
if err != nil {
log.Fatal(err)
}
ret := 0
//调用远程方法
//注意第三个参数是指针类型
err2 := rpc.Call("Rect.Area", Params1{50, 100}, &ret)
if err2 != nil {
log.Fatal(err2)
}
fmt.Println(ret)
}
3.http上的RPC
rpc_server.go
package main
import (
"net/rpc"
"net"
"log"
"net/http"
)
//自己的数据类
type MyMath struct{
}
//加法--只能两个参数--方法名第一个字母必须大写
func (mm *MyMath) Add(num map[string]int,reply *int) error {
*reply = num["num1"] + num["num2"]
return nil
}
func main() {
//注册MyMath类，以代客户端调用
rpc.Register(new(MyMath))
rpc.HandleHTTP()
l, e := net.Listen("tcp", ":1215")
if e != nil {
log.Fatal("listen error:", e)
}
http.Serve(l, nil)
}
rpc_client.go
package main
import (
"net/rpc"
"fmt"
"log"
)
func main() {
//连接服务
client, err := rpc.DialHTTP("tcp", "127.0.0.1:1215")
if err != nil {
log.Fatal("dialing:", err)
}
var reply int
var num = make(map[string]int)
num["num1"] = 3
num["num2"] = 2
//调用远程MyMath的Add方法,也只能是三个参数
err = client.Call("MyMath.Add",num,&reply)
if err != nil {
log.Fatal("arith error:", err)
}
//输出结果
fmt.Println(reply)
client.Close()
}
4.protobuf版rpc
proto文件
syntax = "proto3";
package pb;
// 算术运算请求结构
message ArithRequest {
int32 a = 1;
int32 b = 2;
}
// 算术运算响应结构
message ArithResponse {
int32 pro = 1; // 乘积
int32 quo = 2; // 商
int32 rem = 3; // 余数
}
// rpc方法
service ArithService {
rpc multiply (ArithRequest) returns (ArithResponse); // 乘法运算方法
rpc divide (ArithRequest) returns (ArithResponse); // 除法运算方法
}
rpc_server.go
package main
import (
"test/rpc/pb"
)
// 算术运算结构体
type Arith struct {
}
// 乘法运算方法
func (this *Arith) Multiply(req *pb.ArithRequest, res *pb.ArithResponse) error {
res.Pro = req.GetA() * req.GetB()
return nil
}
func main() {
pb.ListenAndServeArithService("tcp", "127.0.0.1:8097", new(Arith))
}
rpc_client.go
package main
import (
"fmt"
"log"
"test/rpc/pb"
)
func main() {
conn, err := pb.DialArithService("tcp", "127.0.0.1:8097")
if err != nil {
log.Fatalln("dailing error: ", err)
}
defer conn.Close()
req := &pb.ArithRequest{9, 2}
res, err := conn.Multiply(req)
if err != nil {
log.Fatalln("arith error: ", err)
}
fmt.Printf("%d * %d = %d\n", req.GetA(), req.GetB(), res.GetPro())
}
版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。
相关文章
发表评论
暂时没有评论，来抢沙发吧~