使用责任链模式实现一个符合开闭原则的判断流程

最近项目中的一个需求就是对于一串数据，通过一系列的判断条件来判断其是不是符合要求的。这个判断条件是不断变化的。也就是说随时要增加新的判断条件或者移除旧的判断条件，也行我们会觉得写一大串if…else if ….不就解决了吗？当然，if….else if可以解决问题，但软件有一个重要的原则:开闭原则。

什么是开闭原则:

在面向对象编程领域中，开闭原则规定”软件中的对象（类，模块，函数等等）应该对于扩展是开放的，但是对于修改是封闭的”。试想，如果判断条件不断的增加，难道要不断的去增加efse if吗?如果有上百的判断条件是不是要写上百个else..if..这样代码臃肿，给后期维护带来巨大的困难。

责任链模式：

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
适用场景：

• 1、有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定；
• 2、在不明确指定接收者的情况下，向多个对象中的一个提交一个请求；
• 3、处理一个请求的对象集合应被动态指定。

第一次接触责任链模式的时候是在研究Struts2的时候，当时便惊叹与它巧妙的设计，可以讲一个庞大的处理流程完成的这么优雅。现在我们来用责任链模式完成上述的要求:

执行判断的抽象类

public abstract class AbstractJudgment {    //需要继续判断的内容    private String content = null;    // 责任链的下一个节点，即处理者    public AbstractJudgment nextJudg;    public AbstractJudgment(String content) {        this.content = content;    }    public String getContent() {        return this.content;    }    public void setNextJudg(AbstractJudgment nextJudg){        this.nextJudg=nextJudg;    }    //获取判断结果    public abstract Boolean getResult();}

现在我们写三个具体的执行判断的实例:

public class JudgmentOne extends AbstractJudgment{    public JudgmentOne(String content) {        super(content);        // TODO Auto-generated constructor stub    }    @Override    public Boolean getResult() {        // getContent()获取判断的内容 这儿写具体的判断条件并返回结果        return  true or false;    }}public class JudgmentTwo extends AbstractJudgment{    public JudgmentOne(String content) {        super(content);        // TODO Auto-generated constructor stub    }    @Override    public Boolean getResult() {        // getContent()获取判断的内容 这儿写具体的判断条件并返回结果        return  true or false;    }}public class JudgmentThree extends AbstractJudgment {    public JudgmentThree(String content) {            super(content);            // TODO Auto-generated constructor stub        }    @Override    public Boolean getResult() {        // getContent()获取判断的内容 这儿写具体的判断条件并返回结果        return  true or false;    }}

现在我们就有了三个判断条件，我们来写一个Handler:

//抽象处理者类，  public abstract class AbstractHandler {    // 捕获具体请求并进行处理    public final void handleJudgment(AbstractJudgment request) {        // 先由自己处理        boolean result = this.handle(request);        System.out.println(str);        //判断是否符合我们的要求，当判断类判断出        if (result) {            System.out.println("处理有结果。。。");            //符合，终止            return;        } else {            //不符合，继续传递给下一条链            if(request.nextJudg!=null){                System.out.println("传递给下一个条件来处理...");                //递归调用               handleJudgment(request.nextJudg);            }else{                System.out.println("处理无结果。。。");            }        }    }    // 定义链中每个处理者具体的处理方式    protected abstract Boolean handle(AbstractJudgment request);}

现在定义它的实现类:

public class JudgeHandler extends AbstractHandler{    @Override    protected Boolean handle(AbstractJudgment request) {        // TODO Auto-generated method stub        return request.getResult();    }}

完成，测试:

@Test    public void testLinked() {        AbstractHandler handler01 = new JudgeHandler();        // 创建请求并提交到指责链中进行处理        AbstractJudgment request01 = new JudgmentOne("被判断的内容1");        AbstractJudgment request02 = new JudgmentTwo("被判断的内容2");        AbstractJudgment request03 = new JudgmentThree("被判断的内容3");        // 进行链的组装，即头尾相连，一层套一层        request01.setNextJudg(request02);        request02.setNextJudg(request03);        // 每次提交都是从链头开始遍历        handler01.handleJudgment(request01);    }

OK