• RPC之远程过程调用


    RPC之远程过程调用

    1、概念:

    ​ RPC(Remote Procedure Call)远程过程调用,简单的理解是一个节点请求另一个节点提供的服务

    2、RPC架构的作用

    RPC 的主要目标是让构建分布式计算(应用)更容易、透明,在提供强大的远程调用能力时不损失本地调用的语义简洁性。为实现该目标,RPC 框架需提供一种透明调用机制让使用者不必显式的区分本地调用和远程调用。RPC框架负责屏蔽底层的传输方式(TCP或者UDP)、序列化方式(XML/JSON/二进制)和通信细节。开发人员在使用的时候只需要了解谁在什么位置提供了什么样的远程服务接口即可,并不需要关心底层通信细节和调用过程。

    1、从通信协议的层面,大致可以分为:

    (1)基于HTTP协议的(例如基于文本的SOAP(XML)、REST(JSON)、基于二进制Hessian(Binary));
    (2)基于TCP协议的(通常会借助Mina、Netty等高性能网络框架)。

    2、只有二进制数据才能在网络中传输,序列化和反序列化的定义是:

    (1)将对象转换成二进制流的过程叫做序列化;
    (2)将二进制流转换成对象的过程叫做反序列化。

    3、 RPC架构分为三部分:

    (1)、服务提供者(RPC Server),运行在服务器端,提供服务接口定义与服务实现类。
    (2)、服务中心(Registry),运行在服务器端,负责将本地服务发布成远程服务,管理远程服务,提供给服务消费者使用。
    (3)、服务消费者(RPC Client),运行在客户端,通过远程代理对象调用远程服务。
    服务提供者启动后主动向服务(注册)中心注册机器ip、端口以及提供的服务列表; 服务消费者启动时向服务(注册)中心获取服务提供方地址列表,可实现软负载均衡和Failover。

    3、代码实现

    采用twisted可以编写最简单的rpc代码

    • server端代码如下

      from twisted.web import xmlrpc, server
      class Test(xmlrpc.XMLRPC):
      def xmlrpc_add(self, a, b):
      return a + b

      def xmlrpc_fault(self):
          raise xmlrpc.Fault(123, "The fault procedure is faulty.")
      

      if name == 'main':
      from twisted.internet import reactor
      r = Test()
      reactor.listenTCP(7080, server.Site(r))
      reactor.run()

    • client代码如下

    import xmlrpclib
    s = xmlrpclib.Server('http://localhost:7080/')
    print s.add(3, 4)
    

    4、python实现RPC

    利用RabbitMQ构建一个RPC系统,包含了客户端和RPC服务器,依旧使用pika模块

    Callback queue 回调队列

    一个客户端向服务器发送请求,服务器端处理请求后,将其处理结果保存在一个存储体中。而客户端为了获得处理结果,那么客户在向服务器发送请求时,同时发送一个回调队列地址reply_to

    Correlation id 关联标识

    一个客户端可能会发送多个请求给服务器,当服务器处理完后,客户端无法辨别在回调队列中的响应具体和那个请求时对应的。为了处理这种情况,客户端在发送每个请求时,同时会附带一个独有correlation_id属性,这样客户端在回调队列中根据correlation_id字段的值就可以分辨此响应属于哪个请求。

    客户端发送请求:某个应用将请求信息交给客户端,然后客户端发送RPC请求,在发送RPC请求到RPC请求队列时,客户端至少发送带有reply_to以及correlation_id两个属性的信息
    
    服务器端工作流: 等待接受客户端发来RPC请求,当请求出现的时候,服务器从RPC请求队列中取出请求,然后处理后,将响应发送到reply_to指定的回调队列中
    
    客户端接受处理结果: 客户端等待回调队列中出现响应,当响应出现时,它会根据响应中correlation_id字段的值,将其返回给对应的应用
    

    过程:

    1.启动rpc客户端,等待接收数据到来,来了之后就进行处理,再将结果丢进队列
    2.启动rpc服务端,发起请求
    

    服务端 rpc_server.py

    import pika
    import uuid
    class FibonacciRpcClient(object):
        def __init__(self):
            # 客户端启动时,创建回调队列,会开启会话用于发送RPC请求以及接受响应
            # 建立连接,指定服务器的ip地址
            self.connection = pika.BlockingConnection(pika.ConnectionParameters(
                host='192.168.119.10'))
            # 建立一个会话,每个channel代表一个会话任务
            self.channel = self.connection.channel()
    
            # 声明回调队列,再次声明的原因是,服务器和客户端可能先后开启,该声明是幂等的,多次声明,但只生效一次
            #exclusive=True 参数是指只对首次声明它的连接可见
            #exclusive=True 会在连接断开的时候,自动删除
            result = self.channel.queue_declare(exclusive=True)
            # 将次队列指定为当前客户端的回调队列
            self.callback_queue = result.method.queue
            # 客户端订阅回调队列,当回调队列中有响应时,调用`on_response`方法对响应进行处理;
            self.channel.basic_consume(self.on_response, no_ack=True,
                                       queue=self.callback_queue)
    
    
        # 对回调队列中的响应进行处理的函数
        def on_response(self, ch, method, props, body):
            if self.corr_id == props.correlation_id:
                self.response = body
    
        # 发出RPC请求
        def call(self, n):
            # 初始化 response
            self.response = None
            # 生成correlation_id 关联标识,通过python的uuid库,生成全局唯一标识ID,保证时间空间唯一性
            self.corr_id = str(uuid.uuid4())
            # 发送RPC请求内容到RPC请求队列`s14rpc`,同时发送的还有`reply_to`和`correlation_id`
            self.channel.basic_publish(exchange='',
                                       routing_key='s14rpc',
                                       properties=pika.BasicProperties(
                                           reply_to=self.callback_queue,
                                           correlation_id=self.corr_id,
                                       ),
                                       body=str(n))
            while self.response is None:
                self.connection.process_data_events()
            return int(self.response)
    
    # 建立客户端
    fibonacci_rpc = FibonacciRpcClient()
    
    # 发送RPC请求,丢进rpc队列,等待客户端处理完毕,给与响应
    print("发送了请求sum(99)")
    response = fibonacci_rpc.call(99)
    
    print("得到远程结果响应%r" % response)
    

    客户端 rpc_client.py

    import pika
    # 建立连接,服务器地址为localhost,可指定ip地址
    connection = pika.BlockingConnection(pika.ConnectionParameters(
        host='192.168.119.10'))
    # 建立会话
    channel = connection.channel()
    # 声明RPC请求队列
    channel.queue_declare(queue='s14rpc')
    
    def sum(n):
        n+=100
        return n
    # 对RPC请求队列中的请求进行处理
    
    def on_request(ch, method, props, body):
        print(body,type(body))
        n = int(body)
        print(" 正在处理sum(%s)" % n)
        # 调用数据处理方法
        response = sum(n)
        # 将处理结果(响应)发送到回调队列
        ch.basic_publish(exchange='',
                         # reply_to代表回复目标
                         routing_key=props.reply_to,
                         # correlation_id(关联标识):用来将RPC的响应和请求关联起来。
                         properties=pika.BasicProperties(correlation_id= 
                                                             props.correlation_id),
                         body=str(response))
        ch.basic_ack(delivery_tag=method.delivery_tag)
    
    # 负载均衡,同一时刻发送给该服务器的请求不超过一个
    channel.basic_qos(prefetch_count=1)
    channel.basic_consume(on_request, queue='s14rpc')
    print("等待接收rpc请求")
    
    
    #开始消费
    channel.start_consuming()
    
  • 相关阅读:
    跨域常见解决方案
    express-session的简单使用说明
    Spring Cloud中,如何解决Feign/Ribbon第一次请求失败的问题?
    继承父类的静态方法的加载顺序
    sql索引优化
    EXPLAIN 执行计划详解
    JVM总括二-垃圾回收:GC Roots、回收算法、回收器
    dubbo知识体系
    Spring bean的生命流程
    日志体系与异常处理
  • 原文地址:https://www.cnblogs.com/zhufanyu/p/12101112.html
Copyright © 2020-2023  润新知