GoF著作中未提到的设计模式(6):Specification

在一个较为复杂的业务流程中，某些条件的满足与否决定了业务逻辑的走向，我们可以把这些条件抽离出来，使得任意个条件以某种关系进行组合，从而灵活地对业务逻辑进行定制。另外，在查询、过滤等应用场合中，我们也可以预定义多个条件，使用这些条件的组合来处理查询逻辑，而不是使用逻辑判断语句来处理，那样只会让代码变得复杂，让脑袋变大。

在Specification设计模式中，一个条件就是一个specification，多个specification通过串联的方式以某种逻辑关系形成一个组合式的specification。首先看一下整体的UML图：

下面是Specification接口的声明：

public interface Specification {
      boolean isSatisfiedBy(Object params);
      Specification and(Specification other);
      Specification or(Specification other);
      Specification not();
}

它定义了各个条件间可用的关系：与、或、非，这三个关系所对应方法的返回值都是Specification自身，目的是为了实现Specification之间的串联（chaining），从而形成一个关系表达式，后面会看到具体的用法。isSatisfiedBy就是判定方法，参数是一个Object，支持任意类型。
下面我们来看CompositSpecification的声明：

public abstract class CompositeSpecification implements Specification{

      @Override
      public Specification and(Specification other) {
            return new AndSpecification(this, other);
      }

      public abstract boolean isSatisfiedBy(Object params);
           
      @Override
      public Specification not() {
            return new NotSpecification(this);
      }

      @Override
      public Specification or(Specification other) {
            return new OrSpecification(this, other);
      }
}

它实现了Specification接口的关系判定方法，而isSatisfiedBy则仍是抽象方法，需要派生类来具体实现。下面是三个分别实现了与、或、非关系判定的派生类的声明：

public class AndSpecification extends CompositeSpecification {
     
      private final Specification b;
      private final Specification a;

      public AndSpecification(Specification a,Specification b) {
            this.a = a;
            this.b = b;
      }
     
      @Override
      public boolean isSatisfiedBy(Object params) {
            return a.isSatisfiedBy(params) && b.isSatisfiedBy(params);
      }
}

public class OrSpecification extends CompositeSpecification {

      private final Specification b;
      private final Specification a;

      public OrSpecification(Specification a, Specification b) {
            this.a = a;
            this.b = b;
      }
     
      @Override
      public boolean isSatisfiedBy(Object params) {
            return a.isSatisfiedBy(params) || b.isSatisfiedBy(params);
      }
}

public class NotSpecification extends CompositeSpecification {

      private final Specification a;

      public NotSpecification(Specification a) {
            this.a = a;
      }
     
      @Override
      public boolean isSatisfiedBy(Object params) {
            return !a.isSatisfiedBy(params);
      }
}

这些类就构成了Specification模式的核心部分，下面我们来看一个例子：
先定义一个男人：

public class Men {
      public String     name;       // 姓名
      public boolean    married;    // 是否已婚
      public int        cars;       // 拥有车的数量
      public int        houses;     // 拥有房子的数量

      public Men(String name,int cars, int houses, boolean married) {
            this.name = name;
            this.cars = cars;
            this.houses = houses;
            this.married = married;
      }
}

然后定义选男人的几个条件:

// 有车
public class HasCarsSpecification extends CompositeSpecification {

      @Override
      public boolean isSatisfiedBy(Object params) {
            Men m = (Men)params;
            return m.cars > 0;
      }
}

// 有房
public class HasHousesSpecification extends CompositeSpecification {

      @Override
      public boolean isSatisfiedBy(Object params) {
            Men m = (Men)params;
            return m.houses > 0;
      }
}

// 已婚
public class MarriedSpecification extends CompositeSpecification {

      @Override
      public boolean isSatisfiedBy(Object params) {
            Men m = (Men)params;
            return m.married;
      }
}

好，下面有位女嘉宾开始选它心目中的男人了：

Men[] candidates = {
      new Men("李精英", 1, 1, false),
      new Men("王老五", 5, 3, true),
      new Men("赵白领", 0, 1, false),
      new Men("West_Link", 0, 0, false)
};

HasHousesSpecification hasHouse = new HasHousesSpecification();
HasCarsSpecification hasCar = new HasCarsSpecification();
MarriedSpecification married = new MarriedSpecification();

Specification spec = hasHouse.and(hasCar).and(married.not());
for (Men men : candidates) {
      if(spec.isSatisfiedBy(men))
            System.out.println(men.name);
}

从Specification spec = hasHouse.and(hasCar).and(married.not())这行代码可以看出这位女嘉宾选择了有车
并且有房的未婚男子，所以打印结果为：李精英。

经过多轮选择，West_Link始终没有被选上！