Ruby中的反射(Reflection)应用实例

时间:2022-09-17 17:00:48

在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)面向方面编程。
这两种场景都需要调用私有方法或替换成员变量的值。

你觉得呢?