Groovy探索 Visitor模式

Groovy探索 Visitor模式

Groovy语言中的Visitor模式的实现，其实也跟闭包有很大的、直接的关系。当然，你也可以完全不用闭包来实现Visitor模式，就像Java语言那样来实现。但使用了闭包的Visitor模式更加简单，更加易于扩展。所以，我们在Groovy语言中，倾向于使用闭包来实现Visitor模式。这也是我很久以来，都想把这篇文字放在《Groovy探索 闭包》系列中的原因，但由于Visitor模式的复杂性，使得我倾向于以模式的观点来说明它，以利于我们的理解。

Java语言实现的Visitor模式一向是难于理解的一个模式，它的实现基本上有两大类的接口，众多的实体实现。在这里我不多说，有兴趣的看官或者没有学过Java语言Visitor模式的，可以在网上找资料来看。

其实，Visitor模式的目的非常简单，就是把被访问者的数据结构和访问者的动作分离，有利于访问者的扩展。这里，值得注意的是：该模式强调的是被访问者要有一定的确定性，访问者才是可以扩展的。

在Groovy语言中，我们的访问者被简化成一个个的闭包，不再需要一个Visitor接口，让我们从一个简单得不能再简单的例子说起。

比如，我们有如下的一个被访问者对象：

def visitable = [1,2,3,4,5]

这是一个简单的数组对象，现在，我们的第一个访问者希望打印出被访问者的所有元素来。我们就可以这样来定义一个访问者：

def visitor1 = {

println it

}

现在，我们让访问者去访问被访问者：

visitable.each(visitor1)

运行结果为：

1

2

3

4

5

当然，我们使用Visitor模式的目的，就是要扩展访问者，现在，我们就可以扩展另外一个访问者了。

def total = 0

def visitor2 = {

total += it

}

我们也让这个访问者来访问被访问者：

visitable.each(visitor2)

println total

运行结果为：

15

通过上面的例子，我们可以看到，在使用Groovy语言实现的Visitor模式中，我们是如何使用闭包来实现Visitor接口的实现的。正是通过闭包，我们在Groovy语言实现的Visitor模式中，就再也找不到Visitor接口了。

现在，我们再理解Java语言实现的Visitor模式的Visitor接口，其实就是让访问者动作有一个实体类可以存在，因为在Java语言中，方法是不能独立存在的。而在Groovy语言中，方法能够以闭包的形式独立存在，所以就用不着Visitor接口了。

理解了这一层关系以后，我们上面的代码就可以进一步简化成如下的样子了：

visitable.each{

println it

}

visitable.each{

total += it

}

println total

在这里，我们连声明一个Visitor对象都省了，但它们实现的也是Visitor模式。

上面是一个最简单不过的例子，不能显示出Visitor模式的复杂性来。下面，我们就来说说一个相对复杂一点的例子来，进一步的分析Visitor模式。

这个例子说的是，我们在优惠期间到电脑店去买电脑及周边产品。电脑店在优惠期间是这样买商品的：电脑打九折，光盘是买5送1。现在，我们要买一台电脑，12张光盘，想知道我们花了多少钱。

现在，我们就来模拟这个场景。

首先，我们定义的是被访问者和访问者之间的接口类：

class Goods {

def accept(Closure doAction)

{

doAction(this)

}

}

这个Goods类的目的很简单，就是让访问者对象能够访问到被访问者对象，如果没有这个Goods类，那么上面的"accept"方法就要分布在各个被访问者类中。而"accept"方法中的输入参数"doAction"，就是访问者对象了。

现在，该我们的Computer类出场了：

class Computer extends Goods{

def amount

def price

def static DISCOUNT = 0.9

def totalPrice()

{

price*amount*DISCOUNT

}

def totalDiscount()

{

price*amount*(1-DISCOUNT)

}

}

它也很简单：有两个输入属性分别用来定义购买的数量和单价，一个常量属性用来定义折扣。两个方法分别来获取总价和总的折扣价。

同样的功能是Disk类，现在由它出场：

class Disk extends Goods{

def amount

def price

def totalPrice()

{

(amount-(amount/5 as int))*price

}

def totalDiscount()

{

(amount/5 as int)*price

}

}

它实现的是买五送一的活动。下面的Sales类来定义我们买了多少东西：

class Sales {

List goods

def accept(Closure doAction)

{

goods.each{

it.accept(doAction)

}

}

}

它的"accept"方法用来使得访问者能够访问我们所买的所有东西。当然，该方法的"doAction"就是我们的访问者对象了。

现在，一切就绪，我们就可以来访问被访问者了。

首先，我们想知道我们总共花了多少钱？

def mySales = new Sales(goods:[new Computer(amount:1,price:500),new Disk(amount:12,price:2)])

上面的初始化，我们共买了单价为500的电脑一台，单价为2的光盘12张。我们定义一个变量来存取我们所花的钱：

def totalPrice = 0

我们来计算我们总共花了多少钱：

mySales.accept{

totalPrice += it.totalPrice()

}

println "my total price is ${totalPrice}"

结果为：

my total price is 470.0

这样，一个稍微复杂一点的Visitor模式就全部实现了。

你可能要问了，我的访问者对象不是可以扩展吗？你扩展一个给我看看，好，我们现在来计算我们总共省了多少钱。

def totalDiscount = 0

mySales.accept{

totalDiscount += it.totalDiscount()

}

println "my total discount is ${totalDiscount}"

运行结果为：

my total discount is 54.0

使用闭包实现的Visitor模式还有一个好处是能够扩展被访问者，使用在Java语言中实现的Visitor所难以做到的，如果要做到，一般要用到反射技术。而在Groovy语言闭包所实现的Visitor中，我们可以很轻松的扩展被访问者。

比如，我们现在还想买一个鼠标，它没有折扣，如下：

class Mouse extends Goods{

def amount

def price

def totalPrice()

{

amount*price

}

def totalDiscount()

{

0

}

}

现在，我们的客户端就可以这样使用：

def mySales = new Sales(goods:[new Computer(amount:1,price:500),new Disk(amount:12,price:2),

new Mouse(amount:1,price:10)])

def totalPrice = 0

mySales.accept{

totalPrice += it.totalPrice()

}

println "my total price is ${totalPrice}"

def totalDiscount = 0

mySales.accept{

totalDiscount += it.totalDiscount()

}

println "my total discount is ${totalDiscount}"

运行结果为：

my total price is 480.0

my total discount is 54.0

可以看出，在Groovy语言中使用闭包实现的Visitor是非常好理解的，简单到你没有意识到你是在使用Visitor模式，而且，这个Visitor模式也很容易扩展它的被访问者。就像上面的例子那样。