Java设计模式（十二）--责任链模式

简介

责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条,请求在这个链上传递，直到链上的某一个对象决定处理此请求或多个对象一起处理此请求。

抽象处理类

public abstract class AbstractProcessor{

    protected AbstractProcessor next;

    public void next(AbstractProcessor next){
        this.next = next;
    }

    public abstract void handle();

}

抽象处理类中定义了next变量,用来指定下一个处理类的引用,而抽象方法handle由子类来实现当前处理类所拥有的责任。

具体抽象类

public class LevelOne extends AbstractProcessor {

    public void handle() {
        System.out.println("一级");
        if(null != next){
            next.handle();
        }
    }

}

public class LevelTwo extends AbstractProcessor {

    public void handle() {
        System.out.println("二级");
        if(null != next){
            next.handle();
        }
    }

}

具体抽象类中的代码则是先由当前级别的处理类进行处理,当前级别的处理类处理完成之后并且还有下一级,此时就会交给下一级处理类进行处理。

我们也可以不让所有的处理类都进行处理,只让能处理的处理类进行处理,当能处理的处理类处理完之后不再交给下一级处理类进行处理。

测试

public class ChainDemo {

    public void chain(){
        ArrayList<AbstractProcessor> list = new ArrayList<AbstractProcessor>();
        LevelOne levelOne = new LevelOne();
        LevelTwo levelTwo = new LevelTwo();
        list.add(levelOne);
        list.add(levelTwo);

        AbstractProcessor first = levelOne;

        for (AbstractProcessor next : list) {
            if(first != next){
                first.next(next);
            }
            first = next;
        }

        levelOne.handle();
    }

}

从上面的测试代码能看出,先是创建处理类并将处理类添加到集合中,再遍历集合中的处理类,将集合中的处理类使用next引用进行关联，关联之后再执行处理方法。

在创建责任链的时候比较麻烦,我们可以使用建造者来创建。

建造者类

public class BuildChain {

    public static class Build{

        private AbstractProcessor first;
        private AbstractProcessor next;
        private LevelOne levelOne;
        private LevelTwo levelTwo;

        public Build setLevelOne() {
            levelOne = new LevelOne();
            change(levelOne);
            return this;
        }

        public Build setLevelTwo() {
            levelTwo = new LevelTwo();
            change(levelTwo);
            return this;
        }

        private void change(AbstractProcessor processor){
            if(null == first){
                first = processor;
            }else{
                next.next(processor);
            }
            next = processor;
        }

        public AbstractProcessor build(){
            return first;
        }
    }

}

测试

public class ChainDemo {

    public void chainBuild(){

        AbstractProcessor processor = new BuildChain.Build().setLevelTwo().setLevelOne().build();
        processor.handle();

    }

}

使用建造者模式来创建责任链使主流程的代理比较简洁,如果说需要添加新的处理类的时候,就需要修改建造者类中的代码。