从诸葛亮的三个锦囊妙计谈策略模式

话说当年东吴孙权为刘备借走了荆州不还而耿耿于怀，却不料甘夫人去世，周郎顿时计上心来，让孙权将其妹嫁与刘备，骗刘备来东吴完婚。刘备又不是傻子，当然知道其中的猫腻，当即表态：打死也不去。诸葛亮却说无妨，当下给了赵云三个锦囊妙计，让他陪刘备去东吴完婚……最后的结果大家都知道，赵云在恰当的时候一一打开三个锦囊妙计，从而将危机一一化解。周瑜只落了个“周郎妙计安天下，赔了夫人又折兵”的笑柄。

这个故事，我们感兴趣的是三个锦囊妙计。诸葛亮一定是运用策略模式的高手，我们想啊：诸葛亮为什么要这么麻烦，做三个锦囊，他完全可以只做一个锦囊，将这三个妙计都写在它上面。可他没有这么做，而是正确的运用了策略模式做了三个锦囊。这样做的好处十分明显：诸葛亮一个锦囊写一个妙计，他的思路十分清晰，不会三个计策相互混乱。而赵云看妙计的时候也十分方便，什么时候看哪个妙计，使用十分方便，如果三个妙计混在一起，他就没这么方便了。

现在看来，这个故事正包含了策略模式的解决问题的思路：解决某一问题有多种方法或算法，如诸葛亮给了三个妙计，类的提供者要将这多种方法或算法独立开来，如诸葛亮将三个妙计分三个锦囊装，类的使用者，如赵云，在相应的条件，如故事中的恰当时间，使用相应的方法或算法。

前面我们说过命令模式，命令模式是对行为的封装；策略模式其实跟它的解决思路一样，是对算法的封装。当然，它们都一样的拥有同一个接口。

下面我们以一些例子来详细的说一说策略模式。

首先的一个例子是我们对数组的排序，对数组的排序有很多算法，我们想做一个由用户指定一个整形数组和对它排序的算法，我们给出结果这样一个方法，我们可以这样做：

public int[] sort(int[] inArray,String type)

{

       if(type.equals(“a”))

        {

               int k = 0;

               for(int i=0;i<inArray.length;i++)

               {

                      for(int j=i+1;j<inArray.length;j++)

                      {

                             if(inArray[i]> inArray[j])

                             {

                                    k = inArray[i];

                                    inArray[i] = inArray[j];

                                    inArray[j] = k;

                             }

                      }

               }

}

else if(type.equals(“b”))

{

       int k = 0;

       for(int i=0;i< inArray.length;i++)

       {

              for(int j=0;j< inArray.length-i-1;j++)

              {

                     if(inArray [j]> inArray [j+1])

                     {

                            k = inArray [j];

                            inArray [j] = inArray [j+1];

                            inArray [j+1] = k;

                     }

              }

       }

}

}

一看上面的代码，大家就觉得问题很多：第一，所有的算法都搅和在一起，不满足单一职责原则。第二，依赖细节，不满足依赖颠倒原则。第三，扩展性不好，如果要增加一个新的算法，需要对该方法进行改动。

下面我们来看看策略模式的解决思路。

首先是对所有的算法抽象一个接口，这是为了满足扩展性的基本条件，几乎所有的模式都要以接口为基础：

public interface SortAlgorithm

{

        public void sort(int[] inArr);

}

然后是各个算法的具体实现，它们实现了SortAlgorithm接口，完成了对关注点的分离，满足单一职责原则：

public class SortOne implements SortAlgorithm

{

        public void sort(int[] inArr)

        {

               int k = 0;

               for(int i=0;i<inArr.length;i++)

               {

                      for(int j=i+1;j<inArr.length;j++)

                      {

                             if(inArr[i]> inArr[j])

                             {

                                    k = inArr[i];

                                    inArr[i] = inArr[j];

                                    inArr[j] = k;

                             }

                      }

               }

}

}

public class SortTwo implements SortAlgorithm

{

