责任链模式

一.责任链模式的定义

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

 

 

二.责任链模式的使用场景

多个对象可以处理同一请求，但具体由哪个对象处理则在运行时动态决定

在请求者不明确的情况下向对个对象中的一个提交一个请求。需要动态指定一组对象处理请求。

 

三．责任链模式UML

(1).简单实现

//Handler.java

/**
 * Created by Administrator on 2016/4/6 0006.
 */
public abstract class Handler {
    protected Handler successor;//下一节点的处理者

    /**
     * 请求处理
     * @param condition请求条件
     * */
    public abstract  void handlerRequest(String condition);
}

//ConcreteHandler1.java

/**
 * Created by Administrator on 2016/4/6 0006.
 */
public class ConcreteHandler1 extends Handler {
    @Override
    public void handlerRequest(String condition) {
        if(condition.equals("ConcreteHandler1")){
            System.out.println("ConcreteHandler1  handled");
        }else{
            //给下一个人处理
            successor.handlerRequest(condition);
        }
    }
}

//ConcreteHanlder2.java

/**
 * Created by Administrator on 2016/4/6 0006.
 */
public class ConcreteHandler2 extends Handler {
    @Override
    public void handlerRequest(String condition) {
        if(condition.equals("ConcreteHandler2")){
            System.out.println("ConcreteHandler2  handled");
        }else{
            //给下一个人处理
            successor.handlerRequest(condition);
        }
    }
}

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //构造一个ConcreteHandler1对象
        ConcreteHandler1 handler1 = new ConcreteHandler1();
        //构造一个ConcreteHanlder2对象
        ConcreteHandler2 handler2 = new ConcreteHandler2();
        //设置handler1的下一个节点
        handler1.successor = handler2;
        //设置handler2的下一个节点
        handler2.successor = handler1;
        //处理请求
        handler1.handlerRequest("ConcreteHandler2");
    }
}

角色介绍：

Handler：抽象处理者角色，声明一个请求处理的方法，并在其中保持一个对下一个处理节点Handler对象的引用

ConcreteHandler:具体处理者角色，对请求进行处理，如果不能处理则将该请求转发给下一个节点上的处理对象。

 

（2）复杂实现

//AbstractHandler.java

/**
 * Created by Administrator on 2016/4/6 0006.
 */
public abstract class AbstractHandler {
    protected AbstractHandler nextHandler;//下一节点上的处理者对象

    /**
     * 处理请求
     *
     * @param request 请求对象
     */
    public final void handleRequest(AbstractRequest request) {
        //判断当前处理者对象的处理级别是否和请求者的处理级别一致
        if (getHandleLevel() == request.getRequestLevel()) {
            //一致则由该处理对象处理
            handle(request);
        } else {
            //否则则该请求对象转发给下一个节点上的请求对象
            if (nextHandler != null) {
                nextHandler.handleRequest(request);
            } else {
                //当所有处理者对象均不能处理该请求时输出
                System.out.println("All of handler can not handle the request");
            }

        }

    }

    /**
     * 获取处理者对象的处理级别
     *
     * @return 处理级别
     */
    protected abstract int getHandleLevel();

    /**
     * 每个处理者对象的具体处理方式
     *
     * @param request 请求者对象
     */
    protected abstract void handle(AbstractRequest request);

}

//Handler1.java

/**
 * Created by Administrator on 2016/4/6 0006.
 */
public class Handler1 extends AbstractHandler {
    @Override
    protected int getHandleLevel() {
        return 1;
    }

    @Override
    protected void handle(AbstractRequest request) {
        System.out.println("Handler1  handler request:"+request.getRequestLevel());
    }
}

//Handler2.java

/**
 * Created by Administrator on 2016/4/6 0006.
 */
public class Handler2 extends AbstractHandler {
    @Override
    protected int getHandleLevel() {
        return 2;
    }

    @Override
    protected void handle(AbstractRequest request) {
        System.out.println("Handler2  handler request:"+request.getRequestLevel());
    }
}

//Handler3.java

/**
 * Created by Administrator on 2016/4/6 0006.
 */
public class Handler3 extends AbstractHandler {
    @Override
    protected int getHandleLevel() {
        return 3;
    }

    @Override
    protected void handle(AbstractRequest request) {
        System.out.println("Handler3  handler request:"+request.getRequestLevel());
    }
}

//AbstractRequest.java

/**
 * Created by Administrator on 2016/4/6 0006.
 */
public abstract class AbstractRequest {
    protected Object  obj;//处理对象
    public AbstractRequest(Object obj){
        this.obj = obj;
    }
    /**
     * 获取处理的内容对象
     *@return  具体的内容对象
     * */
    public Object getContent(){
        return obj;
    }

    /**
     * 获取请求级别
     * @return 请求级别
     * */
    public abstract int getRequestLevel();
}

