jjym (2622)

用 Ruby 体验快速开发 P2P 网络程序

jjym — Wed, 28 Nov 2018 00:43:08 +0800

很多开发者很熟悉 Server-Client 这一套网络结构，Server-Client 是构建互联网应用的基础。但在区块链技术这里就有点过时了，区块链的世界普遍采用 P2P 网络。

P2P network 是什么呢？

对等式网络（peer-to-peer，简称 P2P），又称点对点技术，是无中心服务器、依靠用户群（peers）交换信息的互联网体系，它的作用在于，减低以往网路传输中的节点，以降低资料遗失的风险。与有中心服务器的中央网络系统不同，对等网络的每个用户端既是一个节点，也有服务器的功能，任何一个节点无法直接找到其他节点，必须依靠其户群进行信息交流。

From 维基百科

ciri-p2p 是在我尝试实现以太坊协议 (Ciri Ethereum) 时的一个副产品，使用这个库可以轻松的用 Ruby 来实现 P2P network 服务

考虑到如果可以用 Ruby 来试验各种 P2P 网络协议会非常爽，所以我把以太坊的底层 P2P 通信协议 - DevP2P 的实现作为了单独的一个库抽离了出来。

DevP2P 是一个相对独立的协议，和区块链、以太坊都没什么太多关联，所以 ciri-p2p 也可以用来做和区块链完全不相关的事情：比如实现个“基于 P2P 网络的 DNS 服务”，我们会在下文中用 ciri-p2p 来实现这个例子。

DevP2P 主要包括了以下部分：

基于公私钥的端到端加密
基于 DHT 的发现协议
架构上分层，支持多个子协议复用连接

在 ciri-p2p 中，前两点对于用户来说是透明的，我们只需要实现一个子协议来完成我们的应用逻辑

我们的示例是实现一个在 P2P 网络中可以与其他节点交换、发现网址的服务。

为了简化设计，我们设计为只去发现程序员们最喜爱的网站 - 1024 的最新网址列表。

实现子协议的代码：

require 'ciri/p2p/server'
require 'ciri/p2p/protocol'
require 'ciri/key'
require 'json'
require 'async'

# 来给 1024 发现协议起个优雅的名字，就叫 GossipDNS
class GossipDNS < Ciri::P2P::Protocol
  # code of our messages
  # 定义两个消息的 ID
  # 我们的简化协议只支持
  # FIND_URLS 查询 url 列表
  # NEW_URLS 返回 url 列表
  FIND_URLS = 1
  NEW_URLS = 2

  attr_reader :dns_records

  # 传入我们知道的 1024 最新网址列表
  def initialize(urls:) 
    # 设置我们的协议名称、版本、长度
    super(name: "1024discovery", version: 1, length: 8096) 
    @urls = urls 
  end

  # 协议初始化时会调用，context 代表当前网络的上下文
  def initialized(context) 
    puts "Service started!"
    # ciri-p2p 依赖 async 框架进行异步 IO 操作
    # 这里我们用 async 框架提供的定时功能每 10s 向所有 peers 请求最新列表
    task = Async::Task.current 
    # 每 10s 执行
    task.reactor.every(10) do
      # 取到当前连接的所有 peer
      context.peers.each do |peer| 
        task.async do
          # 对每个 peer 发送 FIND_URLS 消息, 注意这里 data 为空
          context.send_data(FIND_URLS, '', peer: peer) 
        end
      end
    end
  end


  # 收到消息时会调用
  def received(context, msg) 
    # check msg code
    case msg.code 
    when NEW_URLS
      # 收到新的 url 列表
      urls = JSON.load(msg.payload) 
      puts "receive #{urls.count} urls from #{context.peer.inspect}"
      @urls = (@urls + urls).uniq 
    when FIND_URLS
      # 收到请求消息，返回 url 列表
      puts "send #{@urls.count} urls to #{context.peer.inspect}"
      context.send_data(NEW_URLS, JSON.dump(@urls)) 
    else
      puts "received invalid message code #{msg.code}, ignoring"
    end

    # 输出当前节点和 url 列表
    puts "[#{context.local_node_id.short_hex}] current urls:"
    puts @urls
  end

  def connected(context) 
    puts "connected new peer #{context.peer.inspect}"
  end

  def disconnected(context) 
    puts "disconnected peer #{context.peer.inspect}"
  end