        public void sort(int[] inArr)

        {

               int k = 0;

       for(int j=0;j< inArr.length-i-1;j++)

       {

              if(inArr[j]> inArr[j+1])

              {

                     k = inArr[j];

                     inArr[j] = inArr[j+1];

                     inArr[j+1] = k;

              }

               }

}

}

然后我们来看客户端的调用：

public int[] sort(int[] inArray,String type)

{

       SortAlgorithm sa;

       if(type.equals(“a”))

        {

               sa = new SortOne();

        }

        else if(type.equals(“b”))

        {

               sa = new SrotTwo();

}

else

{

       ……

}

sa.sort(inArray);

}

上面我们就完成了策略模式对该问题的解决，满足了单一职责原则；有了一定的扩展性，如果新增一个算法的话，去实现SortAlgorithm接口就可以了。

当然，我们在客户端代码可以看到，策略模式依然没有完全去掉客户端对具体实现类的依赖，这使得我们增加一个新的算法以后，仍然需要对客户端进行修改。所以策略模式和命令模式一样，只是初步增加了一定的扩展性。如果要完全去掉客户端对具体类的依赖，可以结合工厂模式来对该问题作进一步优化，具体做法大家可以自己做，这里不再讲述。

所谓策略模式，简单说来就是对算法的封装。在实际的编码过程中，我们会遇到各种各种的选择算法的问题，这时候就可以使用策略模式了，下面以一个例子来作为本文的结束。

假设我们有一个POJO类：Employee，里面存储了很多用户的信息，如下：

public class Employee

{

        private int id;

        private String name;

        private double servedYears;

        ……

        public void setId(int id)

        {

               this.id = id;

}

public int getId()

{

       return this.id;

}

public void setName(String name)

{

       this.name = name;

}

public String getName()

{

       return this.name;

}

public void setServedYears(double servedYears)

{

       this.servedYears = servedYears;

}

public double getServedYears()

{

       return this.servedYears;

}

……

}

现在我们有一个关于Employee的数组，需要对数组进行排序，我们知道该使用Arrays.sort()对该数组进行排序，但是在使用该方法的时候，我们首先要实现Comparator接口，如下：

Arrays.sort(emps,new Comparator(){

        Public int compare(Object o1,Object o2)

        {

               return ((Employee)o1).getServedYears()-((Employee)o2).getServedYears();

}

})；

上面实现了一个对POJO对象的排序过程，现在的问题是我们分别需要对Employee类的id、name和servedYears为索引进行排序。我们可以看出，这明显是多个算法的问题，可以使用策略模式来解决问题：

以id为索引的比较器：

public class IdComparator implements Comparator

{

        Public int compare(Object o1,Object o2)

        {

               return ((Employee)o1).getId()-((Employee)o2).getId();

}

}

以name为索引的比较器：

public class NameComparator implements Comparator

{

        Public int compare(Object o1,Object o2)

        {

               return ((Employee)o1).getName()-((Employee)o2).getName();

}

}

以servedYears为索引的比较器：

public class ServedYearsComparator implements Comparator

{

        Public int compare(Object o1,Object o2)

        {

               return ((Employee)o1).getservedYears()-((Employee)o2).getServedYears();

}

}

然后，我们做一个工厂来获取具体的比较器：

public class Factory

{

        public static Comparator getInstance(String type)

        {

               if(type.equals(“id”))

               {

                      return new IdComparator();

}

else if(type.equals(“name”))

{

   return new NameComparator();

}

else

{

   return ServedYearsComparator();

}

}

}

那么我们就可以对客户端进行编码了：

public void sort(Employee[] emps,String type)

{

       Arrays.sort(emps,Factory.getInstance(type));

}

我们可以看到，结合了工厂模式的策略模式的确使多算法的问题得到了很好的解决：抽取了各个算法来单独关注，满足了单一职责原则；满足了依赖颠倒原则，有了很好的扩展性。等等。

还等什么呢？赶快到实践中去灵活运用这些模式吧！