主题：Ruby库中委托Delegator类的实现

中关村村草

主题：Ruby库中委托Delegator类的实现

委托的模式上一篇偷天换日已经解释,这里只讲解里面的Delegator库的实现.

既然采用ruby,它的库一般来说,用起来会更加funny,更加自然.
如同singleton单例库,你写一个类
Java代码  
class Klass   
def method   
end   
end  

class Klass
def method
end
end

想让它成为单例类,只需:
Java代码  
require 'singleton'  
class Klass   
include Singleton   
def method   
end   
end  

require 'singleton'
class Klass
include Singleton
def method
end
end

如此简单,它自动将构造方法置为隐藏,自动加载多线程锁调用,哇,还是线程安全,如果是自己写那得不少代码,而且使用ruby的Module机制,无须继承任何类,毫无副作用...

好了,题外话讲完后,我们来看看Delegator吧.
打开ruby库的delegate.rb文件.
代码行有多少,好家伙,大概330行.除去注释,实际有效代码有100行吧.
第1步看看使用接口先:
Java代码  
# SimpleDelegator's implementation serves as a nice example here.   
#   
#    class SimpleDelegator < Delegator   
#      def initialize(obj)   
#        super             # pass obj to Delegator constructor, required   
#        @_sd_obj = obj    # store obj for future use   
#      end   
#   
#      def __getobj__   
#        @_sd_obj          # return object we are delegating to, required   
#      end   
#   
#      def __setobj__(obj)   
#        @_sd_obj = obj    # change delegation object, a feature we're providing   
#      end   
#   
#      # ...   
#    end  

# SimpleDelegator's implementation serves as a nice example here.
#
#    class SimpleDelegator < Delegator
#      def initialize(obj)
#        super             # pass obj to Delegator constructor, required
#        @_sd_obj = obj    # store obj for future use
#      end
#
#      def __getobj__
#        @_sd_obj          # return object we are delegating to, required
#      end
#
#      def __setobj__(obj)
#        @_sd_obj = obj    # change delegation object, a feature we're providing
#      end
#
#      # ...
#    end

这就是说只要继承Delegator,然后实现__getobj__与__setobj__方法即可.
这个使用方法在上一篇偷天换日中即用这个方法.
想想也是,如此的接口也很简洁了.
再看如何实现的:
Java代码

1. class Delegator   
   
2.   
   
3.   #   
   
4.   # Pass in the _obj_ to delegate method calls to.  All methods supported by   
   
5.   # _obj_ will be delegated to.   
   
6.   #   
   
7.   def initialize(obj)   
   
8.     #拿到所有类的实例方法,去掉几个   
   
9.     #因为Kernel是一个module,它会被所有类包含.可参阅RubyHackGuide进行掌握.   
   
10.     preserved = ::Kernel.public_instance_methods(false)   
    
11.     preserved -= ["to_s","to_a","inspect","==","=~","==="]   
    
12.     for t in self.class.ancestors   
    
13.       preserved |= t.public_instance_methods(false)   
    
14.       preserved |= t.private_instance_methods(false)   
    
15.       preserved |= t.protected_instance_methods(false)   
    
16.       break if t == Delegator   
    
17.     end   
    
18.     preserved << "singleton_method_added"  
    
19.     for method in obj.methods   
    
20.       # 搜集到所有实例方法,   
    
21.       # 以下开始利用eval动态往本代理中添加方法   
    
22.       next if preserved.include? method   
    
23.       begin   
    
24.        # 这里的self是实例本身,不是类,请注意.   
    
25.        # 所以定义的方法都是自身可以用,而不是整个委托类.   
    
26.        # 异常处理的时候使用了一个的技巧,将委托的异常信息给去掉了,更加透明了...(好阴啊,如果是库出问题了连个跟踪的地儿都找不到)   
    
27.     eval <<-EOS   
    
28.       def self.#{method}(*args, &block)   
    
29.         begin   
    
