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

怎么入门数据库编程？需要学习哪些知识点？这是新手们刚接触编程时常见的问题；下面golang学习网就来给大家整理分享一些知识点，希望能够给初学者一些帮助。本篇文章就来介绍《通过Redis实现RPC远程方法调用》，涉及到Redis、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

今天关于《通过Redis实现RPC远程方法调用》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于redis的内容请关注golang学习网公众号！