Groovy探索之Builder 四

Groovy探索之Builder 四

本来这个系列《Groovy探索之Builder》计划三个部分讲述完，也就是前面三篇就完了。之所以现在要加上这一篇，是因为我在和同事讨论的时候，他给我提出一个问题。说从最初接触Builder是因为MarkupBuilder，它是用来生成xml文件，后来你又以table作为例子，给人的感觉好像Builder都是用来解决此类问题的，如xml、html或者Swing等等，都是一些显示方面的问题。

当然不是这样的，Builder模式可以解决的问题很广泛。至于何时使用和如何使用的问题，需要我们对Builder模式熟能生巧后才能做到的。下面试着再举一例来看看Builder模式在其他方面的使用。

记得我们以前讲过的List对象排序的问题，就是对学生成绩进行排序，如下：

class Student {

String no;

String name;

float chinScore;

float mathScore;

float englScore;

float physScore;

float chemScore;

float totalScore;

}

现在又有如下的要求：

比如，你是某大学数学系的招生人员，你会要求对学生成绩做如下排序——我首先要看总分，总分越高越可能是我要的；其次，因为我要招数学系的学生，当然希望他的数学成绩好，也就是说当总分差不多的时候，我要再以数学成绩排序；最后，我还要看看语文成绩，因为理解和表达能力也是很重要的。

当然，如果你是一个外语系的招生人员，你的要求又不一样；还有物理学、化学系等等。

所以就有了这样一个排序的需求——先对其中的元素排序，然后在第一次排序的基础上，又根据第二个元素做第二次排序。还要注意的是还有顺序和逆序的问题。

现在我们要解决这样一个问题，当然首先是接口的问题，也就是输入参数和输出参数的问题。输出当然好说，就是一个排好序的List对象。但在构造输入参数的时候就遇到问题了。比如，我首先想到的是输入参数为一个数组，要排序的属性名按次序保存在数组里。如：props=[totalScore,mathScore,chinScore]，这样是不错了，但顺序和逆序的问题怎么办呢？显然，这种设想已经被排除。

当然，第二种直接的想法就是创建一个JavaBean来存储这些参数，如：

class ArguModel

{

String propName

String desc

}

然后，输入参数就可以这样表示了：

Props = [new ArguModel(propName:’totalScore’,desc:’1’),new ArguModel(propName:’mathScore,desc:’1’), new ArguModel(propName:’chinScore,desc:’1’)]

可以想象，这样的参数创建也是相当的麻烦，我喜欢下面的参数方式：

builder.sortBy{

prop ‘totalScore’

prop(‘mathScore’,[desc:’1’])

prop ‘chinScore’

}

这是一种DSL方式的参数输入，对功能的使用者来说，显得简单直观。

下面，我们就来实现这种DSL方式的参数输入。

class ConditionBuilder extends BuilderSupport{

def props = []

def dscs = []

protectedvoid setParent(Object parent, Object child){

}

protected Object createNode(Object name){

}

protected Object createNode(Object name, Object value){

props.add(value)

dscs.add('0')

}

protected Object createNode(Object name, Map attributes){

}

protected Object createNode(Object name, Map attributes, Object value){

props.add(value)

attributes.each{

dscs.add(it.value)

}

}

protectedvoid nodeCompleted(Object parent, Object node) {

}

}

相比前面一篇的Builder来说，这个ConditionBuilder相当的简单，使用两个List对象来保存属性名和顺序逆序的问题。其他就不要我多说了。

下面来看看排序功能是怎么使用这个ConditionBuilder的：

class SortHelper{

def list

public SortHelper(list)

{

this.list = list

}

defsort(builder)

{

builder.props.eachWithIndex{

it,i ->

ModelComparator comparator = new ModelComparator(it,builder.dscs[i])

if(this.list.get(0) instanceof List)

{

def li = []

this.list.each{

iter ->

Collections.sort(iter,comparator)

groupAll(iter,it).each{

iter1 ->

li.add(iter1)

}

}

this.list = li

}

else

{

Collections.sort(this.list,comparator)

this.list = groupAll(this.list,it)

}

}

if(this.list.get(0) instanceof List)

{

def retns = []

this.list.each{

retns.addAll(it)

}

this.list = retns

}

returnthis.list

}

def groupAll(co,prop)

{

def results = []

int num=0

while(num<co.size())

{

def l = group(co,co.get(num),prop)

results.add(l)

num = num+l.size()

}

return results

}

def group(co,model,prop)

{

return co.findAll{

it."${prop}" == model."${prop}"

}

}

}

可以看到，取得输入参数builder以后，就可以使用它的两个List对象，从中取得需要排序的属性名和顺序逆序。然后就是排序的算法了。

下面，我们就可以来测试一下了。

首先给出ModelComparator类：

import java.util.Comparator

class ModelComparator implements Comparator{

String prop;

String dsc;

public ModelComparator(prop,dsc)

{

this.prop = prop

this.dsc = dsc

}

publicint compare(Object node1, Object node2) {

try

{

float f1 = Float.parseFloat(String.valueOf(node1."${prop}"))

float f2 = Float.parseFloat(String.valueOf(node2."${prop}"))

if("1".equals(this.dsc))

{

return f2.compareTo(f1);

}

else

{

return f1.compareTo(f2)

}

}

catch(Exception e)

{

String v1 = node1."${prop}"

String v2 = node2."${prop}"

if("1".equals(this.dsc))

{

return v2.compareTo(v1)

}

else

{

return v1.compareTo(v2)

}

}

}

}

下面我们就开始测试。

首先是初始化：

def s1 = new Student(no:'001',name:'Tom',chinScore:88,mathScore:90,englScore:66,

physScore:100,chemScore:90,totalScore:434)

def s2 = new Student(no:'003',name:'Alice',chinScore:99,mathScore:70,englScore:89,

physScore:60,chemScore:87,totalScore:405)

def s3 = new Student(no:'007',name:'Mike',chinScore:69,mathScore:80,englScore:89,

physScore:80,chemScore:87,totalScore:405)

def s4 = new Student(no:'008',name:'Wallam',chinScore:98,mathScore:85,englScore:89,

physScore:75,chemScore:87,totalScore:434)

def list = [s1,s2,s3,s4]

然后做第一次排序：

def cond = new ConditionBuilder()

cond.sortBy

{

prop 'totalScore'

prop('mathScore',[dsc:'1'])

}

def list1 = new SortHelper(list).sort(cond)

println'first sort: '

list1.each{

println it.name

}

打印结果为：

first sort:

Mike

Alice

Tom

Wallam

总分是顺序排列，Mike和Alice 405，排在前面，Tom和Wallace 434排在后面；第二次以数学成绩排逆序，Mike数学80，Alice70，当然是Mike在Alice前面，同理Tom也在Wallam前面。

我们再做一个测试：

def cond1 = new ConditionBuilder()

cond1.sortBy

{

prop 'totalScore'

prop('chinScore',[dsc:'1'])

}

def list2 = new SortHelper(list).sort(cond1)

println'second sort: '

list2.each{

println it.name

}

打印结果为：

second sort:

Alice

Mike

Wallam

Tom