30.           __getobj__.__send__(:#{method}, *args, &block)   
    
31.         rescue Exception   
    
32.           $@.delete_if{|s| /:in `__getobj__'$/ =~ s} #`   
    
33.           $@.delete_if{|s| /^\\(eval\\):/ =~ s}   
    
34.           Kernel::raise   
    
35.         end   
    
36.       end   
    
37.     EOS   
    
38.       rescue SyntaxError   
    
39.         raise NameError, "invalid identifier %s" % method, caller(4)   
    
40.       end   
    
41.     end   
    
42.   end   
    
43.   alias initialize_methods initialize   
    
44.   
    
45.   # 这个method_missing是重新实现是怕被委托的那小子动态添加方法,那'我'(委托类)不能不支持啊,所以添加在这里.   
    
46.   # 那我想问原作者,你上述的实现期不多余了,就只为能再透明点啊...   
    
47.   # Handles the magic of delegation through \_\_getobj\_\_.   
    
48.   def method_missing(m, *args)   
    
49.     target = self.__getobj__   
    
50.     unless target.respond_to?(m)   
    
51.       super(m, *args)   
    
52.     end   
    
53.     target.__send__(m, *args)   
    
54.   end   
    
55.   
    
56.   #   
    
57.   # Checks for a method provided by this the delegate object by fowarding the   
    
58.   # call through \_\_getobj\_\_.   
    
59.   #   
    
60.   def respond_to?(m)   
    
61.     return true if super  
    
62.     return self.__getobj__.respond_to?(m)   
    
63.   end   
    
64.   
    
65.   #   
    
66.   # This method must be overridden by subclasses and should return the object   
    
67.   # method calls are being delegated to.   
    
68.   #   
    
69.   # 你继承了后老实实现它吧.   
    
70.   def __getobj__   
    
71.     raise NotImplementedError, "need to define `__getobj__'"  
    
72.   end   
    
73.   
    
74.   # 这些为了可以使用marshal进行外部类存储.   
    
75.   # 如果不使用它,完全不用理会.   
    
76.   # Serialization support for the object returned by \_\_getobj\_\_.   
    
77.   def marshal_dump   
    
78.     __getobj__   
    
79.   end   
    
80.   # Reinitializes delegation from a serialized object.   
    
81.   def marshal_load(obj)   
    
82.     initialize_methods(obj)   
    
83.     __setobj__(obj)   
    
84.   end   
    
85. end  
    
86. 
    
87. class Delegator
    
88. 
    
89.   #
    
90.   # Pass in the _obj_ to delegate method calls to.  All methods supported by
    
91.   # _obj_ will be delegated to.
    
92.   #
    
93.   def initialize(obj)
    
94.     #拿到所有类的实例方法,去掉几个
    
95.     #因为Kernel是一个module,它会被所有类包含.可参阅RubyHackGuide进行掌握.
    
96.     preserved = ::Kernel.public_instance_methods(false)
    
97.     preserved -= ["to_s","to_a","inspect","==","=~","==="]
    
98.     for t in self.class.ancestors
    
99.       preserved |= t.public_instance_methods(false)
    
100.       preserved |= t.private_instance_methods(false)
     
101.       preserved |= t.protected_instance_methods(false)
     
102.       break if t == Delegator
     
103.     end
     
104.     preserved << "singleton_method_added"
     
105.     for method in obj.methods
     
106.       # 搜集到所有实例方法,
     
107.       # 以下开始利用eval动态往本代理中添加方法
     
108.       next if preserved.include? method
     
109.       begin
     
110.        # 这里的self是实例本身,不是类,请注意.
     
111.        # 所以定义的方法都是自身可以用,而不是整个委托类.
     
112.        # 异常处理的时候使用了一个的技巧,将委托的异常信息给去掉了,更加透明了...(好阴啊,如果是库出问题了连个跟踪的地儿都找不到)
     
113.         eval <<-EOS
     
114.           def self.#{method}(*args, &block)
     
115.             begin
     
116.               __getobj__.__send__(:#{method}, *args, &block)
     
117.             rescue Exception
     
118.               $@.delete_if{|s| /:in `__getobj__'$/ =~ s} #`
     
119.               $@.delete_if{|s| /^\\(eval\\):/ =~ s}
     
120.               Kernel::raise
     
121.             end
     
122.           end
     
123.         EOS
     
124.       rescue SyntaxError
     
125.         raise NameError, "invalid identifier %s" % method, caller(4)
     
126.       end
     
127.     end
     
128.   end
     
129.   alias initialize_methods initialize

复制代码

1.   # 这个method_missing是重新实现是怕被委托的那小子动态添加方法,那'我'(委托类)不能不支持啊,所以添加在这里.
   
2.   # 那我想问原作者,你上述的实现期不多余了,就只为能再透明点啊...
   
3.   # Handles the magic of delegation through \_\_getobj\_\_.
   
4.   def method_missing(m, *args)
   
5.     target = self.__getobj__
   
6.     unless target.respond_to?(m)
   
7.       super(m, *args)
   
8.     end
   
9.     target.__send__(m, *args)
   
10.   end
    
11. 
    
12.   #
    
13.   # Checks for a method provided by this the delegate object by fowarding the
    
14.   # call through \_\_getobj\_\_.
    
15.   #
    
16.   def respond_to?(m)
    
17.     return true if super
    
18.     return self.__getobj__.respond_to?(m)
    
19.   end
    
20. 
    
21.   #
    
22.   # This method must be overridden by subclasses and should return the object
    
23.   # method calls are being delegated to.
    
24.   #
    
25.   # 你继承了后老实实现它吧.
    
26.   def __getobj__
    
27.     raise NotImplementedError, "need to define `__getobj__'"
    
28.   end

复制代码

# 这些为了可以使用marshal进行外部类存储.
  # 如果不使用它,完全不用理会.

1.   # Serialization support for the object returned by \_\_getobj\_\_.
   
2.   def marshal_dump
   
3.     __getobj__
   
4.   end
   
5.   # Reinitializes delegation from a serialized object.
   
6.   def marshal_load(obj)
   
7.     initialize_methods(obj)
   
8.     __setobj__(obj)
   
9.   end
   
10. end

复制代码

所有的解析在上面的注释里了.
这里需要你的ruby技术相当熟练,掌握ruby元编程技能.因能力有限,欢迎就不同的观点进行探讨.
写在这里后,据松本行弘说forwardable模块更加优秀.有时间可以再研究下.
最后抱怨一下,ruby库的测试不完善啊,偶尔会出现一些问题,还需要进行猴子补丁..

2gua

怎么这么多重复的帖子呢？