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
 
总分是顺序排列,MikeAlice 405,排在前面,TomWallace 434排在后面;第二次以数学成绩排逆序,Mike数学80Alice70,当然是MikeAlice前面,同理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
 
 
 
展开阅读全文

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