通过Redis实现RPC远程方法调用

开发 后端 前端 Redis
我发现经常研究并且为之兴奋的一件事就是对系统进行扩展。现在这对不同的人有着不同的意思。作为移植Monolithic应用到Microservices架构方法中的一部分,如何处理Microservices架构是我研究RPC的原因。

我发现经常研究并且为之兴奋的一件事就是对系统进行扩展。现在这对不同的人有着不同的意思。作为移植Monolithic应用到Microservices架构方法中的一部分,如何处理Microservices架构是我研究RPC的原因。
 

RPC(或者叫做远程进程调用)是一个已经在计算机科学领域存在较长一段时间的概念。对此一种非常简单的理解就是发送一段消息到远程进程的能力,而不论它是在同一个系统上还是远程的系统。总的来说这是非常模糊的,而且对许多的实现来说是开放的。在我看来,当谈到RPC时,会有相当多的内容可供探讨,比如消息的格式,以及你怎样将消息发送到远程进程上。有许多的方法来实现RPC,而这是我采用的一种,但对这篇文章来说,我准备使用‘JSON-RPC’来处理消息的格式,用Redis来发布消息。

RPC和消息队列

原理基本上都一样,但是使用RPC的话,客户端会等待一个含有RPC调用结果的返回消息。如果你的消息队列系统允许你为发送者处理回调消息,那么你很可能就可以为RPC来使用它。在大多数的消息队列中,它们被用来触发那些不再需要回复给客户端的任务。

为什么用Redis而不是其它的?

你应该能够在某个地主发现Redis是非常先进的技术,如果你说没有发现,你是怎么了?Redis对很多事情来说都是一个伟大的工具,你应该认真研究一下。学习之路能够平坦,并且不用学习太多的新内容,Redis都完美的符合这些想法,所以,让我们看看我们可以干些什么。

Code

Client

  1. require 'redis' 
  2. require 'securerandom' 
  3. require 'msgpack' 
  4.    
  5. class RedisRpcClient  
  6.    
  7.   def initialize(redis_url, list_name)  
  8.     @client = Redis.connect(url: redis_url)  
  9.     @list_name = list_name.to_s  
  10.   end 
  11.    
  12.   def method_missing(name, *args)  
  13.     request = {  
  14.       'jsonrpc' => '2.0',  
  15.       'method' => name,  
  16.       'params' => args,  
  17.       'id' => SecureRandom.uuid  
  18.     }  
  19.    
  20.     @client.lpush(@list_name, request.to_msgpack)  
  21.     channel, response = @client.brpop(request['id'], timeout=30)  
  22.    
  23.     MessagePack.unpack(response)['result']  
  24.   end 
  25.    
  26. end 
  27.    
  28. client = RedisRpcClient.new('redis://localhost:6379':fib)  
  29. (1..30).each { |i| puts client.fib(i) } 

Server

  1. require 'redis' 
  2. require 'msgpack' 
  3.    
  4.    
  5. class Fibonacci  
  6.    
  7.   def fib(n)  
  8.     case n  
  9.     when 0 then 0  
  10.     when 1 then 1  
  11.     else 
  12.       fib(n - 1) + fib(n - 2)  
  13.     end 
  14.   end 
  15.    
  16. end 
  17.    
  18.    
  19. class RedisRpcServer  
  20.    
  21.   def initialize(redis_url, list_name, klass)  
  22.     @client = Redis.connect(url: redis_url)  
  23.     @list_name = list_name.to_s  
  24.     @klass = klass  
  25.   end 
  26.    
  27.   def start  
  28.     puts "Starting RPC server for #{@list_name}" 
  29.     while true 
  30.       channel, request = @client.brpop(@list_name)  
  31.       request = MessagePack.unpack(request)  
  32.    
  33.       puts "Working on request: #{request['id']}" 
  34.    
  35.       args = request['params'].unshift(request['method'])  
  36.       result = @klass.send *args  
  37.    
  38.       reply = {  
  39.         'jsonrpc' => '2.0',  
  40.         'result' => result,  
  41.         'id' => request['id']  
  42.       }  
  43.    
  44.       @client.rpush(request['id'], MessagePack.pack(reply))  
  45.       @client.expire(request['id'], 30)  
  46.     end 
  47.    
  48.   end 
  49.    
  50. end 
  51.    
  52. RedisRpcServer.new('redis://localhost:6379':fib,  Fibonacci.new).start 

