首页 责任链设计模式
文章
取消

责任链设计模式

责任链模式概念

避免请求发送者与接收者耦合在一起,让多个对象都有可能接收请求,将这些对象连接成一条链,并且沿着这条链传递请求,直到有对象处理它为止。

应用场景

  1. 有多个对象可以处理同一个请求,具体哪个对象处理该请求由运行时刻自动确定
  2. 在不明确指定接收者的情况下,向多个对象中的一个提交一个请求
  3. 可动态指定一组对象处理请求

    实现案例

    • 创建抽象的记录器类。 ``` 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);

}

1
2
3
4
5
6
7
8
9
10
11
12
13
- 创建扩展了该记录器类的实体类。
``` 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类:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    
    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类:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    
    public class FileLogger extends AbstractLogger {
    
     public FileLogger(int level){
        this.level = level;
     }
    
     @Override
     protected void write(String message) {
        System.out.println("File::Logger: " + message);
     }
    }
    
  • 创建不同类型的记录器。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    
    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.");
     }
    }
    
本文由作者按照 CC BY 4.0 进行授权
载入天数...载入时分秒...