這篇文章主要介紹了Ruby中的鉤子方法詳解,本文講解了什么是鉤子方法、included、Devise中的 included、extended、ActiveRecord中的 extended、prepended、inherited等內容,需要的朋友可以參考下
Ruby的哲學理念是基于一個基本的要素，那就是讓程序員快樂，
Ruby中的鉤子方法詳解
。Ruby非常注重程序員的快樂，并且也提供了許多不同的方法來實現它。 它的元編程能力能夠讓程序員編寫在運行時動態生成的代碼。它的線程功能使得程序員有一種優雅的的方式編寫多線程代碼。 它的鉤子方法能讓程序員在程序運行時擴展它的行為。上述的這些特性，以及一些其他很酷的語言方面，使得Ruby成為編寫代碼的優先選擇之一。 本文將探討Ruby中的一些重要的鉤子方法。我們將從不同方面討論鉤子方法，如它們是什么，它們用于什么，以及我們如何使用它們來解決不同的問題。 我們同時也了解一下一些流行的Ruby框架/Gem包/庫是如何使用它們來提供非常酷的特性的。
我們開始吧。
什么是鉤子方法？
鉤子方法提供了一種方式用于在程序運行時擴展程序的行為。 假設有這樣的功能，可以在無論何時一個子類繼承了一些特定的父類時收到通知， 或者是比較優雅地處理一個對象上的不可調用的方法而不是讓編譯器拋出異常。 這些情況就是使用鉤子方法，但是它們的用法并不僅限于此。 不同的框架/庫使用了不同的鉤子方法來實現它們的功能。
在本文中我們將會討論如下幾個鉤子方法：
1.included
2.extended
3.prepended
4.inherited
5.method_missing
included
Ruby給我們提供了一種方式使用 模塊(modules) （在其他語言中被稱作 混入類(mixins)）來編寫模塊化的代碼供其他的 模塊/類 使用。 模塊 的概念很簡單，它就是一個可以在其他地方使用的獨立代碼塊。
例如，如果我們想要編寫一些代碼在任何時候調用特定的方法都會返回一個靜態字符串。 我們姑且將這個方法稱作 name。你可能在其他地方也會想使用同一塊代碼。 這樣最好是新建一個模塊。讓我們來創建一個：
代碼如下:
module Person
def name
puts "My name is Person"
end
end
這是一個非常簡單的模塊，僅有一個 name 方法用于返回一個靜態字符串。在我們的程序中使用這個模塊：
代碼如下:
class User
include Person
end
Ruby提供了一些不同的方法來使用模塊。include 是其中之一。include 所做的就是將在 module 內定義的方法在一個 class 的實例變量上可用。 在我們的例子中，是將 Person 模塊中定義的方法變為一個 User 類實例對象的方法。 這就相當于我們是將 name 方法寫在 User 類里一樣，但是定義在 module 里的好處是可復用。 要調用 name 方法我們需要創建一個 User 的實例對象，然后再在這個對象上調用 name 方法。例如：
代碼如下:
User.new.name
=> My name is Person
讓我們看看基于 include 的鉤子方法。included 是Ruby提供的一個鉤子方法，當你在一些 module 或者 class 中 include 了一個 module 時它會被調用。 更新 Person 模塊：
代碼如下:
module Person
def self.included(base)
puts "#{base} included #{self}"
end
def name
"My name is Person"
end
end
你可以看到一個新的方法 included 被定義為 Person 模塊的類方法。當你在其他的模塊或者類中執行 include Person 時，這個 included 方法會被調用。 該方法接收的一個參數是對包含該模塊的類的引用。試試運行 User.new.name，你會看到如下的輸出：
代碼如下:
User included Person
My name is Person
正如你所見，base 返回的是包含該模塊的類名。現在我們有了一個包含 Person 模塊的類的引用，我們可以通過元編程來實現我們想要的功能。 讓我們來看看 Devise是如何使用 included 鉤子的。
Devise中的 included
Devise是Ruby中使用最廣泛的身份驗證gem包之一。它主要是由我喜歡的程序員 José Valim 開發的，現在是由一些了不起的貢獻者在維護。 Devise為我們提供了從注冊到登錄，從忘記密碼到找回密碼等等完善的功能。它可以讓我們在用戶模型中使用簡單的語法來配置各種模塊：
代碼如下:
devise :database_authenticatable, :registerable, :validatable
在我們模型中使用的 devise 方法在這里定義。 為了方便我將這段代碼粘貼在下面：
代碼如下:
def devise(*modules)
ptions = modules.extract_options!.dup
selected_modules = modules.map(&:to_sym).uniq.sort_by do |s|
Devise::ALL.index(s) || -1 # follow Devise::ALL order
end
devise_modules_hook! do
include Devise::Models::Authenticatable
selected_modules.each do |m|
mod = Devise::Models.const_get(m.to_s.classify)
if mod.const_defined?("ClassMethods")
class_mod = mod.const_get("ClassMethods")
extend class_mod
if class_mod.respond_to?(:available_configs)
available_configs = class_mod.available_configs
available_configs.each do |config|
next unless options.key?(config)
send(:"#{config}=", options.delete(config))
end
end
end
include mod
end
self.devise_modules |= selected_modules
options.each { |key, value| send(:"#{key}=", value) }
end
end
在我們的模型中傳給 devise 方法的模塊名將會作為一個數組保存在 *modules 中。 對于傳入的模塊調用 extract_options! 方法提取可能傳入的選項。 在11行中調用 each 方法，并且每個模塊在代碼塊中用 m 表示。 在12行中 m 將會轉化為一個常量（類名），因此使用 m.to.classify 一個例如 :validatable 這樣的符號會變為 Validatable 。 隨便說一下 classify 是ActiveSupport的方法。
Devise::Models.const_get(m.to_classify) 會獲取該模塊的引用，并賦值給 mod。 在27行使用 include mod 包含該模塊。 例子中的 Validatable 模塊是定義在這里。 Validatable 的 included 鉤子方法定義如下：
代碼如下:
def self.included(base)
base.extend ClassMethods
assert_validations_api!(base)
base.class_eval do
validates_presence_of :email, if: :email_required?
validates_uniqueness_of :email, allow_blank: true, if: :email_changed?
validates_format_of :email, with: email_regexp, allow_blank: true, if: :email_changed?
validates_presence_of :password, if: :password_required?
validates_confirmation_of :password, if: :password_required?
validates_length_of :password, within: password_length, allow_blank: true
end
end
此時模型是 base。在第5行的 class_eval 代碼塊會以該類作為上下文進行求值運算。 通過 class_eval 編寫的代碼與直接打開該類的文件將代碼粘貼進去效果是一樣的。 Devise是通過 class_eval 將驗證包含到我們的用戶模型中的。
當我們試著使用Devise注冊或者登錄時，我們會看到這些驗證，但是我們并沒有編寫這些驗證代碼。 Devise是利用了 included 鉤子來實現這些的。非常的優雅吧。
extended
Ruby也允許開發者 擴展(extend) 一個模塊，這與 包含(include) 有點不同。 extend 是將定義在 模塊(module) 內的方法應用為類的方法，而不是實例的方法。 讓我們來看一個簡單的例子：
代碼如下:
module Person
def name
"My name is Person"
end
end
class User
extend Person
end
puts User.name # => My name is Person
正如你所看到的，我們將 Person 模塊內定義的 name 方法作為了 User 的類方法調用。 extend 將 Person 模塊內的方法添加到了 User 類中。extend 同樣也可以用于將模塊內的方法作為單例方法(singleton methods)。 讓我們再來看另外一個例子：
代碼如下:
# We are using same Person module and User class from previous example.
u1 = User.new
u2 = User.new
u1.extend Person
puts u1.name # => My name is Person
puts u2.name # => undefined method `name‘ for #
我們創建了兩個 User 的實例對象，并將 Person 作為參數在 u1 上調用 extend 方法。 使用這種調用方式，Person 的 name 方法僅對 u1 有效，對于其他實例是無效的。
正如 included 一樣，與 extend 相對應的鉤子方法是 extended。 當一個模塊被其他模塊或者類執行了 extend 操作時，該方法將會被調用。 讓我們來看一個例子：
代碼如下:
# Modified version of Person module
module Person
def self.extended(base)
puts "#{base} extended #{self}"
end
def name
"My name is Person"
end
end
class User
extend Person
end
該代碼的運行結果是輸出 User extended Person。
關于 extended 的介紹已經完了，讓我們來看看 ActiveRecord 是如何使用它的。
ActiveRecord中的 extended
ActiveRecord 是在 Ruby 以及 Rails 中廣泛使用的ORM框架。它具有許多酷的特性， 因此使用它在很多情況下成為了ORM的首選。讓我們進入 ActiveRecord 內部看看 ActiveRecord 是如何使用回調的。 (我們使用的是 Rails v3.2.21)
ActiveRecord 在這里 extend 了 ActiveRecord::Models 模塊。
代碼如下:
extend ActiveModel::Callbacks
ActiveModel 提供了一套在模型類中使用的接口。它們允許 ActionPack 與不是 ActiveRecord 的模型進行交互。 在這里， ActiveModel::Callbacks 內部你將會看到如下代碼：
代碼如下:
def self.extended(base)
base.class_eval do
include ActiveSupport::Callbacks
end
end
ActiveModel::Callbacks 對 base 即就是 ActiveRecord::Callbacks 調用了 class_eval 方法， 并包含了 ActiveSupport::Callbacks 模塊，
電腦資料
《Ruby中的鉤子方法詳解》(http://salifelink.com)。我們前面已經提到過了，對一個類調用 class_eval 與手動地將代碼寫在這個類里是一樣的。 ActiveSupport::Callbacks 為 ActiveRecord::Callbacks 提供了 Rails 中的回調方法。這里我們討論了 extend 方法，以及與之對應的鉤子 extended。并且也了解了 ActiveRecord / ActiveModel 是如何使用上述方法為我們提供可用功能的。
prepended
另一個使用定義在模塊內部方法的方式稱為 prepend。prepend 是在Ruby 2.0中引入的，并且與 include 和 extend 很不一樣。 使用 include 和 extend 引入的方法可以被目標模塊/類重新定義覆蓋。 例如，如果我們在某個模塊中定義了一個名為 name 的方法，并且在目標模塊/類中也定義同名的方法。 那么這個在我們類在定義的 name 方法將會覆蓋模塊中的。而 prepend 是不一樣的，它會將 prepend 引入的模塊 中的方法覆蓋掉我們模塊/類中定義的方法。讓我們來看一個簡單的例子：
代碼如下:
module Person
def name
"My name belongs to Person"
end
end
class User
include Person
def name
"My name belongs to User"
end
end
puts User.new.name
=> My name belongs to User
現在再來看看 prepend 的情況：
代碼如下:
module Person
def name
"My name belongs to Person"
end
end
class User
prepend Person
def name
"My name belongs to User"
end
end
puts User.new.name
=> My name belongs to Person
使用 prepend Person 會將 User 中的同名方法給覆蓋掉，因此在終端輸出的結果為 My name belongs to Person。 prepend 實際上是將方法添加到方法鏈的前端。在調用 User 類內定義的 name 方法時，會調用 super 從而調用 Person 模塊的 name。
與 prepend 對應的回調名為（你應該猜到了） prepended。當一個模塊被預置到另一個模塊/類中時它會被調用。 我們來看下效果。更新 Person 模塊的定義：
代碼如下:
module Person
def self.prepended(base)
puts "#{self} prepended to #{base}"
end
def name
"My name belongs to Person"
end
end
你再運行這段代碼應該會看到如下結果：
代碼如下:
Person prepended to User
My name belongs to Person
prepend 的引入是為了去除 alias_method_chain hack的丑陋，它曾被Rails以及其他庫廣泛地使用以達到與 prepend 相同的功能。 因為 prepend 只有在 Ruby >= 2.0 的版本中才能使用，因此如果你打算使用 prepend 的話，那么你就應該升級你的Ruby版本。
inherited
繼承是面向對象中一個最重要的概念。Ruby是一門面向對象的編程語言，并且提供了從基/父類繼承一個子類的功能。 我們來看一個簡單的例子：
代碼如下:
class Person
def name
"My name is Person"
end
end
class User < Person
end
puts User.new.name # => My name is Person
我們創建了一個 Person 類和一個子類 User。在 Person 中定義的方法也成為了 User 的一部分。 這是非常簡單的繼承。你可能會好奇，是否有什么方法可以在一個類被其他類繼承時收到通知呢？ 是的，Ruby有一個名為 inherited 的鉤子可以實現。我們再看看這個例子：
代碼如下:
class Person
def self.inherited(child_class)
puts "#{child_class} inherits #{self}"
end
def name
"My name is Person"
end
end
class User < Person
end
puts User.new.name
正如你所見，當 Person 類被其他子類繼承時 inherited 類方法將會被調用。 運行以上代碼結果如下：
代碼如下:
User inherits Person
My name is Person
讓我們看看 Rails 在它的代碼中是如何使用 inherited 的。
Rails中的 inherited
Rails應用中有一個重要的類名為 Application ，定義中 config/application.rb 文件內。 這個類執行了許多不同的任務，如運行所有的Railties，引擎以及插件的初始化。 關于 Application 類的一個有趣的事件是，在同一個進程中不能運行兩個實例。 如果我們嘗試修改這個行為，Rails將會拋出一個異常。讓我們來看看Rails是如何實現這個特性的。
Application 類繼承自 Rails::Application，它是在這里定義的。 在62行定義了 inherited 鉤子，它會在我們的Rails應用 Application 類繼承 Rails::Application 時被調用。 inherited 鉤子的代碼如下：
代碼如下:
class << self
def inherited(base)
raise "You cannot have more than one Rails::Application" if Rails.application
super
Rails.application = base.instance
Rails.application.add_lib_to_load_path!
ActiveSupport.run_load_hooks(:before_configuration, base.instance)
end
end
class << self 是Ruby中的另一個定義類方法的方式。在 inherited 中的第1行是檢查 Rails.application 是否已存在。 如果存在則拋出異常。第一次運行這段代碼時 Rails.application 會返回false然后調用 super。 在這里 super 即是 Rails::Engine 的 inherited 鉤子，因為 Rails::Application 繼承自 Rails::Engine。
在下一行，你會看到 Rails.application 被賦值為 base.instance 。其余就是設置Rails應用了。
這就是Rails如何巧妙地使用 inherited 鉤子來實現我們的Rails Application 類的單實例。
method_missing
method_missing 可能是Ruby中使用最廣的鉤子。在許多流行的Ruby框架/gem包/庫中都有使用它。 當我們試圖訪問一個對象上不存在的方法時則會調用這個鉤子方法。 讓我們來看一個簡單的例子：
代碼如下:
class Person
def name
"My name is Person"
end
end
p = Person.new
puts p.name # => My name is Person
puts p.address # => undefined method `address‘ for #
我們定義了一個簡單的 Person 類， 它只有一個 name 方法。然后創建一個 Person 的實例對象， 并分別調用 name 和 address 兩個方法。因為 Person 中定義了 name，因此這個運行沒問題。 然而 Person 并沒有定義 address，這將會拋出一個異常。 method_missing 鉤子可以優雅地捕捉到這些未定義的方法，避免此類異常。 讓我們修改一下 Person 類：
代碼如下:
class Person
def method_missing(sym, *args)
"#{sym} not defined on #{self}"
end
def name
"My name is Person"
end
end
p = Person.new
puts p.name # => My name is Person
puts p.address # => address not defined on #
method_missing 接收兩個參數：被調用的方法名和傳遞給該方法的參數。 首先Ruby會尋找我們試圖調用的方法，如果方法沒找到則會尋找 method_missing 方法。 現在我們重載了 Person 中的 method_missing，因此Ruby將會調用它而不是拋出異常。
讓我們來看看 Rake 是如何使用 method_missing 的。
Rake中的 method_missing
Rake 是Ruby中使用最廣泛的gem包之一。Rake 使用 method_missing 來提供訪問傳遞給Rake任務的參數。 首先創建一個簡單的rake任務：
代碼如下:
task :hello do
puts "Hello"
end
如果你通過調用 rake hello 來執行這個任務，你會看到輸出 Hello。 讓我們擴展這個rake任務，以便接收一個參數（一個人名）并向他打招呼：
代碼如下:
task :hello, :name do |t, args|
puts "Hello #{args.name}"
end
t 是任務名，args 保存了傳遞過來的參數。正如你所見，我們調用 args.name 來獲取傳遞給 hello 任務的 name 參數。 運行該任務，并傳遞一個參數：
代碼如下:
rake hello["Imran Latif"]
=> Hello Imran Latif
讓我們來看看 Rake 是如何使用 method_missing 為我們提供了傳遞給任務的參數的。
在上面任務中的 args 對象是一個 Rake::TaskArguments 實例，它是在這里所定義。 這個類負責管理傳遞給Rake任務的參數。查看 Rake::TaskArguments 的代碼，你會發現并沒有定義相關的方法將參數傳給任務。 那么 Rake 是如何將參數提供給任務的呢？答案是 Rake 是使用了 method_missing 巧妙地實現了這個功能。 看看第64行 method_missing 的定義：
代碼如下:
def method_missing(sym, *args)
lookup(sym.to_sym)
end
在這個類中定義 method_missing 是為了保證能夠訪問到那些未定義的方法，而不是由Ruby拋出異常。 在 method_missing 中它調用了 lookup 方法：
代碼如下:
def lookup(name)
if @hash.has_key?(name)
@hash[name]
elsif @parent
@parent.lookup(name)
end
end
method_missing 調用 lookup，并將方法名以 Symbol(符號) 的形式傳遞給它。 lookup 方法將會在 @hash 中進行查找，它是在 Rake::TaskArguments 的構造函數中創建的。 如果 @hash 中包含該參數則返回，如果在 @hash 中沒有則 Rake 會嘗試調用 @parent 的 lookup。 如果該參數沒有找到，則什么都不返回。
這就是 Rake 如何巧妙地使用 method_missing 提供了訪問傳遞給Rake任務的參數的。 感謝Jim Weirich編寫了Rake。
結束語
我們討論了5個重要的Ruby鉤子方法，探索了它們是如何工作的，以及一些流行的框架/gem包是如何使用它們來提供一些優雅的功能。 我希望你能喜歡這篇文章。請在評論中告訴我們你所喜歡的Ruby鉤子，以及你使用它們所解決的問題。