规格模式（Specification Pattern）

当前位置:

首页 > 编程开发 > Java教程 >

规格模式（Specification Pattern）

本文节选自《设计模式就该这样学》

1　规格模式的定义#

规格模式（Specification Pattern）可以认为是组合模式的一种扩展。很多时候程序中的某些条件决定了业务逻辑，这些条件就可以抽离出来以某种关系（与、或、非）进行组合，从而灵活地对业务逻辑进行定制。另外，在查询、过滤等应用场合中，通过预定义多个条件，然后使用这些条件的组合来处理查询或过滤，而不是使用逻辑判断语句来处理，可以简化整个实现逻辑。
这里的每个条件都是一个规格，多个规格（条件）通过串联的方式以某种逻辑关系形成一个组合式的规格。规格模式属于结构型设计模式。

2　规格模式的应用场景#

规格模式主要适用于以下应用场景。

（1）验证对象，检验对象本身是否满足某些业务要求或者是否已经为实现某个业务目标做好了准备。

（2）从集合中选择符合特定业务规则的对象或对象子集。

（3）指定在创建新对象的时候必须要满足某种业务要求。

3　规格模式的UML类图#

规格模式的UML类图如下图所示。

file

由上图可以看到，规格模式主要包含6个角色。

（1）抽象规格书（Specification）：对规格书的抽象定义。

（2）组合规格书（CompositeSpecification）：一般设计为抽象类，对规格书进行与或非操作，实现and()、or()、not()方法，在方法中关联子类，因为子类为固定类，所以父类可以进行关联。

（3）与规格书（AndSpecification）：对规格书进行与操作，实现isSatisfiedBy()方法。

（4）或规格书（OrSpecification）：对规格书进行或操作，实现isSatisfiedBy()方法。

（5）非规格书（NotSpecification）：对规格书进行非操作，实现isSatisfiedBy()方法。

（6）业务规格书（BizSpecification）：实现isSatisfiedBy()方法，对业务进行判断，一个类为一种判断方式，可进行扩展。

4　规格模式的通用写法#

以下是规格模式的通用写法。


public class Client {

    public static void main(String[] args) {
        //待分析的对象
        List<Object> list = new ArrayList<Object>();
        //定义两个业务规格书
        ISpecification spec1 = new BizSpecification("a");
        ISpecification spec2 = new BizSpecification("b");
        //规格调用
        for (Object o : list) {
            if(spec1.and(spec2).isSatisfiedBy(o)){  //如果o满足spec1 && spec2
                System.out.println(o);
            }
        }
    }

    //抽象规格书
    interface ISpecification {
        //候选者是否满足条件
        boolean isSatisfiedBy (Object candidate) ;
        //and操作
        ISpecification and (ISpecification spec);
        //or操作
        ISpecification or (ISpecification spec);
        //not操作
        ISpecification not ();
    }

    //组合规格书
    static abstract class CompositeSpecification implements ISpecification {
        //是否满足条件由子类实现
        public abstract boolean isSatisfiedBy (Object candidate) ;
        //and操作
        public ISpecification and (ISpecification spec) {
            return new AndSpecification(this, spec);
        }
        //or操作
        public ISpecification or(ISpecification spec) {
            return new OrSpecification(this, spec);
        }
        //not操作
        public ISpecification not() {
            return new NotSpecification(this);
        }
    }

    //与规格书
    static class AndSpecification extends CompositeSpecification {
        //传递两个规格书进行and操作
        private ISpecification left;
        private ISpecification right;

        public AndSpecification(ISpecification left, ISpecification right) {
            this.left = left;
            this.right = right;
        }
        
        //进行and运算
        public boolean isSatisfiedBy(Object candidate) {
            return left.isSatisfiedBy(candidate) && right.isSatisfiedBy(candidate);
        }
    }


    static class OrSpecification extends CompositeSpecification {
        //传递两个规格书进行or操作
        private ISpecification left;
        private ISpecification right;

        public OrSpecification(ISpecification left, ISpecification right) {
            this.left= left;
            this.right = right;
        }

        //进行or运算
        public boolean isSatisfiedBy(Object candidate) {
            return left.isSatisfiedBy(candidate) || right.isSatisfiedBy(candidate);
        }
    }

    static class NotSpecification extends CompositeSpecification {
        //传递两个规格书进行非操作
        private ISpecification spec;

        public NotSpecification(ISpecification spec) {
            this.spec = spec;
        }

        //进行not运算
        public boolean isSatisfiedBy(Object candidate) {
            return !spec.isSatisfiedBy(candidate);
        }
    }

    //业务规格书
    static class BizSpecification extends CompositeSpecification {
        //基准对象，如姓名等，也可以是int等类型
        private String obj;
        public BizSpecification(String obj) {
            this.obj = obj;
        }
        //判断是否满足要求
        public boolean isSatisfiedBy(Object candidate){
            //根据基准对象判断是否符合
            return true;
        }
    }
}