책임의 사슬

이름에서 알 수 있듯이 책임 체인은 요청을 처리하기 위한 수신자 개체 체인을 생성합니다.
이 패턴은 요청 유형에 따라 요청의 발신자와 수신자를 분리합니다.
이 패턴은 행동 패턴에 속합니다.

이 패턴에서는 요청의 각 수신자 개체가 요청을 처리할 수 없는 경우 다음 개체에 대한 참조를 가지며 요청은 체인의 다음 수신자에게 전달됩니다.

메시지(요청) 수준에 따라 메시지를 기록하는 로깅 메커니즘의 예를 통해 이를 이해해 보겠습니다.

추상로거

package Patterns.Behavioral.chainOfResponsibility;

public abstract class AbstractLogger{
    /**
     * TRACE < DEBUG < INFO < WARN < ERROR < FATAL
     * which means if the level is INFO, then INFO, WARN, ERROR and FATAL messages will be logged
     * but if the level is ERROR then only ERROR and FATAL messages will be logged 
    */
    //higher the number higher the priority
    public static int DEBUG = 1;
    public static int INFO = 2;
    public static int ERROR = 3;
    protected int LEVEL;
    //next Logger in the chain of responsibility
    private AbstractLogger nextLogger;
    public void setNextLogger(AbstractLogger logger){
        this.nextLogger = logger;
    }
    public void logMessage(int level, String message){
        //If the logging level of the message is greater than the current Logger's LEVEL then it will be logged 
        //example if level = ERROR and this.LEVEL = INFO then the message will be logged as INFO has a lower priority than ERROR
        if(this.LEVEL <=level){
            write(message);
        }
        // else the message/request will be passed down to the next logger/object in the chain
        else{
            if(nextLogger!=null){
                nextLogger.logMessage(level, message);
            }
        }
    }
    abstract void write(String message);
}

콘크리트 로거

package Patterns.Behavioral.chainOfResponsibility;

public class DebugLogger extends AbstractLogger {
    private String className = this.getClass().getSimpleName();
    private String logger   = "DEBUG";
    public DebugLogger(){
        this.LEVEL = 1;
    }

    @Override
    void write(String message) {
        System.out.println(className+":"+logger+":"+message);
    }

}

package Patterns.Behavioral.chainOfResponsibility;

public class InfoLogger extends AbstractLogger {
    private String className = this.getClass().getSimpleName();
    private String logger   = "INFO";
    public InfoLogger(){
        this.LEVEL = 2;
    }

    @Override
    void write(String message) {
        System.out.println(className+":"+logger+":"+message);
    }

}
package Patterns.Behavioral.chainOfResponsibility;

public class ErrorLogger extends AbstractLogger {
    private String className = this.getClass().getSimpleName();
    private String logger   = "ERROR";
    public ErrorLogger(){
        this.LEVEL = 3;
    }

    @Override
    void write(String message) {
        System.out.println(className+":"+logger+":"+message);
    }

}

메인

package Patterns.Behavioral.chainOfResponsibility;

public class Main {
    public static AbstractLogger intializeLoggers(){
        AbstractLogger errorLogger = new ErrorLogger(); //LEVEL = 3;
        AbstractLogger infoLogger = new InfoLogger(); //LEVEL = 2;
        AbstractLogger debugLogger = new DebugLogger(); // LEVEL = 1;
        errorLogger.setNextLogger(infoLogger);
        infoLogger.setNextLogger(debugLogger);
        return errorLogger;// return the highest priority Logger first


    }
    public static void main(String args[]){
        // initialize the chain of responsible objects
        AbstractLogger logger  = intializeLoggers();

        //pass the request down the responsibility chain
        //logging level 3 logger
        logger.logMessage(3, "log this error message");
        //loggin level 2 logger
        logger.logMessage(2, "info level log message");
        //logging level 1 logger
        logger.logMessage(1, "debug level log message");
    }
}

출력:

ErrorLogger:ERROR:log this error message
InfoLogger:INFO:info level log message
DebugLogger:DEBUG:debug level log message

핵심사항

• LSP(리스코프 대체 원칙, 즉 견고한 디자인 패턴)를 따릅니다.
• 철저한 원칙의 SRP를 따릅니다.
• 기존 코드를 전혀 수정하지 않고도 추적, 치명적 등의 로거를 추가할 수 있으므로 견고한 원칙의 OCP를 따릅니다.
• ISP도 따릅니다.

위 내용은 책임의 사슬의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!