end

这段代码实现了 1024 发现协议的核心逻辑，注意 received 方法里我们针对收到的两个消息进行了不同的处理。整个应用由初始化时的定时任务触发。

下面来实现创建节点的代码

def start_node(protocols:,
               private_key: Ciri::Key.random, 
               bootnodes:, 
               host: '127.0.0.1', tcp_port: 0, udp_port: 0) 
  Ciri::P2P::Server.new( 
    private_key: private_key, # private key of our node, used for encrypted communication
    protocols: protocols, # 节点运行的协议
    bootnodes: bootnodes, # 节点启动时去连接的其他节点
    host: host, 
    tcp_port: tcp_port, # node port
    udp_port: udp_port, # port for discovery
    discovery_interval_secs: 5, # try discovery more nodes every 5 seconds
    dial_outgoing_interval_secs: 10, # try connect to new nodes every 10 seconds
    max_outgoing: 4, # number of nodes we will try to connect
    max_incoming: 8, # number of nodes we will accept
  ) 
end

注意这个方法的 protocols 参数，这里我们传入要启动的子协议，这些协议就会自动被节点运行。其他的参数是节点启动时的一些配置，查阅注释应该可以理解。

然后我们实现启动节点的代码：

# 我们来写启动两个节点的示例
def start_example
  puts "start example"
  # 启动 async 框架的 reactor
  Async::Reactor.run do |task| 
    # 随机一个 key 作为 node1 的私钥
    # 补充下公钥会作为节点地址的一部分，所以我们这里事先生成 key
    node1_key = Ciri::Key.random 
    # 初始化我们的协议，填入 1024 的最新网址获取方法
    protocol1 = GossipDNS.new(urls: ['baidu.com']) 
    # node2 的协议
    protocol2 = GossipDNS.new(urls: ['google.com']) 

    # start node1
    task.async do
      start_node(protocols: [protocol1], private_key: node1_key, bootnodes: [], tcp_port: 3000, udp_port: 3000).run 
    end

    # start node2
    task.async do
      # 注意这里的地址包含了 node_id 和 address，DevP2P 中节点地址是由这两部分组成。
      node1 = Ciri::P2P::Node.new( 
        node_id: Ciri::P2P::NodeID.new(node1_key), 
        addresses: [ 
          Ciri::P2P::Address.new( 
            ip: '127.0.0.1', 
            udp_port: 3000, 
            tcp_port: 3000, 
          ) 
        ]) 
      start_node(protocols: [protocol2], bootnodes: [node1], tcp_port: 3001, udp_port: 3001).run 
    end
  end

end

if caller.size == 0
  # 设置 ciri-p2p 的日志
  Ciri::Utils::Logger.setup(level: :info) 
  start_example 
end

上述代码设计了一些 async 框架的部分，分别启动了两个节点，设置了 node2 的 bootnodes 参数，这样 node2 会去主动连接 node1。等待 10s 左右就会看到节点间互相传递数据的日志。

全部代码整理在 gossip-dns-example ，可以直接 clone repo 来启动。

在示例仓库目录下运行 bundle install && bundle exec ruby app.rb

产生如下日志，节点成功交换网址！

