设计模式责任链模式

作者: GB_speak | 来源:发表于2017-04-13 19:22 被阅读20次

    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/

    相关文章

      网友评论

        本文标题:设计模式责任链模式

        本文链接:https://www.haomeiwen.com/subject/joqiattx.html