在ruby中，当某些特定的事件发生时，将调用回调方法和钩子方法。事件有如下几种：
- 调用一个不存在的对象方法
- 类混含一个模块
- 定义类的子类
- 给类添加一个实例方法
- 给对象添加一个单例方法
- 引用一个不存在的常量
对以上的事件，都可以为之编写一个回调方法，当该事件发生时，这个回调方法被执行。这些回调方法是针对某个对象，或者某个类的，而不是全局的。
下面给出一些例子：
1 Method_missing拦截不能识别的消息
在前面说过，根据对象模型来进行方法查找，如果没有找到，会抛出一个NoMethodError异常，除非定义了一个名为method_missing的方法。
如下：
class C
def method_missing(m)
puts "there is no method #{m}"
end
end
C.new.hello
输出：
there is no method hello
类C中没有定义实例方法hello(它的方法查找路径上也没有)，因此调用method_missing。
2 用Module#included捕捉混含操作
当一个模块被混入到类（或者另一个模块）中，如果该模块的included方法已经定义，那么该方法就会被调用。该方法的参数就是混入该模块的类。
如下：
module M
def self.included(c)
puts "module M is included by #{c}"
end
end
class C
include M
end
输出：
module M is included by C
当模块M被混入到C中，模块M的included方法被调用了。
这种方式可以用来定义类方法，如上面的代码中，在self.included中就可以定义类c的类方法，或者给单例类添加一个模块
如下：
module M
def self.included(c)
puts "module M is included by #{c}" def c.m1
puts "this is class #{c}'s class method m1 "
end c.extend(N)
end
module N
def method
puts "hello world"
end
end
end
class C
include M
end
p C.singleton_methods
输出：
module M is included by C
[:m1, :method]
如代码，5-7行定义了一个类方法，该类是包含模块M的类（此例中就是C），9行将模块N加入了该类的单例类中。在20行的输出类C的单例方法可以看出加入成功。
3 用Class#inherited拦截继承
当为一个类定义了inherited方法，那么在为它生成子类时，inherited会被调用，唯一的调用参数就是新的子类的名字。
如下：
class C
def self.inherited(subclass)
puts "#{self} got a new subclass #{subclass} "
end
end
class D < C
end
class E < D
end
输出：
C got a new subclass D
D got a new subclass E
当D继承C时，调用了这个钩子方法，输出C got a new subclass D。同时，D的单例类中也有了C的类方法，因此在E继承D时，也会调用调用D的这个钩子方法。
4 Module#const_missing
当给定的模块或者类中引用了一个不可识别的常量时，该方法被调用。
如下：
class C
def self.const_missing(const)
puts "#{const} is undefined-setting "
const_set(const,1)
end
end
puts C::A
输出
A is undefined-setting
1
常量A没有被定义，因此调用了const_missing方法。在方法中把它定义为1。
5 Module#method_added
当新定义一个方法时，会调用这个方法。
如下：
module M
def self.method_added(method)
puts "method #{method} is added in M"
end
def m1
end
end
输出
method m1 is added in M
ruby中钩子方法很多，覆盖了绝大多数值得注意的事件。这里只给出一些常见的，给自己参考，给大家参考。