[행위] 책임 연쇄 패턴

책임 연쇄 패턴(Chain of Responsibility)

 

클라이언트의 요청을 수신해서 처리할 수 있는 객체를 찾을때까지 집합 내부에서 요청을 전달하는 

패턴

 

'파이프 라인'이라고 비유하면 이해가 쉽습니다. 

파이프라인을 따라 가다가 요청을 처리 가능한 그 handler가 이벤트를 처리하고,

처리불가능하면 다음 handler에 요청을 넘깁니다.

 

장점)

 

결합도를 낮추고 요청의 발신자, 수신자 분리

클라이언트는 내부를 알 필요가 없다

집합 내 순서를 유연하게 처리 가능

새로운 요청을 처리하기 매우 쉬워진다(계속 붙여주면 됨) 

 

단점)

디버깅이 쉽지 않다

사이클이 발생하지 않게 주의

 

코드 예시

 

숫자를 넣었을때 10, 100, 1000이하인지 처리하는 handler를 만들어봅시다.

 

class COR {
    
    constructor(){
        this.setLog();
    }

    setLog(){
        this.log = 0;
    }

    setNextChain(nextChain){
        this.chain = nextChain;
        return nextChain;
    }

    support(number){
        if(this.resolve(number)){
            this.done(number);
        }
        else if(this.chain){
            this.chain.support(number);
        }
        else{
            this.fail(number);
        }
    }

    resolve(number){
        return false;
    }

    done(number){
        console.log(`${number} less than ${this.log} `);
    }

    fail(number){
        console.log(`${number} bigger than ${this.log} `);
    }
}

기본 interface는 위의 코드와 같습니다.

 

support 라는 메소드로 이벤트를 처리하는데,

지금 이벤트 핸들링이 가능하면 this.done 메소드를 호출해서 이벤트 체인을 끝내고 자신의 이벤트를 실행합니다.

그렇지 않으면 체인을 걸어준 다음 handler로 넘기고,

끝까지 도착했으면 이벤트 핸들링이 불가능한 뜻이므로 this.fail 메소드를 실행해 체이닝을 종료합니다.

 

class TenChain extends COR{
    setLog(){
        this.log = 10;
    }


    resolve(number){
        if(number<10){
            return true;
        }
        return false;
    }
}

class HundredChain extends COR{
    setLog(){
        this.log = 100;
    }

    resolve(number){
        if(number<100){
            return true;
        }
        return false;
    }
}

class ThousandChain extends COR{
    setLog(){
        this.log = 1000;
    }
    resolve(number){
        if(number<1000){
            return true;
        }
        return false;
    }
}

각각 10, 100, 1000 이하인지 확인하는 간단한 예시 이벤트 핸들러입니다. 

실제 책임 연쇄 패턴 사용 예시는 이보다 복잡하지만 전체 구조를 훑어보기에 알맞은 예시인거 같아서 작성했습니다.

 

let PC = new TenChain();
let cursor = PC;

cursor = cursor.setNextChain(new HundredChain());
cursor = cursor.setNextChain(new ThousandChain());

PC.support(1);
PC.support(30);
PC.support(210);
PC.support(220);
PC.support(3100);

/*
1 less than 10 
30 less than 100 
210 less than 1000 
220 less than 1000 
3100 bigger than 1000 
*/

10 handler -> 100 handler -> 1000 handler 로 체인이 걸려있고, 실제 테스트해보니

잘 작동하는것을 볼 수 있습니다.

 

 

 

 

ref

 

https://medium.com/geekculture/understanding-the-chain-of-responsibility-pattern-d729ef84621c

Understanding The Chain of Responsibility Pattern