设计模式 责任链模式

• 

  设计模式 - 责任链模式

  责任链模式顾名思义，责任链模式为请求创建了接收方对象链。此模式根据请求的类型解耦请求的发送方和接收方。这种模式属于行为模式。

  在这种模式下，通常每个接收器都包含对另一个接收器的引用。如果一个对象无法处理该请求，则将其传递给下一个接收者，依此类推。
• 

  实例

  我们创建了一个抽象级别为Logging的AbstractLogger类。然后，我们创建了三种类型的记录器，它们扩展了AbstractLogger。每个记录器都会将消息级别检查到其级别并进行相应打印，否则不会打印并将消息传递给下一个记录器。

  

  第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;
  
     //next element in chain or responsibility
     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 , ErrorLogger.java , FileLogger.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);
     }
  }
  

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

  
  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 an debug level information.");
  
        loggerChain.logMessage(AbstractLogger.ERROR, 
           "This is an error information.");
     }
  }
  

  步骤4 - 验证输出。

  
  Standard Console::Logger: This is an information.
  File::Logger: This is an debug level information.
  Standard Console::Logger: This is an 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.