Ruby库中委托Delegator类的实现

feiyang10086

Ruby库中委托Delegator类的实现

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

既然采用ruby,它的库一般来说,用起来会更加funny,更加自然.
如同singleton单例库,你写一个类

Java代码

1. 1.class Klass   
   
2. 2. def method   
   
3. 3. end   
   
4. 4.end  
   
5. class Klass
   
6. def method
   
7. end
   
8. end
   
9. 
   
10. 想让它成为单例类,只需:
    
11. 
    
12. Java代码  
    
13. 1.require 'singleton'  
    
14. 2.class Klass   
    
15. 3. include Singleton   
    
16. 4. def method   
    
17. 5. end   
    
18. 6.end  
    
19. require 'singleton'
    
20. class Klass
    
21. include Singleton
    
22. def method
    
23. end
    
24. end

复制代码

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

好了,题外话讲完后,我们来看看Delegator吧.
打开ruby库的delegate.rb文件.
代码行有多少,好家伙,大概330行.除去注释,实际有效代码有100行吧.
第1步看看使用接口先:

Java代码

1. 1.# SimpleDelegator's implementation serves as a nice example here.   
   
2. 2.#   
   
3. 3.#    class SimpleDelegator < Delegator   
   
4. 4.#      def initialize(obj)   
   
5. 5.#        super             # pass obj to Delegator constructor, required   
   
6. 6.#        @_sd_obj = obj    # store obj for future use   
   
7. 7.#      end   
   
8. 8.#   
   
9. 9.#      def __getobj__   
   
10. 10.#        @_sd_obj          # return object we are delegating to, required   
    
11. 11.#      end   
    
12. 12.#   
    
13. 13.#      def __setobj__(obj)   
    
14. 14.#        @_sd_obj = obj    # change delegation object, a feature we're providing   
    
15. 15.#      end   
    
16. 16.#   
    
17. 17.#      # ...   
    
18. 18.#    end  
    
19. # SimpleDelegator's implementation serves as a nice example here.
    
20. #
    
21. #    class SimpleDelegator < Delegator
    
22. #      def initialize(obj)
    
23. #        super             # pass obj to Delegator constructor, required
    
24. #        @_sd_obj = obj    # store obj for future use
    
25. #      end
    
26. #
    
27. #      def __getobj__
    
28. #        @_sd_obj          # return object we are delegating to, required
    
29. #      end
    
30. #
    
31. #      def __setobj__(obj)
    
32. #        @_sd_obj = obj    # change delegation object, a feature we're providing
    
33. #      end
    
34. #
    
35. #      # ...
    
36. #    end

复制代码

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

Java代码

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

复制代码

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

cinanine

ruby技术相当熟练

2gua

ruby技术相当熟练
cinanine 发表于 2011-11-01 14:47

    你？