回调函数设计及应用（Java）——分组模式设计

背景：在项目中因为牵涉到大数据的处理，需要经常在各个类中用到分组的模式。同样地流程控制代码，到处copy，导致一个地方出错，每个地方都需要修改。因此考虑将此模式提取出来。

分析：鉴于分组模式是固定的，分组后需要处理的事务是动态的，让我联想到JavaScript里经常用的回调函数正好如此。因此可以结合Java语言特性借鉴js处理方式，将动态方法体放到回调函数中。

设计：

分组模式基本流程是：  1.根据总数/每组分配个数，得到组数N

                            2.根据总数%每组分配个数，得到余数组组员个数M

                            3.如果总数整除每组分配个数，M值为0，总组数为N，否则总组数为N+1

                            4.进行分组循环

                            5.按每组分配的个数进行组内循环，如果M值不为0，则最后一组组内循环M次

设计：                   1.根据分组模式基本流程可知分组流程需要参数为总数、每组分配个数、组内循环具体需要执行的方法体

                           2.分组模式中产生了内部变量当前循环的组号i、当前循环的组内编号j,总计分成的组数，因此回调函数需要传出这三个参数，提供给动态方法体调用。

                           3.借用java中的方法重载来实现动态方法体，借助接口来实现回调函数的可扩展性。

具体实现：             1.IDealByGroupCallback.java 回调函数接口类

                          2.DealByGroupCallback.java  回调函数接口实现类

                          3.DealByGroup.java             分组流程实现类

                          4.TestDemo.java                 测试调用类

代码：IDealByGroupCallback.java    回调函数接口类

public interface IDealByGroupCallback {
    public void func(int index,int groupIndex,int totalgroup);
}

        DealByGroupCallback.java    回调函数接口实现类

public class DealByGroupCallback implements IDealByGroupCallback{
    public DealByGroupCallback() {
      }
    public void func(int index,int groupIndex,int totalgroup){
        System.out.print("index:" + index);
        System.out.print(" groupIndex:" + groupIndex);
        System.out.println(" totalgroup:" + totalgroup);
    }
}

        DealByGroup.java    分组流程实现类

public class DealByGroup {
      int totalCount;
      int perCount;
      IDealByGroupCallback dealByGroupCallback;
      public DealByGroup(int totalCount, int perCount,IDealByGroupCallback dealByGroupCallback)
      {
          this.totalCount = totalCount;
          this.perCount = perCount;
          this.dealByGroupCallback = dealByGroupCallback;
      }
      public void deal()
      {
        //在这里写分组查询
        int n = totalCount / perCount;
        int m = totalCount % perCount;  
        if (m == 0)
        {
            n--;
        }
        int len = perCount;
        for (int i = 0; i <= n; i++)
        {
            if(i == n && m != 0)
            {
                len = m;
            }
            for(int j = perCount*i; j < perCount*i+len; j++)
            {
                //接口类的方法
                dealByGroupCallback.func(j,i,n+1);
            }
        }        
      }
}

调用：TestDemo.java

public class TestDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
           final int ss = 0;
           DealByGroup dealByGroup = new DealByGroup(100,11,new DealByGroupCallback() {
                  public void func(int index,int groupIndex,int totalgroup) {
                        //这里可以写具体的方法体的话可以调用局部变量ss，也可以将方法体写在另外的函数中，在这里执行。
                        System.out.println(index + "aaaaaaaaaa" + ss);
                  }});
           dealByGroup.deal();
           DealByGroup dealByGroup2 = new DealByGroup(100,11,new DealByGroupCallback());
           dealByGroup2.deal();
    }    
    

}

 --OVER

后记：推测线程的管理也是这种模式。new Thread(<A implements Runnable>)

这两天出于要面试的原因，再次复习设计模式，发现其实这个回调函数的实现，应用了两种设计模式。

其一：策略模式

IDealByGroupCallback ：策略的接口

DealByGroupCallback  ：策略的实现

DealByGroup ：策略的调用者

在这里DealByGroupCallback，这个策略的具体实现是动态的，根据业务的不同，将不同的业务逻辑放到DealByGroupCallback的func中去。这里应用了类的继承来实现策略的动态拓展，

以不变应万变。

其一：门面模式

DealByGroup相当于门面类，将方法的反复调用操作流程都放到一个类中，main作为调用者不需要关注流程怎么实现, 只需要将操作的内容交给DealByGroup。