Android责任链模式(java责任链模式，Android事件分发)

责任链模式

定义：

为了避免请求发送者与多个请求处理者耦合在一起，于是将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链;当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。

生活小场景:

假设公司有个人叫小王，他的工作是采购，公司要买一批设备，设备有一张采购单，采购单他不能直接去买的，他要拿给他的组长进行审核，组长觉得这个东西大体是可以的，但是他没有决定权，他又把这个东西的审批给到他的部门经理，部门经理看了之后也同意，但是他也是不能立马下决定，还是要请示总经理，总经理感觉金额涉及过大，又把审批给到老板。这样子就形成一条责任链，他们都参与了采购的审批，消耗请求，有可能在中间某个人就消耗掉了请求，就不会往下面继续传递了，举个例子，总经理已经有足够大的权力决定这个审批了就不会传给老板了。

代码示例

//代表我们购买内容采购单，
public class Purchase {
    private String name;
    private float price;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public float getPrice() {
        return price;
    }

    public void setPrice(float price) {
        this.price = price;
    }
}

这个类整个内容就代表我们的购买清单 相当于前面说的采购单

public class Request {
    private List<Purchase> purchaseList;//清单列表，代表我们所有的采购内容

    public Request() {
        purchaseList = new ArrayList<>();
    }

    public void add(Purchase purchase) {
        purchaseList.add(purchase);
    }

    public float getTotalPrice() {
        float total = 0f;
        for (int i = 0; i < purchaseList.size(); i++) {
            total = total + purchaseList.get(i).getPrice();
        }
        return total;
    }
}

处理者基类

public abstract class Handler {
    private Handler next;//下一个处理者的引用

    public Handler getNext() {
        return next;
    }

    public void setNext(Handler next) {
        this.next = next;
    }
    //处理请求的方法
    public abstract void handleRequest(Request request);
}

责任链，组长类

//组长
public class ConcreteHandler1 extends Handler{
    @Override
    public void handleRequest(Request request) {
        if (request.getTotalPrice()<1000){//组长只能处理到小于1000的购买单
            Log.w("组长", "");
        }else {//组长处理不好就给到下一个的处理者
            if (getNext()!=null){
                getNext().handleRequest(request);
            }else {
                System.out.println("没有人处理该请求！");
            }
        }
    }
}

部门经理

//部门经理
public class ConcreteHandler2 extends Handler {
    @Override
    public void handleRequest(Request request) {
        if (request.getTotalPrice()<10000){//
            Log.w("部门经理", "部门经理负责处理该请求！");
        }else {//部门经理处理不好就给到下一个的处理者
            if (getNext()!=null){
                getNext().handleRequest(request);
            }else {
                System.out.println("没有人处理该请求！");
            }
        }
    }
}

总经理

//总经理
public class ConcreteHandler3 extends Handler{
    @Override
    public void handleRequest(Request request) {
        if (request.getTotalPrice()<100000){//
            Log.w("总经理", "总经理负责处理该请求！");
        }else {//总经理处理不好就给到下一个的处理者
            if (getNext()!=null){
                getNext().handleRequest(request);
            }else {
                System.out.println("没有人处理该请求！");
            }
        }
    }
}

老板

//老板
public class ConcreteHandler4 extends Handler{
    @Override
    public void handleRequest(Request request) {
        if (request.getTotalPrice()<100000){//
            Log.w("老板", "老板负责处理该请求！");
        }else {
            if (getNext()!=null){
                getNext().handleRequest(request);
            }else {
                System.out.println("没有人处理该请求！");
            }
        }
    }
}

测试类MainActivity

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //组装请求
        Request request = new Request();
        request.add(new Purchase("顶配计算机", 200));
        request.add(new Purchase("豪华小车", 5000000));

        //组装责任链
        Handler handler1 = new ConcreteHandler1();

        Handler handler2 = new ConcreteHandler2();
        handler1.setNext(handler2);

        Handler handler3 = new ConcreteHandler3();
        handler2.setNext(handler3);

        Handler handler4 = new ConcreteHandler4();
        handler3.setNext(handler4);

        //提交请求
        handler1.handleRequest(request);
    }
}

运行看结果：

分析：handle1链到handler2，以此类推，在每个责任链中，如果本身处理不了，就会将请求一直往后面传，如果在某一个责任链节点中可以处理就不会往后面继续传递下去了。

Android中应用（事件分发）

事件传递的基础，我们事件的传递也是在这三个部分中去传递的。

核心方法

事件分发机制流程图

一开始是分发到我们的Activity中的dispatchTouchEvent（）方法中，然后会给到子类child处理，先传递给ViewGroup，然后又到里面的dispatchTouchEvent（）方法，然后在这里会判断这个事件是否会被拦截，到达onInterccptTouchEvent()，假设确定拦截的话，就会传递给onTouchEvent()函数进行处理。不拦截的话就传递到下面的子View中处理。
Event（）方法中，然后会给到子类child处理，先传递给ViewGroup，然后又到里面的dispatchTouchEvent（）方法，然后在这里会判断这个事件是否会被拦截，到达onInterccptTouchEvent()，假设确定拦截的话，就会传递给onTouchEvent()函数进行处理。不拦截的话就传递到下面的子View中处理。

小结：这个事件是在我们的不同责任点，不同的责任的一个组件上面进行的消费，如果某一方消费了这个事件，就代表整个事件已经结束了，如果没有消费到这个事件，这个事件就一直往后传。