设计模式(9)-责任链模式详解(易懂)

责任链模式的定义

责任链模式是一种设计模式。在责任链模式里，不少对象由每个对象对其下家的引用而链接起来造成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪个对象最终处理这个请求，这使得系统能够在不影响客户端的状况下动态地从新组织和分配责任。

模型：

• Hander：抽象处理者

• ConcreteHander：具体处理者

下面模型代码以下：

1.设计等级类

public class Level {
    private  int level=1;

    public  Level(int level){
        this.level=level;
    }

    public int getLevel() {
        return level;
    }
}

复制代码

2.请求类

public class MyRequest {

    Level level;
    public  MyRequest(Level level){
        this.level=level;
    }
    public int  getLevel(){

        return level.getLevel();
    }

}

复制代码

3.响应类

public class Response {
    private String message;
    public Response(String message) {
        Log.d("qzs","处理完成");
        this.message = message;
    }
    public String getMessage() {
        return message;
    }
}

复制代码

4.抽象处理者类

public abstract class AbstractHandler  {
    //判断下一个处理者是谁
    private AbstractHandler nextHandler = null;

    public final Response handlerRequest(MyRequest request) {
        Response response = null;

        if(this.getHandlerLevel()==request.getLevel()) {
            response = this.response(request);
        }else {
            if(this.nextHandler != null) {
                Log.d("qzs","转到下一个处理者中...");
                response = this.nextHandler.handlerRequest(request);
            }else {
           Log.d("qzs","后面没有处理请求了...");
            }
        }
        return response;
    }
    public void setNextHandler(AbstractHandler handler) {
        nextHandler = handler;
    }
    //拿到等级
    protected abstract int getHandlerLevel();
    //响应
    protected abstract Response response(MyRequest request);
}

复制代码

5.定义具体的处理者，这里就定义了两个：

public class ConcreteHandlerA extends AbstractHandler {
    @Override
    protected int getHandlerLevel() {
        return 0;
    }

    @Override
    protected Response response(MyRequest request) {
        Log.d("qzs","正在处理中“ConcreteHandlerA");
        return new Response("响应处理结果A") ;
    }
}

public class ConcreteHandlerB extends AbstractHandler {
    @Override
    protected int getHandlerLevel() {
        return 1;
    }

    @Override
    protected Response response(MyRequest request) {
        Log.d("qzs","正在处理中“ConcreteHandlerB");
        return new Response("响应处理结果B") ;
    }
}

复制代码

6.调用：

前提是A到B组成了一个链，而且上面A的等级是0，B是1；发出的请求先通过A若是不能处理就交给B：

AbstractHandler handler1=new ConcreteHandlerA();
        AbstractHandler handler2=new ConcreteHandlerB();
        //A到B组成一个链
        handler1.setNextHandler(handler2);
        Response response=handler1.handlerRequest(new MyRequest(new Level(1)));

复制代码

上面代码我传送的等级是1，结果应该是由B解决的，下面是运行结果：

若是你传入的等级不在A和B的范围，运行结果以下：

说明没有适合的了。

---

实例说明

若是上面的定义不是很明白，下面直接实例说明一下。

例子：家里的小孩想出去玩，须要请示一下，这里规定一级请示爸爸，爸爸赞成了就能够出去玩了；若是爸爸不在家就请示(二级)妈妈，妈妈赞成了也能够出去玩；若是都不在家就不容许出去玩。

1.编写等级类，响应类，请求类，这些都没有变化能够直接去上面看就能够了。

2.抽象处理类：

public abstract class AbstractHandler  {
    //判断下一个处理者是谁
    private AbstractHandler nextHandler = null;

    public final Response handlerRequest(MyRequest request) {
        Response response = null;

        if(this.getHandlerLevel()==request.getLevel()) {
            response = this.response(request);
        }else {
            if(this.nextHandler != null) {
                Log.d("qzs","转到下一个处理者中...");
                response = this.nextHandler.handlerRequest(request);
            }else {
           Log.d("qzs","爸爸妈妈不在家...");
            }
        }
        return response;
    }
    public void setNextHandler(AbstractHandler handler) {
        nextHandler = handler;
    }
    //拿到等级
    protected abstract int getHandlerLevel();
    //响应
    protected abstract Response response(MyRequest request);
}

复制代码

3.具体处理者，也就是爸爸和妈妈：

public class Father extends AbstractHandler {
    @Override
    protected int getHandlerLevel() {
        return 1;
    }

    @Override
    protected Response response(MyRequest request) {
        Log.d("qzs","正在处理中“Father”");
        Log.d("qzs","爸爸赞成孩子出去玩了");
        return  new Response("") ;
    }
}

public class Mother extends  AbstractHandler{
    @Override
    protected int getHandlerLevel() {
        return 2;
    }

    @Override
    protected Response response(MyRequest request) {
        Log.d("qzs","正在处理中“Mother”");
        Log.d("qzs","妈妈赞成孩子出去玩了");
        return new Response("") ;
    }
}

复制代码

4.调用

若是传入的等级1：

AbstractHandler handler1=new Father();
        AbstractHandler handler2=new Mother();
        //先问爸爸，爸爸不在家再问妈妈
        handler1.setNextHandler(handler2);
        Response response=handler1.handlerRequest(new MyRequest(new Level(1)));

复制代码

运行结果：

传入其余的等级也能够，这个你们能够本身去试一试。

责任链模式的优缺点及其余

1.优势

• 耦合度下降，请求和处理是分开的

2.缺点

• 责任链太长或者每条链判断处理的时间太长会影响性能。特别是递归循环的时候

• 不必定被处理，每一个职责类的职责很明确，这就须要对写默认的处理了

责任链模式重要的两点：分离职责，动态组合

本文部分定义参考了网上博文和网上信息...

---

你们能够关注个人微信公众号：「安卓干货铺」一个有质量、有态度的公众号！