设计模式责任链模式

1.责任链模式的定义及使用场景
定义：
责任链模式是行为型设计模式之一。使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止
使用场景：
使多个对象都有机会处理请求，从而避免了请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，只到有对象处理它为止

Paste_Image.png
2 . 责任链模式的优缺点
2.1优点
责任链模式非常显著的优点是将请求和处理分开。请求者可以不用知道是谁处理，处理者可以不用知道请求的全貌，两者解耦，提高系统的灵活性
2.2缺点
责任链有两个非常显著的缺点：一是性能问题，每个请求都是从链头遍历到链尾，特别是在链比较长的时候，性能是一个比较大的问题；二是调试不很方便，特别是链条比较长，环节比较多的时候，由于采用了类似递归的方式，调试的时候逻辑可能比较复杂
3.注意实现
链中节点数量需要控制，避免出现超长链的情况，一般的做法是在handler中设置一个最大节点数量，在setNext方法中判断是否已经是超过其阈值，超过则不允许该链建立，避免无意识地破坏系统性能
4. 责任链模式的实现方式

public abstract class AbstractRequest {
    private Object obj;//处理对象
    public AbstractRequest(Object object) {
        this.obj = object;
    }
    public Object getContent() {
        return obj;
    }
    //获取请求的级别
    public abstract int getRequestLevel();
}```

public abstract class AbstractHandler {
protected AbstractHandler nexthandler;//下一节点处理对象
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");
}
}
}
//获取处理者对象的处理级别
protected abstract int getHandleLevel();
//每个处理者对象的具体处理方式
protected abstract void handle(AbstractRequest request);
}```

public class Handler1 extends AbstractHandler {
    @Override
    protected int getHandleLevel() {
        return 1;
    }
    @Override
    protected void handle(AbstractRequest request) {
        System.out.println("Handler1 handle request:"+request.getRequestLevel());
    }
}```

public class Handler2 extends AbstractHandler {
@Override
protected int getHandleLevel() {
return 2;
}
@Override
protected void handle(AbstractRequest request) {
System.out.println("Handler2 handle request:"+request.getRequestLevel());
}
}```

public class Handler3 extends AbstractHandler {
    @Override
    protected int getHandleLevel() {
        return 3;
    }
    @Override
    protected void handle(AbstractRequest request) {
        System.out.println("Handler3 handle request:"+request.getRequestLevel());
    }
}```

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

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

public class Request3 extends AbstractRequest {
public Request3(Object object) {
super(object);
}
@Override
public int getRequestLevel() {
return 3;
}
}```

public class Request4 extends  AbstractRequest {
    public Request4(Object object) {
        super(object);
    }
    @Override
    public int getRequestLevel() {
        return 4;
    }
}```

public class Test {
public static void main(String args[]) {
AbstractHandler h1=new Handler1();
AbstractHandler h2=new Handler2();
AbstractHandler h3=new Handler3();
h1.nexthandler=h2;
h2.nexthandler=h3;
AbstractRequest r1=new Request1(h1);
AbstractRequest r2=new Request2(h2);
AbstractRequest r3=new Request3(h3);
AbstractRequest r4=new Request4(h3);
//总是从链式的首端发起请求
h1.handleRequest(r1);
h1.handleRequest(r2);
h1.handleRequest(r3);
h1.handleRequest(r4);
}
}```
5. 责任链模式在Android中的实际应用

责任链模式在Android源码中比较类似的实现就是对于触摸事件的分发处理。每当用户接触屏幕时，Android都会将对应的事件包装成一个事件对象从ViewTree的顶部至上而下地分发传递。ViewGroup事件投递的递归调用就类似于一条责任链，一旦寻找到责任者，那么将由责任者持有并消费掉该次事件，具体地体现在View的onTouchEvent方法中返回值的设置，如果onTouchEvent返回false，那么意味着当前View不会是该次事件的复制人，将不会对其持有；如果为true则相反，此时View会持有该事件并不再向外传递。
View的事件分发机制（MontionEvent的分发过程）：
public boolean dispatchTouchEvent（MotionEvent ev）
如果事件能够传递到当前的View，那么此方法一定会被调用。
public boolean onInterceptTouchEvent（MotionEvent ev）
用来判断是否拦截某个事件
public boolean onTouchEvent(MotionEvent ev)
用来处理点击事件
流转关系（伪代码）

public boolean dispatchTouchEvent(MotionEvent ev){
     boolean consume=false;
     if(onInterceptTouchEvent(ev)){
          consume=onTouchEvent(ev);
     }else{
          consume=child.dispatchTouchEvent(ev);
     }
     return consume;
     }```
出处：http://huangjunbin.com/page/2/