21. 责任链模式

### 21. 责任链模式
> 责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。**在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。**

- **主要解决**：职责链上的处理者负责处理请求，客户只需要将请求发送到职责链上即可，无须关心请求的处理细节和请求的传递，所以职责链将请求的发送者和请求的处理者解耦了。

以Android Studio中打印日志为例，最小单元步骤：

- 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);
	        }
	        // 递归效果，不断调用下一级 logMessage
	        if (nextLogger != null) {
	            nextLogger.logMessage(level, message);
	        }
	    }
	
	    protected abstract void write(String message);
	}
	```

- 2、创建扩展了该记录器类的实体类。

```java
	public class ConsoleLogger extends AbstractLogger {
	
	    public ConsoleLogger(int level) {
	        this.level = level;
	    }
	
	    @Override
	    protected void write(String message) {
	        Log.e("---", "Standard Console::Logger  " + message);
	    }
	}
	```

```java
	public class FileLogger extends AbstractLogger {
	
	    public FileLogger(int level) {
	        this.level = level;
	    }
	
	    @Override
	    protected void write(String message) {
	        Log.e("---", "File::Logger  " + message);
	    }
	}
	```

```java
	public class ErrorLogger extends AbstractLogger {
	
	    public ErrorLogger(int level) {
	        this.level = level;
	    }
	
	    @Override
	    protected void write(String message) {
	        Log.e("---", "Error Console::Logger  " + message);
	    }
	}
	```

- 3、创建不同类型的记录器。赋予它们不同的错误级别，并在每个记录器中设置下一个记录器。每个记录器中的下一个记录器代表的是链的一部分。

```java
	public static AbstractLogger getChainOfLoggers() {
        ErrorLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR);
        FileLogger fileLogger = new FileLogger(AbstractLogger.DEBUG);
        ConsoleLogger consoleLogger = new ConsoleLogger(AbstractLogger.INFO);
        errorLogger.setNextLogger(fileLogger);
        fileLogger.setNextLogger(consoleLogger);
        return errorLogger;
	}
	
	AbstractLogger logger = getChainOfLoggers();
	
    // ---: Standard Console::Logger  this is an information.
    logger.logMessage(AbstractLogger.INFO, "this is an information.");
    
    // ---: File::Logger  this is a debug level information.
    // ---: Standard Console::Logger  this is a debug level information.
    logger.logMessage(AbstractLogger.DEBUG, "this is a debug level information.");

// ---: Error Console::Logger  this is a error level information.
    // ---: File::Logger  this is a error level information.
    // ---: Standard Console::Logger  this is a error level information.
    logger.logMessage(AbstractLogger.ERROR, "this is a error level information.");

```