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 = []
protected
void
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)
}
}
protected
void
nodeCompleted(Object parent, Object node) {
}
}
相比前面一篇的
Builder
来说,这个
ConditionBuilder
相当的简单,使用两个
List
对象来保存属性名和顺序逆序的问题。其他就不要我多说了。
下面来看看排序功能是怎么使用这个
ConditionBuilder
的:
class
SortHelper{
def
list
public
SortHelper(list)
{
this
.list = list
}
def
sort
(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
}
return
this
.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
}
public
int
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