//Request1.java

/**
 * Created by Administrator on 2016/4/6 0006.
 */
public class Request1 extends AbstractRequest {

    public Request1(Object obj) {
        super(obj);
    }

    @Override
    public int getRequestLevel() {
        return 1;
    }
}

//Request2.java

/**
 * Created by Administrator on 2016/4/6 0006.
 */
public class Request2 extends AbstractRequest {

    public Request2(Object obj) {
        super(obj);
    }

    @Override
    public int getRequestLevel() {
        return 2;
    }
}

//Request3.java

/**
 * Created by Administrator on 2016/4/6 0006.
 */
public class Request3 extends AbstractRequest {

    public Request3(Object obj) {
        super(obj);
    }

    @Override
    public int getRequestLevel() {
        return 3;
    }
}

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //构造3个处理者对象
        AbstractHandler handler1 = new Handler1();
        AbstractHandler handler2 = new Handler2();
        AbstractHandler handler3 = new Handler3();
        //设置当前处理者对象下一个节点的处理者对象
        handler1.nextHandler = handler2;
        handler2.nextHandler = handler3;
        //构造3个请求者对象
        AbstractRequest request1 = new Request1("Request1");
        AbstractRequest request2 = new Request1("Request2");
        AbstractRequest request3 = new Request1("Request3");
        //总是从链式的首端发起请求
        handler1.handleRequest(request1);
        handler1.handleRequest(request2);
        handler1.handleRequest(request3);

    }

}

四．责任链模式的简单实现

比如说小明要去出差然后报销，金额太多，由领导-->经理--->boss最后只能由boss批准

//Leader.java

/**
 * Created by Administrator on 2016/4/7 0007.
 */
public abstract class Leader {
    protected Leader nextHandler;//上一级领导处理者

    /**
     * 处理报账请求
     * @param  money 能批复的报账额度
     * */
    public final void handlerRequest(int money){
        if(money <= limit()){
            handle(money);
        }else{
            if(null != nextHandler){
                nextHandler.handlerRequest(money);
            }
        }
    }

    /**
     * 自身能批复的额度权限
     * @return 额度
     * */
    public abstract  int limit();

    /**
     * 处理报账行为
     * @param money 具体金额
     * */
    public abstract void handle(int money);
}

//GroupLeader.java

/**
 * Created by Administrator on 2016/4/7 0007.
 */
public class GroupLeader extends Leader {
    @Override
    public int limit() {
        return 1000;
    }

    @Override
    public void handle(int money) {
        System.out.println("组长批复报修"+money+"元");
    }
}

//Director.java

/**
 * Created by Administrator on 2016/4/7 0007.
 */
public class Director extends Leader {
    @Override
    public int limit() {
        return 5000;
    }

    @Override
    public void handle(int money) {
        System.out.println("主管批复报修"+money+"元");
    }
}

//Manager.java

/**
 * Created by Administrator on 2016/4/7 0007.
 */
public class Manager extends Leader {
    @Override
    public int limit() {
        return 10000;
    }

    @Override
    public void handle(int money) {
        System.out.println("经理批复报修"+money+"元");
    }
}

//Boss.java

/**
 * Created by Administrator on 2016/4/7 0007.
 */
public class Boss extends Leader {
    @Override
    public int limit() {
        return Integer.MAX_VALUE;
    }

    @Override
    public void handle(int money) {
        System.out.println("老板批复报修"+money+"元");
    }
}

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //构造各个领导对象
        GroupLeader groupLeader = new GroupLeader();
        Director director = new Director();
        Manager manager = new Manager();
        Boss boss = new Boss();

        //设置上一级领导处理者对象
        groupLeader.nextHandler = director;
        director.nextHandler = manager;
        manager.nextHandler = boss;

        //发起报账申请
        groupLeader.handlerRequest(50000);
    }

}

结果

1567-1567/com.dx.text.text0407 I/System.out﹕ 老板批复报修50000元

 

五．Android源码中的责任链模式实现

责任链模式在Android源码中比较类似的实现莫过于对事件的分发处理，每当用户接触屏幕时，Android都会将对应的事件包装成一个事件对象从ViewTree的顶部自上而下地分发传递

 

源码略。。。

ViewGroup事件投递的递归调用就类似于一条责任链，一旦其寻找到责任者，那么就由责任者持有并消费掉该次事件，具体地体现在View的onTouchEvent方法中返回值的设置，如果onTouchEvent返回false,那么意味着当前View不会是该次事件的责任人，将不会对其持有：如果为true则相反，此时View会持有该事件并不再向外传递。

 

六．总结

优点：显而易见，可以对请求者和处理者关系解耦（比如小明和老板），提高代码的灵活性。

缺点：对链中请求处理者的遍历。如果处理者太多那么遍历必定会影响性能，特别是在一些递归调用中，要慎重。