Android 架构师之路10 设计模式之责任链模式

Android 架构师之路 目录

1、 责任链模式概念

1.1 介绍

客户端发出一个请求，链上的对象都有机会来处理这一请求，而客户端不需要知道谁是具体的处理对象。这样就实现了请求者和接受者之间的解耦，并且在客户端可以实现动态的组合职责链。使编程更有灵活性。

1.2 定义

使多个对象都有机会处理请求，从而避免了请求的发送者和接收者之间的耦合关系。将这些对象形成一条链，并沿着这条链传递该请求，直到有对象处理它为止。其过程实际上是一个递归调用。

1.3 使用场景

• 有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。。
• 在请求处理者不明确的情况下向多个对象中的一个提交请求。
• 需要动态指定处理一个请求的对象集合。

2、责任链模式UML类图

责任链模式UML类图

角色：

• Handler：定义职责接口，通常在内部定义处理请求的方法，可以在这里实现后继链。
• ConcreteHandler：实际的职责类，在这里个类里面，实现在它职责范围内的请求处理，如果不处理，就继续转发请求给后继者。
• Client：客户端，组装职责链，向链上的具体对象提交请求。

图中最关键的点就是：那条从Handler出发又指向自己的线，它就是实现链式调用的关键。

3、责任链模式简单实现

Handler

/**
 * 抽象的处理类
 * Created by Administrator on 2018/1/25.
 */
public abstract  class Handler {

    public Handler nextHandler;

    /**
     *
     */
    public void handRequest(AbstractRequest request){
     if(request.getRequestLevel()==getHandlerLevel()){
         handle(request);
     }else {
         if(nextHandler!=null){
             nextHandler.handRequest(request);
         }else {
             System.out.println("----> 所有处理对象 都不能处理 " );
         }
     }
    }
    /**
     * 具体的处理方法，给子类实现
     * @param request
     */
    public abstract void handle(AbstractRequest request);

    /**
     * 能够处理请求的级别
     * @return
     */
    public abstract int  getHandlerLevel();
}

ConcreteHandler

/**
 * 具体处理者
 */
public class Handler1 extends Handler {
    @Override
    public void handle(AbstractRequest request) {
        System.out.println("handle1---->处理了对象" + request.getRequestLevel());
    }

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

public class Handler2 extends Handler {
    @Override
    public void handle(AbstractRequest request) {
        System.out.println("handle2---->处理了对象" + request.getRequestLevel());
    }

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

public class Handler3 extends Handler {
    @Override
    public void handle(AbstractRequest request) {
        System.out.println("handle3---->处理了对象" + request.getRequestLevel());
    }

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

public class Handler4 extends Handler {
    @Override
    public void handle(AbstractRequest request) {
        System.out.println("handle4---->处理了对象" + request.getRequestLevel());
    }

    @Override
    public int getHandlerLevel() {
        return 4;
    }
}

处理对象Request

public abstract class AbstractRequest {
    private Object object;
    public  Object getContent(){
        return object;
    }
    public abstract int getRequestLevel();
}

public class Request1 extends AbstractRequest {
    @Override
    public int getRequestLevel() {
        return 1;
    }
}

public class Request2 extends AbstractRequest {
    @Override
    public int getRequestLevel() {
        return 2;
    }
}

Client

public class Client {
    public static void main(String[] args){
        Handler handler1 = new Handler1();
        Handler handler2 = new Handler2();
        Handler handler3 = new Handler3();
        Handler handler4 = new Handler4();

        //拼装成链子
        handler1.nextHandler = handler2;
        handler2.nextHandler = handler3;
        handler3.nextHandler = handler4;

        AbstractRequest request = new Request1();
        //一定要将请求对象，丢给第一个处理者
        handler1.handRequest(request);

        AbstractRequest request2 = new Request2();
        //handler1 不处理 交给handler2处理
        handler1.handRequest(request2);


    }
}

运行结果

handle1---->处理了对象1
handle2---->处理了对象2

对于责任链来说，一个请求最终只有两种情况：一是被某个处理对象处理，另一个是所有的对象均为对其处理。 对于前一种情况，我们称该对象为纯的责任链，对于后一种情况我们称为不纯的责任链，在实际应用中，我们所见的责任链模式大多为不纯的责任链模式。

4、责任链模式在Android系统中

4.1 View事件的分发处理

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

4.2 Broadcast广播机制

5、总结

对于责任链中的一个处理者对象，有两个行为。一是处理请求，二是将请求传递到下一节点，不允许某个处理者对象在处理了请求后又将请求传送给上一个节点的情况。

对于一条责任链来说，一个请求最终只有两种情况。一是被某个处理对象所处理，另一个是所有对象均未对其处理，对于前一种情况我们称为纯的责任链模式，后一种为不纯的责任链。实际中大多为不纯的责任链。

优点：

职责链模式的最主要功能就是：动态组合，请求者和接受者解耦。

• 请求者和接受者松散耦合：请求者不需要知道接受者，也不需要知道如何处理。每个职责对象只负责自己的职责范围，其他的交给后继者。各个组件间完全解耦。

• 动态组合职责：职责链模式会把功能分散到单独的职责对象中，然后在使用时动态的组合形成链，从而可以灵活的分配职责对象，也可以灵活的添加改变对象职责。

缺点：

• 产生很多细粒度的对象：因为功能处理都分散到了单独的职责对象中，每个对象功能单一，要把整个流程处理完，需要很多的职责对象，会产生大量的细粒度职责对象。

• 不一定能处理：每个职责对象都只负责自己的部分，这样就可以出现某个请求，即使把整个链走完，都没有职责对象处理它。这就需要提供默认处理，并且注意构造链的有效性。

特别感谢：

陈李冠