标签：3.2 param 就是 2.0 自己实现 使用 adb rem .net
其他专栏最新篇：协程加强之~兼容答疑篇 | 聊聊数据库~SQL环境篇
上篇回顾：万物互联之~深入篇
Code：https://github.com/lotapp/BaseCode/tree/master/python/6.net/6.rpc/
RPC(Remote Procedure Call)：分布式系统常见的一种通信方法（远程过程调用），通俗讲：可以一台计算机的程序调用另一台计算机的子程序（可以把它看成之前我们说的进程间通信，只不过这一次的进程不在同一台PC上了）
PS：RPC的设计思想是力图使远程调用中的通讯细节对于使用者透明，调用双方无需关心网络通讯的具体实现
引用一张网上的图:
和HTTP有点相似，你可以这样理解：
HTTP/1.0是短链接，而RPC是长连接进行通信
HTTP/1.1支持了长连接(Connection:keep-alive)，基本上和RPC差不多了
keep-alive一般都限制有最长时间，或者最多处理的请求数，而RPC是基于长连接的，基本上没有这个限制HTTP/2.0建立了gRPC，它们之间的基本上也就差不多了
HTTP-普通话和RPC-方言的区别了RPC和HTTP调用不用经过中间件，而是端到端的直接数据交互
Socket实现的（RPC、HTTP都是Socket的读写操作）简单概括一下RPC的优缺点就是：
PS：HTTP更多是Client与Server的通讯;RPC更多是内部服务器间的通讯
上面说这么多，可能还没有来个案例实在，我们看个案例：
本地调用sum()：
def sum(a, b):
"""return a+b"""
return a + b
def main():
result = sum(1, 2)
print(f"1+2={result}")
if __name__ == "__main__":
main()输出：（这个大家都知道）
1+2=3官方文档：
https://docs.python.org/3/library/xmlrpc.client.html
https://docs.python.org/3/library/xmlrpc.server.html都说RPC用起来就像本地调用一样，那么用起来啥样呢？看个案例：
服务端：(CentOS7：192.168.36.123:50051)
from xmlrpc.server import SimpleXMLRPCServer
def sum(a, b):
"""return a+b"""
return a + b
# PS：50051是gRPC默认端口
server = SimpleXMLRPCServer(('', 50051))
# 把函数注册到RPC服务器中
server.register_function(sum)
print("Server启动ing，Port：50051")
server.serve_forever()客户端：（Win10：192.168.36.144）
from xmlrpc.client import ServerProxy
stub = ServerProxy("http://192.168.36.123:50051")
result = stub.sum(1, 2)
print(f"1+2={result}")输出：（Client用起来是不是和本地差不多？就是通过代理访问了下RPCServer而已）
1+2=3
PS：CentOS服务器不是你绑定个端口就一定能访问的，如果不能记让防火墙开放对应的端口
这个之前在说MariaDB环境的时候有详细说：https://www.cnblogs.com/dotnetcrazy/p/9887708.html#_map4
# 添加 --permanent永久生效(没有此参数重启后失效)
firewall-cmd --zone=public --add-port=80/tcp --permanentzeroRPC用起来和这个差不多，也简单举个例子吧：
把服务的某个方法注册到RPCServer中，供外部服务调用
import zerorpc
class Test(object):
def say_hi(self, name):
return f"Hi，My Name is{name}"
# 注册一个Test的实例
server = zerorpc.Server(Test())
server.bind("tcp://0.0.0.0:50051")
server.run()调用服务端代码：
import zerorpc
client = zerorpc.Client("tcp://192.168.36.123:50051")
result = client.say_hi("RPC")
print(result)看了上面的引入案例，是不是感觉RPC不过如此？NoNoNo，要是真这么简单也就谈不上RPC架构了，上面两个是最简单的RPC服务了，可以这么说：生产环境基本上用不到，只能当案例练习罢了，对Python来说，最常用的RPC就两个gRPC and Thrift
PS：国产最出名的是Dubbo and Tars，Net最常用的是gRPC、Thrift、Surging
要自己实现一个RPC Server那么就得了解整个流程了：
Client（调用者）以本地调用的方式发起调用RPC服务进行远程过程调用（RPC的目标就是要把这些步骤都封装起来，让使用者感觉不到这个过程）
RPC Proxy组件收到调用后，负责将被调用的方法名、参数等打包编码成自定义的协议RPC Proxy组件在打包完成后通过网络把数据包发送给RPC ServerRPC Proxy组件把通过网络接收到的数据包按照相应格式进行拆包解码，获取方法名和参数RPC Proxy组件根据方法名和参数进行本地调用RPC Server（被调用者）本地执行后将结果返回给服务端的RPC ProxyRPC Proxy组件将返回值打包编码成自定义的协议数据包，并通过网络发送给客户端的RPC Proxy组件RPC Proxy组件收到数据包后，进行拆包解码，把数据返回给ClientClient（调用者）得到本次RPC调用的返回结果用一张时序图来描述下整个过程：
PS：RPC Proxy有时候也叫Stub（存根）：(Client Stub，Server Stub)
为屏蔽客户调用远程主机上的对象，必须提供某种方式来模拟本地对象,这种本地对象称为存根(stub),存根负责接收本地方法调用,并将它们委派给各自的具体实现对象
PRC服务实现的过程中其实就两核心点：
Protocol BuffersTCP/UDP/HTTP）下面我们就根据上面的流程来手写一个简单的RPC：
1.Client调用：
# client.py
from client_stub import ClientStub
def main():
stub = ClientStub(("192.168.36.144", 50051))
result = stub.get("sum", (1, 2))
print(f"1+2={result}")
result = stub.get("sum", (1.1, 2))
print(f"1.1+2={result}")
time_str = stub.get("get_time")
print(time_str)
if __name__ == "__main__":
main()输出:
1+2=3
1.1+2.2=3.1
Wed Jan 16 222.Client Stub，客户端存根：(主要有打包、解包、和RPC服务器通信的方法)
# client_stub.py
import socket
class ClientStub(object):
def __init__(self, address):
"""address ==> (ip,port)"""
self.socket = socket.socket()
self.socket.connect(address)
def convert(self, obj):
"""根据类型转换成对应的类型编号"""
if isinstance(obj, int):
return 1
if isinstance(obj, float):
return 2
if isinstance(obj, str):
return 3
def pack(self, func, args):
"""打包：把方法和参数拼接成自定义的协议
格式：func:函数名@params:类型-参数,类型2-参数2...
"""
result = f"func:{func}"
if args:
params = ""
# params:类型-参数,类型2-参数2...
for item in args:
params += f"{self.convert(item)}-{item},"
# 去除最后一个,
result += f"@params:{params[:-1]}"
# print(result) # log 输出
return result.encode("utf-8")
def unpack(self, data):
"""解包：获取返回结果"""
msg = data.decode("utf-8")
# 格式应该是"data:xxxx"
params = msg.split(":")
if len(params) > 1:
return params[1]
return None
def get(self, func, args=None):
"""1.客户端的RPC Proxy组件收到调用后，负责将被调用的方法名、参数等打包编码成自定义的协议"""
data = self.pack(func, args)
# 2.客户端的RPC Proxy组件在打包完成后通过网络把数据包发送给RPC Server
self.socket.send(data)
# 等待服务端返回结果
data = self.socket.recv(2048)
if data:
return self.unpack(data)
return None简要说明下：（我根据流程在Code里面标注了，看起来应该很轻松）
之前有说到核心其实就是消息协议and传输控制，我客户端存根的消息协议是自定义的格式（后面会说简化方案）：func:函数名@params:类型-参数,类型2-参数2...，传输我是基于TCP进行了简单的封装
3.Server端：（实现很简单）
# server.py
import socket
from server_stub import ServerStub
class RPCServer(object):
def __init__(self, address, mycode):
self.mycode = mycode
# 服务端存根（RPC Proxy）
self.server_stub = ServerStub(mycode)
# TCP Socket
self.socket = socket.socket()
# 端口复用
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 绑定端口
self.socket.bind(address)
def run(self):
self.socket.listen()
while True:
# 等待客户端连接
client_socket, client_addr = self.socket.accept()
print(f"来自{client_addr}的请求：\n")
# 交给服务端存根（Server Proxy）处理
self.server_stub.handle(client_socket, client_addr)
if __name__ == "__main__":
from server_code import MyCode
server = RPCServer(('', 50051), MyCode())
print("Server启动ing，Port：50051")
server.run()为了简洁，服务端代码我单独放在了server_code.py中：
# 5.RPC Server（被调用者）本地执行后将结果返回给服务端的RPC Proxy
class MyCode(object):
def sum(self, a, b):
return a + b
def get_time(self):
import time
return time.ctime()4.然后再看看重头戏Server Stub:
# server_stub.py
import socket
class ServerStub(object):
def __init__(self, mycode):
self.mycode = mycode
def convert(self, num, obj):
"""根据类型编号转换类型"""
if num == "1":
obj = int(obj)
if num == "2":
obj = float(obj)
if num == "3":
obj = str(obj)
return obj
def unpack(self, data):
"""3.服务端的RPC Proxy组件把通过网络接收到的数据包按照相应格式进行拆包解码，获取方法名和参数"""
msg = data.decode("utf-8")
# 格式应该是"格式：func:函数名@params:类型编号-参数,类型编号2-参数2..."
array = msg.split("@")
func = array[0].split(":")[1]
if len(array) > 1:
args = list()
for item in array[1].split(":")[1].split(","):
temps = item.split("-")
# 类型转换
args.append(self.convert(temps[0], temps[1]))
return (func, tuple(args)) # (func,args)
return (func, )
def pack(self, result):
"""打包：把方法和参数拼接成自定义的协议"""
# 格式："data:返回值"
return f"data:{result}".encode("utf-8")
def exec(self, func, args=None):
"""4.服务端的RPC Proxy组件根据方法名和参数进行本地调用"""
# 如果没有这个方法则返回None
func = getattr(self.mycode, func, None)
if args:
return func(*args) # 解包
else:
return func() # 无参函数
def handle(self, client_socket, client_addr):
while True:
# 获取客户端发送的数据包
data = client_socket.recv(2048)
if data:
try:
data = self.unpack(data) # 解包
if len(data) == 1:
data = self.exec(data[0]) # 执行无参函数
elif len(data) > 1:
data = self.exec(data[0], data[1]) # 执行带参函数
else:
data = "RPC Server Error Code:500"
except Exception as ex:
data = "RPC Server Function Error"
print(ex)
# 6.服务端的RPC Proxy组件将返回值打包编码成自定义的协议数据包，并通过网络发送给客户端的RPC Proxy组件
data = self.pack(data) # 把函数执行结果按指定协议打包
# 把处理过的数据发送给客户端
client_socket.send(data)
else:
print(f"客户端：{client_addr}已断开\n")
break再简要说明一下：里面方法其实主要就是解包、执行函数、返回值打包
输出图示：
再贴一下上面的时序图：
课外拓展：
HTTP1.0、HTTP1.1 和 HTTP2.0 的区别
https://www.cnblogs.com/heluan/p/8620312.html
简述分布式RPC框架
https://blog.csdn.net/jamebing/article/details/79610994
分布式基础—RPC
http://www.dataguru.cn/article-14244-1.html下节预估：RPC服务进一步简化与演变、手写一个简单的REST接口
标签：3.2 param 就是 2.0 自己实现 使用 adb rem .net
原文地址：https://www.cnblogs.com/dunitian/p/10279946.html
