趣谈责任链模式

什么叫责任链模式？就是请求1：1的传递，直到请求内容被相应的类处理。这么说是不是不好理解？那么我们结合生活中的例子来掌握java的这种设计模式。
张小虎是家里最小的孩子，家里还有哥哥，老妈，老爹。张小虎要是想做啥事儿都会先跟哥哥说，哥哥解决不了的然后就交给老妈，老妈搞不定了就找老爹了，老爹是家里最大的boss，所以无论张小虎想做啥，行或者不行都到此为止了。用代码来模拟一下这个场景。

//张小虎作为请求者
public class Requester {

    //请求的内容
    public String requestContent;
    //要多少钱
    public int money;

    public Requester(String requestContent,int money){
        this.money = money;
        this.requestContent = requestContent;
    }

}

哥哥，老妈，老爸都可以处理张小虎的请求，但是他们能处理的权限不一样。

public interface HandleI {
    //处理请求的方法
    void hand(Requester request);
}

哥哥可以支配家里100块以下的钱，多余100块的就得向老妈说了。

public class Brother implements HandleI {

    private HandleI nextHander;
    public void setNextHander(HandleI nextHander) {
        this.nextHander = nextHander;
    }

    @Override
    public void hand(Requester request) {
        if(request.money <100){
            Log.i(getClass().getSimpleName(),"可以，给你"+request.money);
        }else {
            Log.i(getClass().getSimpleName(),"我没那么多线啊，我跟老妈说说吧");
            this.nextHander.hand(request);
        }
    }
}

老妈可以支配家里1000块，多余1000块的就得跟老爹汇报。

public class Mother implements HandleI {

    private  HandleI nextHander;

    public void setNextHander(HandleI nextHander) {
        this.nextHander = nextHander;
    }

    @Override
    public void hand(Requester request) {
        if(request.money <1000){
            Log.i(getClass().getSimpleName(),"可以，给你"+request.money);
        }else {
            Log.i(getClass().getSimpleName(),"我去问问你爹，要是他同意就行");
            this.nextHander.hand(request);
        }

    }
}

老爹是最大的boss，可以决定一切大小事务。


public class Father implements HandleI {


    @Override
    public void hand(Requester request) {
        Log.i(getClass().getSimpleName(),"可以，"+request.money);
    }
}

然后我们看运行一下，看看张小虎的三个请求的处理结果是怎样的。

    Requester requester1 = new Requester("买玩具",20);
                Requester requester2 = new Requester("买玩具",200);
                Requester requester3 = new Requester("买玩具",2000);

                Brother brother = new Brother();
                Mother mother = new Mother();
                Father father = new Father();
                brother.setNextHander(mother);
                mother.setNextHander(father);

                brother.hand(requester1);
                brother.hand(requester2);
                brother.hand(requester3);

三个都是买玩具的请求，第一个是买20块的玩具，第二个是买200块的玩具，第三个是买2000块的玩具。
处理结果：

//第一次请求
07-09 15:17:43.228 12201-12201/com.iwintrue.todoapplication2 I/Brother: 可以，给你20
//第二次请求
07-09 15:17:43.228 12201-12201/com.iwintrue.todoapplication2 I/Brother: 我没那么多线啊，我跟老妈说说吧
07-09 15:17:43.229 12201-12201/com.iwintrue.todoapplication2 I/Mother: 可以，给你200
//第三次请求，他爹同意了，家里有钱，任性。
07-09 15:17:43.229 12201-12201/com.iwintrue.todoapplication2 I/Brother: 我没那么多线啊，我跟老妈说说吧
07-09 15:17:43.229 12201-12201/com.iwintrue.todoapplication2 I/Mother: 我去问问你爹，要是他同意就行
07-09 15:17:43.229 12201-12201/com.iwintrue.todoapplication2 I/Father: 可以，2000

优缺点：
从这个例子中，我们就可以掌握责任链的这种设计模式了，在android中最典型的使用就是view的事件分发机制。优点：降低了模块的耦合性，具体的请求由具体的类来处理，符合类的最小封装原则。缺点：处理请求时会层层传递，效率不高，请求处理不当会出现循环执行。

猜你喜欢