确是如此,它能工作是因为当你等待数据从服务器传回来时,Redis有命令能够让你阻塞等待。这是非常优秀的做法,它让你的客户端代码看上去像是在调用本地方法。

Ruby 相当酷,可是。。。

如果你想用其它语言怎么办?没问题,只要你的语言有很好的Redis库,你就可以做同样的事。让我们瞧一瞧用Python来建立一个服务端程序。

  1. import redis  
  2. import msgpack  
  3.    
  4. class Fibonacci:  
  5.    
  6.   def fib(self,n):  
  7.     if n == 0:  
  8.       return 0  
  9.     elif n == 1:  
  10.       return 1  
  11.     else:  
  12.       return self.fib(n-1) + self.fib(n-2)  
  13.    
  14.    
  15. class RedisRpcServer:  
  16.    
  17.   def __init__(self, redis_url, list_name, klass):  
  18.     self.client = redis.from_url(redis_url)  
  19.     self.list_name = list_name  
  20.     self.klass = klass  
  21.    
  22.   def start(self):  
  23.     print("Starting RPC server for " + self.list_name)  
  24.     while True:  
  25.       channel, request = self.client.brpop('fib')  
  26.       request = msgpack.unpackb(request, encoding='utf-8')  
  27.    
  28.       print("Working on request: " + request['id'])  
  29.    
  30.       result = getattr(self.klass, request['method'])(*request['params'])  
  31.    
  32.       reply = {  
  33.         'jsonrpc''2.0',  
  34.         'result': result,  
  35.         'id': request['id']  
  36.       }  
  37.    
  38.       self.client.rpush(request['id'], msgpack.packb(reply, use_bin_type=True))  
  39.       self.client.expire(request['id'], 30)  
  40.    
  41.    
  42. RedisRpcServer('redis://localhost:6379''fib', Fibonacci()).start() 

结论

这很好的证明了你头脑中的一些想法,当然,还需要更多的工作来处理异常。如果你用这个方法遇到任何的问题,我乐意帮助你。我的确希望在同样想法的一此地方使用RabbitMQ,但如果你已经在你的项目中使用了Redis,这将会是一个非常不错的方法。

英文原文:RPC using Redis

译文链接:http://www.oschina.net/translate/rpc-using-redis

责任编辑:林师授 来源: 开源中国社区 编译
相关推荐

2019-06-21 14:48:25

RMI远程RPC

2021-11-15 14:02:27

RPCSpringBootRabbitMQ

2012-02-07 13:21:37

Java

2015-06-09 13:31:29

Hadoop RPC远源码解析

2023-05-18 08:47:42

2022-01-07 06:12:08

RPC框架限流

2022-04-02 07:52:47

DubboRPC调用动态代理

2009-06-24 10:44:08

2010-10-11 11:58:12

2009-06-19 16:55:47

JNI调用C语言

2016-04-21 10:10:31

Java应用架构

2009-12-21 17:48:30

WCF方法重载

2012-07-10 13:29:30

Java

2022-06-02 10:54:01

物联网远程监控预测性

2009-06-15 10:00:08

FluorineFx库Silverlight

2009-09-18 12:29:55

2022-01-27 10:26:07

Python

2020-05-17 16:15:49

RPCJava代码

2014-07-22 10:42:04

2012-04-11 11:10:25

JavaRMI
点赞
收藏

51CTO技术栈公众号