Ruby中的反射(Reflection)应用实例
在java语言中,提供了发射机制,通过发射机制可以通过字符串构造出这个对象,可以获取对象的所有方法(包括私有方法),可以调用私有方法,可以更改成员变量的值(包括私有的成员变量)。
ruby也是面向对象的高级语言,当然也提供了反射机制,今天我们讨论通过类名称构造类对象的功能。
一、通过类名称构造类对象
我们先看普通的构造:
module modulea
#the class name, later we will use it to create the corresponding object
class_name_of_wood = "modulea::wood"
class_name_of_wooddesk = "modulea::wooddesk"
class_name_of_woodchair = "modulea::woodchair"
class wood
def initialize
@desc = "i am a primal wood"
end
def say
puts @desc
end
end
class wooddesk < wood
def initialize
@desc = "i am a desk made of wood"
end
def say_private
puts "actually, i have some bug but no public"
end
public :say
private :say_private
end
class woodchair < wood
def initialize
@desc = "i am a chair made of wood"
end
def say_private
puts "i want get married with a wooddesk..."
end
def smile
puts "ha hah hah haha ...."
end
public :say
private :say_private, :smile
end
end
定义了一个基础类wood,有两个子类:wooddesk, woodchair,子类有分别有一个私有方法 say_private。
我们new出对象来执行:
#the normal initailze
wood = modulea::wood.new
wood.say
desk = modulea::wooddesk.new
desk.say
chair = modulea::woodchair.new
chair.say
#try call the private method
puts "desk respond to say_private? #{desk.respond_to? :say_private}"
desk.say_private if desk.respond_to? :say_private
上面代码,执行public方法say,然后尝试执行private方法 say_private,执行先check是否能够执行,返回结果是不能执行,desk.respond_to? :say_private返回false:
i am a primal wood
i am a desk made of wood
i am a chair made of wood
desk respond to say_private? false
好,现在我们通过反射机制来构造对象,并尝试执行其私有方法。
我们注意到模块的定义中有三个常量,定义的是类名称,
#the class name, later we will use it to create the corresponding object
class_name_of_wood = "modulea::wood"
class_name_of_wooddesk = "modulea::wooddesk"
class_name_of_woodchair = "modulea::woodchair"
下面会通过这三个变量来理解module.constants方法。
下面代码片段,基于上面的类定义:
#get all module constants
obj_list = array.new
tmp_const_sym_list = modulea.constants
tmp_const_sym_list.each do | sym |
obj_list << modulea.const_get(sym)
puts "calss = #{sym.class}, value = #{sym}"
end
我们注意到 modulea.constants,这个方法是module模块中的,其作用是返回模块中所有常量的symbol对象。我们看结果输出:
calss = symbol, value = class_name_of_wood
calss = symbol, value = class_name_of_wooddesk
calss = symbol, value = class_name_of_woodchair
calss = symbol, value = wood
calss = symbol, value = wooddesk
calss = symbol, value = woodchair
从结果中看到,定义的三个常量和类名称都被返回了。所以注意:ruby中的常量是包含定义的常量(变量)和类名称,注意他们都是symbol对象。。
不过我们是需要根据类名称构造类对象,那么那三个常量就是没用的,需要删除。我们通过正则表达式匹配名字,来过滤。上面的代码修改一下:
#get all module constants
sym_list = array.new
tmp_const_sym_list = modulea.constants
tmp_const_sym_list.each do | sym |
puts "calss = #{sym.class}, value = #{sym}"
sym_list << modulea.const_get(sym) if /^wood\w*/ =~ sym.to_s
end
sym_list << modulea.const_get(sym) if /^wood\w*/ =~ sym.to_s,仅保存以wood开头的symbol,这样我们就过滤掉了那三个常量。
找都类名称之后,开始构造对象:
#create object from symbol
obj_list = array.new
sym_list.each do | sym |
obj = sym.new
obj_list << obj
puts "create the object: #{obj}"
end
begin
obj_list.each do | wood |
wood.say
end
调用symbol的new方法构造出次对象(sym.new),然后我们调用对象的say方法:
create the object: #
create the object: #
create the object: #
i am a primal wood
i am a desk made of wood
i am a chair made of wood
达到了我们预期的结果。
二、操作成员变量和私有方法
使用过java反射的同学们都知道,有了对象之后,操作成员变量和私有方法也就不在话下了。
ruby中也是一样。
先看操作成员变量的例子。我们尝试更改一个成员变量的值。(接着上一片文章的代码)
#manpulate instance variables
first_wood = obj_list.first
first_wood.instance_variables.each do | var |
#get the instance variable
puts "class of var = #{var.class}, value of var = #{var}"
var_value = first_wood.instance_variable_get(var)
puts "class of var_value = #{var_value.class}, value of var_value = #{var_value}"
#set the new value of instance varialbe
first_wood.instance_variable_set(var, var_value + "...and i was changed.")
first_wood.say
end
1、first_wood.instance_variables.each,我们得到一个wood对象,然后调用其instance_variables方法得到所有成员变量的名称(symbol对象)。
2、然后,调用对象的first_wood.instance_variable_get方法,传递成员变量名称,得到成员变量对象。
3、最后,我们通过first_wood.instance_variable_set,改变这个成员变量的值。
代码运行结果:
class of var = symbol, value of var = @desc
class of var_value = string, value of var_value = i am a primal wood
i am a primal wood...and i was changed.
再看调用私有方法:
#call private method
last_wood = obj_list.last
last_wood.method(:say_private).call
很简单,如果你知道方法名称,调用last_wood.method传入方法名,就可以得到一个method对象,然后调用method对象的call方法,结果是私有方法输出的内容:
i want get married with a wooddesk...
普通场景下用不到修改成员变量和调用私有方法,因为这是违反了面向对象的封装原则的,那么反射在什么场景下有用呢?从我个人经验来说我觉得两个地方有用:
1)单元测试。
2)面向方面编程。
这两种场景都需要调用私有方法或替换成员变量的值。
你觉得呢?
上一篇: Java中main()方法的用法介绍
下一篇: HTML5 新增内容