职责链模式

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

优点：1.客户端与具体的处理者解耦，客户端只认识一个Hanlder接口，降低了客户端（即请求发送者）与处理者的耦合度。

           2.简化了对象。使得对象不需要知道链的结构。

缺点：1.提高了系统的复杂度。

           2.不能保证一定被处理。           

使用场景：多个类分别多次的调用。

类图：

通用代码：

Handler 接口

      static abstract class Handler {
             protected Handler mNextHandler;
             public void setnextHanlder(Handler successor) {
                 this.mNextHandler = successor;
              }
             public abstract void handleRequest(String request);
          }
  
 

具体的处理类

      static class ConcreteHandlerA extends Handler {
             @Override
              public void handleRequest(String request) {
                 if ("requestA".equals(request)) {
                     //doSomething
                     return;
                  }
                 //给下一个责任类
                 if (this.mNextHandler != null) {
                     this.mNextHandler.handleRequest(request);
                  }
              }
          }
  
 

调用

      class Client {
         public static void main(String[] args) {
              Handler handlerA = new ConcreteHandlerA();
              Handler handlerB = new ConcreteHandlerB();
             //放入下一个责任类 
              handlerA.setnextHanlder(handlerB);
              handlerA.handleRequest("requestB");
          }
  
 

栗子

抽象审批类()：设计的核心类。处理请求和跳转请求。

      public abstract class ClassType{
     	protected ClassType nextClassType;//下个责任对象
     	public ClassType(String name) {
     		super();
     		this.name = name;
      	}
     	//设定下个责任对象
     	public void setNextClassType(ClassType nextClassType) {
     		this.nextClassType = nextClassType;
      	}
     	/**
       * 处理请求的核心的业务方法
       * @param request
       */
     	public abstract void handleRequest(Long age);
      }
  
 

抽象实现类

      public class smallClass extends ClassType{
     	@Override
      	public void handleRequest(Long age) {
     		if(age < 6){
     			System.out.println("是小班我的人");
      		}else{
     			this.nextLeader.handleRequest(age);
      		}
      	}
      }
  
 

      public class middleClass extends ClassType{
     	@Override
      	public void handleRequest(Long age) {
     		if(age > 6 && age < 8){
     			System.out.println("是中班班我的人");
      		}else{
     			this.nextLeader.handleRequest(age);
      		}
      	}
      }
  
 

      public class bigClass extends ClassType{
     	@Override
      	public void handleRequest(Long age) {
     		if(age > 8 && age < 10){
     			System.out.println("是大班班我的人");
      		}else{
     			System.out.println("多大了 还来幼儿园");
      		}
      	}
      }
  
 

调用

      public class Client {
     	public static void main(String[] args) {
      		ClassType small = new smallClass();
      		ClassType middle = new middleClass();
      		ClassType big = new bigClass();
     		//组织责任链对象关系
      		small.setNextLeader(middle);
      		middle.setNextLeader(big);
     		//开始请假操作
      		small.handleRequest(12);
      	}
  
 

文章来源: baocl.blog.csdn.net，作者：小黄鸡1992，版权归原作者所有，如需转载，请联系作者。

原文链接：baocl.blog.csdn.net/article/details/102665192