责任链模式(十三)

为请求创建了一个接收者对象的链,
通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。
意图：避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。就想抛出错误信息一样，由内到最外层

菜鸟案例：

我们创建抽象类 AbstractLogger，带有详细的日志记录级别。然后我们创建三种类型的记录器，都扩展了 AbstractLogger。每个记录器消息的级别是否属于自己的级别，如果是则相应地打印出来，否则将不打印并把消息传给下一个记录器。

把图拆开

这一大部分也算是责任链部分的主题
看图例就知道是AbstractLogger是个抽象类，那它的下面类就是继承的子类，像介绍说的是扩展了AbstractLogger ，那责任链既然是条链条，还是按顺序的，那就像单向链表，一个对象嵌套一个下一个对象。
那链条的组成对象肯定就是AbstractLogger的三个扩展类了，不可能AbstractLogger当一个链条的一个对象吧，也可以，不过这不符合这的题意
那怎么把这个链条串起来？

一个是单独弄一个方法在Demo类里把这个链条串起来，下面也是这么写的
还有一个就是在扩展AbstractLogger就写好谁是下一个，比如在ConsoleLogger中写好下一个是ErrorLogger
看代码
（1）创建抽象的记录器类(这是个通用的抽象类，下面继承的会扩展它的)
AbstractLogger.java

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） 创建扩展了该记录器类的实体类。
ConsoleLogger.java

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);
   }
}

ErrorLogger.java

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);
   }
}

FileLogger.java

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）创建不同类型的记录器。赋予它们不同的错误级别，并在每个记录器中设置下一个记录器。每个记录器中的下一个记录器代表的是链的一部分。
ChainPatternDemo.java

public class ChainPatternDemo {
   
   private static AbstractLogger getChainOfLoggers(){
 	//AbstractLogger.ERROR，DEBUG，INFO就决定它的等级了
      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.");
   }
}

执行程序，输出结果：

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.
————————————————
版权声明：本文为CSDN博主「胖墩的IT」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_43113679/article/details/99472340