行为型模式-责任链模式

代码引自：https://www.runoob.com/design-pattern/chain-of-responsibility-pattern.html

定义：

就是用来处理事情责任的一条执行链，执行链上有多个节点，每个节点都有机会匹配到（条件匹配）处理请求事务，如果某个节点处理完了就可以根据实际业务需求传递给下一个节点继续处理或者返回处理完毕。

1 首先是抽象方类，抽象类里面有设置下个节点的方法

public abstract class AbstractLogger {
	
	   public static int INFO = 1;
	   public static int DEBUG = 2;
	   public static int ERROR = 3;
	 
	   protected int level;
	 
	   //责任链中的下一个元素
	   protected AbstractLogger nextLogger;
	 
	   public void setNextLogger(AbstractLogger nextLogger){
	      this.nextLogger = nextLogger;
	   }
	 
	   public void logMessage(int level, String message){
	      if(this.level <= level){
	         write(message);
	      }
	      if(nextLogger !=null){
	         nextLogger.logMessage(level, message);
	      }
	   }
	 
	   abstract protected void write(String message);   

}

2 设置不同的子类，子类要重载父类的方法，有能接受判断调节的构造方法。

public class ConsoleLogger extends AbstractLogger {
	 
	   public ConsoleLogger(int level){
	      this.level = level;
	   }
	 
	   @Override
	   protected void write(String message) {    
	      System.out.println("Standard Console::Logger: " + message);
	   }
}

public class ErrorLogger extends AbstractLogger {
	 
	   public ErrorLogger(int level){
	      this.level = level;
	   }
	 
	   @Override
	   protected void write(String message) {    
	      System.out.println("Error Console::Logger: " + message);
	   }
}

public class FileLogger extends AbstractLogger {
	 
	   public FileLogger(int level){
	      this.level = level;
	   }
	 
	   @Override
	   protected void write(String message) {    
	      System.out.println("File::Logger: " + message);
	   }
}

3 Test 类，父类对象指向子类实现，创建三个子类对象。设置责任链(已设置好判断调节)。

public class ChainPatternDemo {
	   
	   private static AbstractLogger getChainOfLoggers(){
	 
	      AbstractLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR);
	      AbstractLogger fileLogger = new FileLogger(AbstractLogger.DEBUG);
	      AbstractLogger consoleLogger = new ConsoleLogger(AbstractLogger.INFO);
	 
	      errorLogger.setNextLogger(fileLogger);
	      fileLogger.setNextLogger(consoleLogger);
	 
	      return errorLogger;  
	   }
	 
	   public static void main(String[] args) {
	      AbstractLogger loggerChain = getChainOfLoggers();
	 
	      loggerChain.logMessage(AbstractLogger.INFO, "This is an information.");
	 
	      loggerChain.logMessage(AbstractLogger.DEBUG, 
	         "This is a debug level information.");
	 
	      loggerChain.logMessage(AbstractLogger.ERROR, 
	         "This is an error information.");
	   }
}

4 执行结果：

Standard Console::Logger: This is an information.
File::Logger: This is a debug level information.
Standard Console::Logger: This is a debug level information.
Error Console::Logger: This is an error information.
File::Logger: This is an error information.
Standard Console::Logger: This is an error information.

5 总结：责任链的重点是事件在链上传递的时候，会根据事先设置好的条件和传入调节匹配来抉择是否当前节点去执行。

缺点：如果链条保护多个节点，势必会造成对性能的浪费，因为白白执行了很多传递。