Groovy探索之Delegate模式 一

                       Groovy探索之Delegate模式 一
 
Delegate即是委派的意思。在Java语言中,很少提到委派或者委派模式,即使用到了也不说,这是因为Java语言的特点,实现起委派来相当的繁琐,而且只能适用于一些简单的场合。
但现实的需求是,由于敏捷编程的兴起,重构技术也得到了大家的广泛使用;要使用重构,其中的一个重要原则是:使用组合代替聚合,这样才能方便重构。使用组合,最终是要使用到委派技术了。同时,我们经常有这样的一些需求,我们只想继承一个类的部分功能,而另外一部分功能是我们不想要、甚至是对我们有害的功能,这时候,我们只能使用委派技术,而不能使用继承了。
基于上面的一些分析,我们知道,继承和委派技术都能扩展一个类,使它拥有另外一个类的部分或者全部功能。但委派技术更为灵活,它可以使得一个类可以全部或部分的扩展得到另一个类的功能,而继承只能是全盘接收。
说了这么多,您可能要说了,我想看一些例子,或者你举出一些例子来证明你的观点啊。这正是下面要做的事。
比方说,有下面的一个简单类:
class Foo {
   
    deftest()
    {
       println'have a test'
    }
   
    def foo()
    {
       println'foo...'
    }
 
}
 
现在有一个新的类要实现它的全部功能,即“test”和“foo”方法。当然,我们首先想到的是继承:
class FooSon extends Foo{
   
    def testAgain()
    {
       println'test it again'
    }
 
}
 
这样,我们就可以在FooSon中使用Foo的功能了,比如:
   
     def foo = new FooSon()
     
     foo.test()
     
     foo.foo()
     
     foo.testAgain()
 
 
它的运行结果为:
have a test
foo...
test it again
 
这样的继承无疑是完美的,子类不用写太多代码,就完全实现了父类的功能。但它最明显的缺点是,如果我有这样的需求,我只想在子类中要Foo类的“test”方法,不想要“foo”方法,在这里继承能办到吗?
如果您的答案是否定的,请您跟着我往下看。
下面,我将使用委派技术来产生一个新类,同样继承Foo类的所有方法:
class Foo2 {
   
    private delegate = new Foo()
   
    deftest()
    {
       this.delegate.test()
    }
    def foo()
    {
       this.delegate.foo()
    }
   
    def testAgain()
    {
       println'test it again'
    }
}
 
 
通过这个例子,您可以看到,所谓“委派”的意思是:一个类要实现的功能,比如Foo2类要实现的“test”和“foo”方法,但它并未真正去实现这些功能,而是把这些功能委派给另一个类去实现,如Foo2类的“test”和“foo”方法,实际上是交给Foo类去实现了。
可以测试一下上面的例子:
     
     def foo = new Foo2()
     
     foo.test()
     foo.foo()
 foo.testAgain()
 
运行结果为:
have a test
foo...
test it again
 
当然,我还记得上面提出来的需求,新的类只想实现Foo类的“test”方法,不想要“foo”方法。使用委派技术就很好实现了:
class Foo2 {
   
    private delegate = new Foo()
   
    deftest()
    {
       this.delegate.test()
    }
    def testAgain()
    {
       println'test it again'
    }
}
 
 
看了上面的例子,您可能会说,委派技术很简单,也很好理解,但就是实现起来太繁琐了,我要想在子类中实现父类的方法,非得在子类中把这些方法重写一遍不可,远远没有继承来得方便。是的,这就是在Java语言中很少提到委派技术的原因。
但是,我们应该知道的是,Groovy语言是基于Java语言的,这使得它必定有超过Java语言之处,而对委派技术的动态实现正是Groovy语言动态的一个重要方面。下面,我将举出一个例子来实现上面的功能的动态委派技术。
 
class Foo3 {
   
    private delegate = new Foo()
   
    def invokeMethod(String name,Object args)
    {
       this.delegate.invokeMethod(name,args)
    }
   
    def testAgain()
    {
       println'test it again'
    }
 
}
 
是了,我们又通过“invokeMethod”方法来实现动态委派技术,我已经记不清“invokeMethod”方法实现了我们的多少功能。
一个“invokeMethod”方法,就不管你要实现父类的多少功能,统统通过这一个方法就能实现了。下面来测试一下:
 
     def foo = new Foo3()
     
     foo.test()
     foo.foo()
 foo.testAgain()
 
结果为:
have a test
foo...
test it again
 
如果你在动态实现中,不想要父类的“foo”方法,也是可以实现的:
class Foo3 {
   
    private delegate = new Foo()
   
    def invokeMethod(String name,Object args)
    {
       if(name != 'foo')
       {
           this.delegate.invokeMethod(name,args)
       }
    }
   
    def testAgain()
    {
       println'test it again'
    }
 
}
 
值得注意的是,Groovy语言还有很多其他的方法来实现动态委派,这将是《Groovy探索之Delegate模式二》及《三》中要谈到的。
展开阅读全文

没有更多推荐了,返回首页