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 = []

 

    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