start example
Service started!                                        
I, [2018-11-28 00:00:02#6306]  INFO -- Ciri::P2P::Server: start accept connections -- listen on localhost:hbci
Service started!
I, [2018-11-28 00:00:02#6306]  INFO -- Ciri::P2P::Server: start accept connections -- listen on localhost:redwood-broker
I, [2018-11-28 00:00:02#6306]  INFO -- Ciri::P2P::Discovery::Service: start discovery server on udp_port: 3000 tcp_port: 3000
local_node_id: 0xfcf53c4df3f3202c9b4835cad688828abdd01e3123dee1bcb5a6408199360f92e225a4d2e2d04e2e0f7002c1bde328e13c107ccd43140f08ce052f53753d3458
I, [2018-11-28 00:00:02#6306]  INFO -- Ciri::P2P::Discovery::Service: start discovery server on udp_port: 3001 tcp_port: 3001
local_node_id: 0x1640206ef2b13fb80c4b4d7af34cd3e1b319f2a4c139724d157458df456569487b17cd787072b94de1776c40bf51b8d4d1cfff56358dc5ecf7472fa2fe2d1d28
I, [2018-11-28 00:00:03#6306]  INFO -- Ciri::P2P::NetworkState: [0x1640206] connect to new peer <Peer:0xfcf53c4 direction: outgoing>
connected new peer <Peer:0xfcf53c4 direction: outgoing>
I, [2018-11-28 00:00:03#6306]  INFO -- Ciri::P2P::NetworkState: [0xfcf53c4] connect to new peer <Peer:0x1640206 direction: incoming>
connected new peer <Peer:0x1640206 direction: incoming>
send 1 urls to <Peer:0xfcf53c4 direction: outgoing>
[0x1640206] current urls:             
google.com                                  
receive 1 urls from <Peer:0x1640206 direction: incoming>                                                                        
[0xfcf53c4] current urls:                                                                                                        
baidu.com                                                                                                                       
google.com

这是个很简单的示例程序，展示了 ciri-p2p 的基本用法，ciri-p2p 本身的功能还是很完善的，结合 async 框架我们甚至可以把示例扩展为真正可用的 P2P 版 DNS。

区块链或其他的 P2P 网络环境中还有很多有趣的协议值得研究，不妨用 ciri-p2p 来实现下。

要注意的是，真实的 P2P 网络中，一定要考虑到 peer 间是无法信任的，像示例中这样简单的协议，很可能跑一整天也发现不了真正的网址。

Ciri-p2p https://github.com/ciri-ethereum/ciri-p2p
示例代码 https://github.com/jjyr/gossip-dns-example

原文转自博客 - http://justjjy.com/2018/11/27/yong-Ruby-ti-yan-kuai-su-kai-fa-p2p-wang-luo-cheng-xu/

简化实例变量的初始化，一个被连续拒绝了 7 年的语法...

jjym — Tue, 02 Oct 2018 13:48:27 +0800

https://bugs.ruby-lang.org/issues/15192

Ruby 的命名空间提案，引用包时避免污染全局环境

jjym — Sun, 19 Aug 2018 12:58:45 +0800

https://bugs.ruby-lang.org/issues/14982

大致思路就是加入一些对上下文的造作，让用户来控制当前的上下文（Binding），而不是 gem 作者

示例：

1 引用 ruby 文件到单独的 module 下

# requiring into isolated Binding
require ‘foo’, into: :IsolatedBindingModule1
IsolatedBindingModule1.class # Module
IsolatedBindingModule1::Foo # access names

# the old way should still work
# requiring and polluting TOPLEVEL_BINDING
require ‘foo’
Foo

2 允许用户使用“干净”的上下文 (Binding)

Foo
isolate # isolate 关键字创建了新的 Binding(独立于 TOPLEVEL_BINDING)
    Foo # NameError
end

isolate module Bar # 隔离 Bar 的 Binding
  Foo # NameError
end

3 import，从另外 Binding 中导入名称

Foo
isolate
  # import name from a ruby file
  # import primitive is a convenient way to use isolated requiring
  import :Foo, from: “foo”
end

更多详细信息可以去看原帖

注意：这是个提案，目前还未被 Ruby 团队接受

PUMA 实现简要分析

jjym — Thu, 22 Feb 2018 02:17:25 +0800

http://justjjy.com/2018/02/21/PUMA-shi-xian-jian-yao-fen-xi/

Good news everyone! Ruby 又要添加绿色线程了, Thread::Green (可以理解为 go 的 goroutine)

jjym — Sun, 04 Feb 2018 14:49:29 +0800

https://bugs.ruby-lang.org/issues/13618

翻到了 ruby-lang 的这个 issue，总结下

Eric Wong 给 ruby 增加了可以自动调度的 fiber，暂命名为 Thread::Green。就是类似 go 的 goroutine 这样的轻量级线程
Queue, SizedQueue 等用于同步的类是可以和 Thread::Green 一起使用的。意味着现有的 WebServer 成 Thread::Green 很简单可以迁移
Matz, ko1 等大佬纷纷拍手称赞，(说不定很快就能用上了)
之后 ruby 可以说摆脱异步编程模型了，直接起 Thread::Green 然后用 blocking IO 就可以和 node 的 callback hell 怼一怼
对‘应用级别’开发者意味着 Web Server 会更高效，Rails 等框架也会更高效

用法大概就是和 Thread api 会兼容所以没什么区别，比如下面示例：

urls = ["https://...", ...]
results = urls.map do |url|
  Thread::Green.new(url) do |url|
    # request url
    ....
  end
end

感觉 Eric Wong 这个人很神奇啊，Unicorn 应该也是他写的。很低调、很少出镜，不用非自由软件 (包括 js)..有谁知道他的故事..

坏消息就是我之前写的库已经失去存在意义了 lightio, 不过可以当作个教学示例吧，这些功能从 ruby 层面去实现大概就是这个库

新年新项目，聊一聊最近在做的 LightIO，IO 性能的免费午餐

jjym — Mon, 01 Jan 2018 18:08:33 +0800

LightIO 是什么

gevent 是 python 中我最喜欢库之一。

只要 import gevent, 调用下 monkey patch 便会把线程替换为绿色线程，并且把标准库 socket 打上补丁。

每次 IO 操作都会由类库自动切换到其他绿色线程。对用户几乎完全透明，堪称 IO 性能的免费午餐。（建议看这里了解详细： gevent 和异步）

身为 rubyist 一直很羡慕隔壁的 gevent。之前虽也有过 em-synchronize 之类使用 Fiber 来表达同步的库（也可以看这篇了解，不再累述），但总归昙花一现，而且无法做到对用户透明用起来没 gevent 这么方便。

最近耐心看了 gevent 源码，尝试在 ruby 中实现类似能力。产出是 LightIO，目标是为 ruby 用户提供免费的 IO 午餐

当前状态

核心实现起来很简单。但 ruby 的标准库接口庞大，要实现可以 Monkey Patch 的类得花费一番功夫。所以目前只支持有限的几个类 (Socket, TCPSocket, IO 等等)

和 gevent 一样，可以显式的使用 LightIO 来编写代码，目前已经能稳定的支持

如下示例，使用 LightIO 下的 Beam， TCPServer 相比标准库可以获得更好的性能。（基础用法）

# echo server example, use telnet to test
LightIO::TCPServer.open('127.0.0.1', 3000) do |server|
  puts "start echo server"
  while (socket = server.accept)
    LightIO::Beam.new(socket){|s| 
      _, port, host = s.peeraddr
      puts "accept connection from #{host}:#{port}"
      loop {s << s.readpartial(4096) rescue break puts("client leave #{host}:#{port}")}
    }
  end
end

另一种精髓用法是使用 LightIO namespace 下的类进行全局 Monkey Patch, 目前仍未完美支持。

Monkey Patch 和 Performance

最近成功的用 LightIO Monkey Patch 了 Webrick，用 ab 本机测了下，性能的确有所提升。 https://github.com/jjyr/lightio_benchmark

在 aws 的 1G 机器上大概每秒多处理 100 个请求。提升不太明显，原因 1 是和 Webrick 代码本身有关，2 是目前大多数服务器也是异步 IO，只测 Hello World 不会有太大区别。在更贴近真实环境的情况下 LightIO 的绿色线程会有更大优势。

同时试了下 sinatra 还无法支持..应该是 sinatra 使用了目前 LightIO 没有包含的标准库。

目前的下个目标就定位可以 Monkey Patch sinatra 应用

道阻且长，完美的 Monkey Patch 标准库是难以短时间实现的。

但 LightiO 已经可以提供很好的支持使用，如果有人写一些高性能的 Server／爬虫等服务，可以考虑使用 LightIO 来实现。

[上海] 魔都最闪耀的容器云计算领域明星企业 DaoCloud 求贤若渴！推荐求职送豪礼~

jjym — Wed, 29 Jun 2016 11:57:11 +0800

DaoCloud 成立于 2014 年末，是新一代容器云计算领域的明星企业。DaoCloud 产品线涵盖互联网应用的开发、交付、运维和运营全生命周期，并提供公有云、混合云和私有云等多种交付方式。DaoCloud 核心团队由来自 EMC、VMware、微软等知名企业的高管和技术专家组成，公司已经完成两轮超过千万美元规模融资，产品被企业级客户、互联网公司等广泛采用。DaoCloud 总部位于中国上海，并设立了北京、武汉、深圳等分支机构。我们的官网：http://www.daocloud.io/

区域销售经理（上海、南京、北京、济南、武汉、深圳、广州）五年以上企业级 IT 软件产品或解决方案大客户的销售经验熟悉云计算、大数据、容器、PaaS、软件开发等领域的知识在本区域有一定企业客户、行业、渠道资源的积累出色的商务谈判和沟通能力，良好的团队协作能力具备责任心、服务意识、创业激情，能够承受较大的工作压力

售前顾问（上海、南京、北京、济南、武汉、深圳、广州）三年以上 IT 或互联网相关公司技术开发或售前相关工作经验熟悉云计算行业的主流技术，了解 VMware、微软，或者 OpenStack 等虚拟化技术对持续集成、持续交付、容器云平台等有较深入的研究和实战经验求知欲强，有较好的学习能力，对企业 IT 架构和业务需求有较深入的理解优秀的沟通能力和演讲能力，能够与客户的决策层有效沟通交流

云平台后端工程师（上海）熟练使用 Python 或 Golang 熟悉 Docker 和 Docker 相关的产品，比如 Registry、Swarm、Compose 等熟悉 Linux 开发环境，有一定的系统管理能力和 MySQL 管理能力开源项目的 Owner、核心贡献者或 DaoCloud 活跃用户优先考虑对代码和工程质量有所追求

「推荐送豪礼」

欢迎一直默默支持 DaoCloud 的伙伴们积极参与本次活动！

即日起，成功自荐或推荐身边亲朋好友入职转正后，即可获得以下任意一款惊喜极客大礼或等值现金红包：

价值 4499 元微软 Microsoft Xbox One 体感游戏机一台价值 5199 元大疆 Phantom 3 4K 航拍无人机四轴飞行器一台

价值 4488 元苹果 iPad Air 2（64G）平板电脑一台

价值 4566 元科思康双轮平衡体感车一辆

参与方式：

请猛烈投掷简历至：jobs@daocloud.io

本次活动截至时间为 2016 年 7 月 15 日

友情提醒：

1）请在邮件标题中注明应聘或推荐的职位＋人名

2）程序员请提供 Github 个人页面地址

minidown 2.1.0 版发布！一个又小又快的 markdown parser, 100% 的 GFM 支持

jjym — Sun, 23 Feb 2014 23:26:21 +0800

https://github.com/jjyr/minidown/releases/tag/v2.1.0

很久前发过一次，但我当时没想到有很多隐藏的很难解决的 bug。(比如区分 html 和普通的 text，正确分析几种有歧义的语法等)

最近才找到了思路，把这些难缠的 bug 都修掉了，并且加入了 table 的语法支持。

现在已经做到了 100% 的 GFM 格式支持！！

其实写这个的初衷就是很多 markdown parser 号称支持 GFM，但并非 100% 的支持，比如 redcarpet 的 underscore 语法，如果加上 escape 符号的话会有问题，换行貌似也会有问题。marked 则是不支持 Task list.maruku 的话总是报错，rdiscount 解析速度又太慢。

于是就打算写个纯 ruby，100% 支持 GFM，使用方便，不可配置 (这一点也是考虑到了减少复杂度) 的 markdown parser。写完后测了下，发现解析速度相比同是 ruby 所写的 maruku 和 rdiscount 还是有不少优势。

目前 minidown 坚持的是小而方便路线

纯 ruby
无其他依赖
暂时不会考虑加入更多的自定义 (目前 code 块可以自定义，用于代码着色)

当初版本号升的太草率了，所以导致 2.1 版前隐藏着一些很难发现的 parse 上的问题。

现在测试用例增加到了 120 多个，可以说正确性已经得到了解决，并且已经 100% 支持 GFM！

偶然搜到了个很 cool 的东西，rhodes -- ruby 开发跨平台 mobile 应用

jjym — Sat, 18 Jan 2014 23:10:11 +0800

https://github.com/rhomobile/rhodes

The Rhodes framework is a platform for building locally executing, device-optimized mobile applications for all major smartphone devices.

大家用了 ruby2.0 后感觉对 web 程序来说效率提升了吗？

jjym — Wed, 18 Sep 2013 13:23:25 +0800

最近试了下用 ruby2.0 + rails3.2，benchmark 感觉没 1.9.3 快。很出乎意料啊

Github 两步认证

jjym — Fri, 06 Sep 2013 11:39:34 +0800

https://github.com/blog/1614-two-factor-authentication

发现没人在社区里发

bundler 1.4.0 增加并行支持，以后不能偷懒了...

jjym — Sat, 31 Aug 2013 22:47:02 +0800

http://robots.thoughtbot.com/post/59584648154/parallel-gem-installing-using-bundler

写了个 Markdown parser [附代码导读]

jjym — Thu, 29 Aug 2013 19:32:48 +0800

最近练手写了个 markdown parser 采用 GFM 格式没有其他依赖 https://github.com/jjyr/minidown 比想像中的要麻烦不少..

可以完美解析GFM 的 source 页！

另: 既然有人读就再增加了一些略详细的说明

大概思路是字符串传到Document类，然后split成行

这是markdown一个特点, 单行就可以进行解析，比如 `code` 等语法都是不允许换行的，即使是块结构的语法, 如```，也是可以从单行中判断开始与结束

之后`Document#parse_reference`会去解析一遍文档， 把markdown中的链接/图片定义替换

然后parse_line进行每行的解析

大概就是

while line = unparsed_lines.shift
    parsed_nodes << (parse_line line)
end

parse_line中如果发现特殊结构
如: `>, *`等就由相应的类去解析(如`>`开头会由`BlockElement`类解析)

其余交给TextElement来解析文本内的语法，比如 *斜体*

....然后就是与各种正则的搏斗

之后对parse后的node调用to_html全部转换为HTML输出

[Benchmark] Ruby 2.0 真的快了不少，还是我的 Python 代码有问题?

jjym — Mon, 22 Jul 2013 23:12:02 +0800

ruby -v
ruby 2.0.0p247 (2013-06-27 revision 41674) [x86_64-linux]

python3 --version
Python 3.3.2

使用传统的 fibonacci 来 benchmark

#ruby
require 'benchmark'

def fib n
  if n < 2
    1
  else
    fib(n - 1) + fib(n - 2)
  end
end

Benchmark.bm{|bm| bm.report{puts fib(35)}}

#python
import timeit

def fib(n):
    if n < 2:
        return 1
    else:
        return fib(n - 1) + fib(n - 2)

if __name__=='__main__':
    from timeit import Timer
    t = Timer("print(fib(35))","from __main__ import fib")
    print(t.timeit(1))

#ruby

ruby fib.rb
       user     system      total        real
 14930352
  2.600000   0.000000   2.600000 (  2.601639)

#python3.2.2

fib.py 
14930352
9.720147652000378

ruby 版本快了大概 3.7 倍我使用 python2.7.5 版会稍微快些，大概 6.3 秒，当然还是比 ruby 慢的

ruby2.0 真的快了不少，还是说我的 python 代码写的有问题？

请问有什么好用的微博推特客户端吗？

jjym — Sun, 07 Jul 2013 20:31:02 +0800

大家都用的什么

网站提供 atom feed 同时还需要 rss 吗？

jjym — Fri, 24 May 2013 14:42:16 +0800

Supporters of the ATOM format also needs to add support for RSS so that those who only have RSS support can also see the content, which is still the great majority of people who subscribe to web feeds.

http://www.differencebetween.net/technology/difference-between-rss-and-atom/#ixzz1RTwQ79rt

从这里看到的，大家做 rss 的时候都是提供两个吗？还是只 atom feed 或者只 rss feed?

哈哈哈哈，熬夜写了个半成品的 Lisp like interpreter

jjym — Sun, 19 May 2013 03:46:42 +0800

看了下 b 大发的参考

发现貌似没这么难，试着做了下

虽然代码很烂，功能不完善这也是自己写的第一个解释器啊 just for study https://github.com/jjyr/rblisp

明天继续搞怕挂了，先睡觉了

更新已经比较完善了

((if (< (size "hello world") 42) puts 42) "hello world")
#hello world

ruby 的某个服务器 3 倍速了..

jjym — Fri, 05 Apr 2013 15:02:50 +0800

详见这个

另外作者还表示对某个 Benchmark 很感兴趣..

[已解决] ruby 调用 shell 时大括号不能展开

jjym — Thu, 29 Nov 2012 10:25:22 +0800

mkdir {dir1,dir2} 这样写在 shell 是能展开的

但是通过 ruby 调用只能得到文件夹{dir1,dir2} `` exec system popen 好像都不能展开。。求解有啥好办法

[新手向] ActiveRecord::Base 与 ActiveRecord::Relation 关系及基本原理

jjym — Tue, 21 Aug 2012 13:31:09 +0800

之前在 github 上看 Rails 源码真的要疯了。。现在有 rubymine 这个神器。看源码方便多了。。

正题：

AR = ActiveRecord

AR::Base 和 AR::Record 的关系

在 AR::Base 上调用查询方法如 where,all,limit 等均会代理到 scoped 方法，而 scoped 方法大意就是会返回一个 AR::Relation 的实例，AR::Base 本身拥有一个 AR::Relation 实例，并且之后所有查询都在此 relation 上 clone 而来。所以我们在 Base 上调用的查询接口实际是 Relation 中的。

补充：前几天看 Kaminari 源码，发现仅在 Base 上 include 了分页方法的模块，经人指点后发现这是因为 Relation 新建时会接受一个 Base 的引用，并且 Relation 的 method_missing 会调用该引用的方法。所以在 Base 上定义就 OK。

延迟执行很神奇吗？

其实没什么神奇的，原理很简单（实现还是有困难的。。），每次把条件存下，然后真正查询的时候再调用

比如

def uniq(value = true)
      relation = clone
      relation.uniq_value = value
      relation
end

存下条件，返回 relation 这样就能进行链式调用了

真正查询时在根据条件生成查询语句

什么时候查询？

打开 rails c

输入Post.where "id > 5"

生成SELECT "posts".* FROM "posts" WHERE (id > 5)

输入Post.where("id > 5").first

生成SELECT "posts".* FROM "posts" WHERE (id > 5) LIMIT 1

where 做的应该只是保存查询条件才对。现在居然生成查询语句，这不科学！！

def where(opts, *rest)
      return self if opts.blank?

      relation = clone
      relation.where_values += build_where(opts, rest)
      relation
end

你没猜错！返回的的确是 relation，所以答案就在这个坑跌的 relation 中

AR::Relation#inspect

def inspect
      to_a.inspect
end

因为 irb 每次执行都会输出返回值的 inspect，所以造成了 where 语句执行查询的错觉。

在 Rails 中我们通常调用 each 来遍历，或者 first/last 来取值，这时查询才会发生！