设计模式——责任链模式详解

0.  前言

 

写在最前面，本人的设计模式类博文，建议先看博文前半部分的理论介绍，再看后半部分的实例分析，最后再返回来复习一遍理论介绍，这时候你就会发现我在重点处标红的用心，对于帮助你理解设计模式有奇效哦~本文原创，转载请注明出处为SEU_Calvin的博客。

责任链模式是行为型设计模式之一。链中的每个节点即一个对象，每一个对象拥有不同的处理逻辑，请求从链的首端发出，依次传递给每个节点对象，直到有对象处理这个请求为止。这就是所谓的责任链模式。

 

1.  责任链模式介绍

责任链模式定义：

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

 

责任链模式的使用场景：

多个对象可处理同一个请求，但是到底谁处理要动态决定。但是还是要向多个对象中的一个提交请求。

 

享元模式包括的角色：

 

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

（2）具体处理者ConcreteHandler类：具体的处理类，如果不负责该类的处理条件则将请求交给下一个处理者。

 

2.  责任链模式通用模版代码

从下面代码中可以看出，ConcreteHandlerA中持有了ConcreteHandlerB的引用，ConcreteHandlerB中持有了ConcreteHandlerA的引用，两者均可根据请求参数决定自己处理请求，或者是给下一个处理者处理请求。

/**
 * Iterator Pattern
 * Created by Calvin on 2017/5/4.
 */
public class Iterator {

    public static void main(String[] args) {
        ConcreteHandlerA a = new ConcreteHandlerA();
        ConcreteHandlerB b = new ConcreteHandlerB();
        a.myHandler = b;
        b.myHandler = a;

        a.function("B");
    }

    public static class ConcreteHandlerA extends Handler{
        @Override
        public void function(String condition) {
            if(condition.equals("A")){
                System.out.println("ConcreteHandlerA handle this");
            }else{
                myHandler.function(condition);
            }
        }
    }

    public static class ConcreteHandlerB extends Handler{
        @Override
        public void function(String condition) {
            if(condition.equals("B")){
                System.out.println("ConcreteHandlerB handle this");
            }else{
                myHandler.function(condition);
            }
        }
    }

    public static abstract class Handler {
        protected Handler myHandler;
        public abstract void function(String condition);
    }

}

3.  责任链模式实例代码

这里引入一个实例，在公司里作为新人肯定会遇到很多难题，不会的问题可以向师兄、技术主管、技术总监虚心请教，师兄、技术主管、技术总监能解决的问题难度不一样，比如师兄可以解决难度<=10的问题、主管可以解决难度<=20的问题、总监可以解决难度<=30的问题。这个场景就可以使用责任链模式进行解决。

/** 
 * Iterator Pattern 
 * Created by Calvin on 2017/5/4. 
 */  
public class Iterator {  
  
    public static void main(String[] args) {  
    	ShiXiong shiXiong = new ShiXiong();
    	ZhuGuan zhuGuan = new ZhuGuan();
    	ZongJian zongJian = new ZongJian();
    	
    	shiXiong.nextRespondent = zhuGuan;
    	zhuGuan.nextRespondent = zongJian;
    	zongJian.nextRespondent = null;
    	
        shiXiong.handleQuestion(21);
    }  
  
    public static abstract class Respondent {  
        protected Respondent nextRespondent;  
        public final void handleQuestion(int level){
        	if(level <= getRespondentLevel()){
        		//该类自己处理
        		handle(level);
        	}else {
				if(nextRespondent !=null ){
					//下一个处理对象处理
					nextRespondent.handleQuestion(level);
				}else {
					//没有人可以处理该请求
					System.out.println("Nobody can handle this request.");
				}
			}
        }
        
        public abstract int getRespondentLevel(); 
        
        public abstract void handle(int level); 
        
    }  
    
    public static class ShiXiong extends Respondent{

		@Override
		public int getRespondentLevel() {
			return 10;
		}

		@Override
		public void handle(int level) {
			System.out.println("师兄解决了难度为" + level + "的问题");
		}
    	
    }
  
    public static class ZhuGuan extends Respondent{

		@Override
		public int getRespondentLevel() {
			return 20;
		}

		@Override
		public void handle(int level) {
			System.out.println("主管解决了难度为" + level + "的问题");
		}
    	
    }
    
    public static class ZongJian extends Respondent{

		@Override
		public int getRespondentLevel() {
			return 30;
		}

		@Override
		public void handle(int level) {
			System.out.println("总监解决了难度为" + level + "的问题");
		}
    	
    }
}  

4. 责任链模式总结

责任链模式的灵活之处在于，可以灵活改变责任链的结构，比如上个例子中可以直接越过主管直接向总监请教。还有就是请求者和处理者之间的解耦。缺点在于处理者过多的情况，遍历处理者势必会影响性能。

在Android中，ViewGroup的事件传递机制的递归调用就类似于责任链模式。一旦找到处理者，则该处理者就会消耗掉该点击事件，否则会将该事件向外传递。