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,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
,
physScore:
80
,totalScore:
405
)
def
s4 =
new
Student(no:
'008'
,name:
'Wallam'
,chinScore:
98
,mathScore:
85
,
physScore:
75
,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
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。
