패턴은 행동(Behavioral) - 책임 연쇄(Chain of Responsibility) 패턴

책임 연쇄(Chain of Responsibility) 패턴

책임 연쇄(Chain of Responsibility) 패턴은 행동(Behavioral) 패턴에 속합니다. 이 패턴은 요청을 처리하는 여러 객체를 연결하여 요청을 처리할 수 있는 객체가 나올 때까지 객체 체인을 따라 요청을 전달합니다. 요청을 처리할 객체를 동적으로 결정할 수 있도록 설계됩니다.

---

책임 연쇄 패턴의 특징

1. 요청 처리의 유연성:
   • 요청을 처리할 객체를 명확히 알 필요 없이 처리의 흐름을 객체 간 연결을 통해 동적으로 결정합니다.
2. 결합도 감소:
   • 요청 발신자와 처리자가 서로를 직접 참조하지 않으므로 객체 간 결합도가 낮아집니다.
3. 확장성 증가:
   • 새로운 처리 객체를 추가하거나 변경할 때 기존 객체를 수정할 필요 없이 체인에 추가만 하면 됩니다.

---

책임 연쇄 패턴의 구성요소

1. Handler (처리자):
   • 요청 처리의 기본 인터페이스를 정의합니다. 요청을 처리하거나 다음 처리자에 요청을 전달할 수 있습니다.
2. ConcreteHandler (구체적인 처리자):
   • Handler를 구현하며, 요청을 처리하거나 다음 처리자로 요청을 전달합니다.
3. Client (클라이언트):
   • 요청을 초기 처리자에게 전달하며, 처리 여부는 각 처리자가 결정합니다.

---

JAVA 예제

1. Handler 인터페이스

// Handler 인터페이스
interface Handler {
    void setNextHandler(Handler nextHandler); // 다음 처리자를 설정
    void handleRequest(String request); // 요청 처리
}

 

 

2. ConcreteHandler 구현

// ConcreteHandler: LowLevelHandler
class LowLevelHandler implements Handler {
    private Handler nextHandler;

    @Override
    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void handleRequest(String request) {
        if (request.equals("Low")) {
            System.out.println("LowLevelHandler 처리: " + request);
        } else {
            if (nextHandler != null) {
                nextHandler.handleRequest(request);
            } else {
                System.out.println("요청 처리 불가: " + request);
            }
        }
    }
}

// ConcreteHandler: MidLevelHandler
class MidLevelHandler implements Handler {
    private Handler nextHandler;

    @Override
    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void handleRequest(String request) {
        if (request.equals("Mid")) {
            System.out.println("MidLevelHandler 처리: " + request);
        } else {
            if (nextHandler != null) {
                nextHandler.handleRequest(request);
            } else {
                System.out.println("요청 처리 불가: " + request);
            }
        }
    }
}

// ConcreteHandler: HighLevelHandler
class HighLevelHandler implements Handler {
    private Handler nextHandler;

    @Override
    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void handleRequest(String request) {
        if (request.equals("High")) {
            System.out.println("HighLevelHandler 처리: " + request);
        } else {
            if (nextHandler != null) {
                nextHandler.handleRequest(request);
            } else {
                System.out.println("요청 처리 불가: " + request);
            }
        }
    }
}

 

 

3. 사용 예시

public class ChainOfResponsibilityExample {
    public static void main(String[] args) {
        // 처리자 생성
        Handler lowLevelHandler = new LowLevelHandler();
        Handler midLevelHandler = new MidLevelHandler();
        Handler highLevelHandler = new HighLevelHandler();

        // 처리자 체인 구성
        lowLevelHandler.setNextHandler(midLevelHandler);
        midLevelHandler.setNextHandler(highLevelHandler);

        // 요청 처리
        System.out.println("요청: Low");
        lowLevelHandler.handleRequest("Low");

        System.out.println("\n요청: Mid");
        lowLevelHandler.handleRequest("Mid");

        System.out.println("\n요청: High");
        lowLevelHandler.handleRequest("High");

        System.out.println("\n요청: Unknown");
        lowLevelHandler.handleRequest("Unknown");
    }
}

 

 

실행 결과

요청: Low
LowLevelHandler 처리: Low

요청: Mid
MidLevelHandler 처리: Mid

요청: High
HighLevelHandler 처리: High

요청: Unknown
요청 처리 불가: Unknown

 

 

---

책임 연쇄 패턴의 활용 사례

1. 로깅 시스템:
   • 다양한 수준(Info, Debug, Error)의 로그를 처리하기 위해 사용.
2. UI 이벤트 처리:
   • 이벤트가 발생했을 때 적합한 컴포넌트가 처리하도록 이벤트 체인을 구성.
3. 지원 요청 처리 시스템:
   • 고객 지원 요청을 우선순위에 따라 적합한 팀(1단계, 2단계, 관리자)에서 처리.
4. 권한 검증 시스템:
   • 요청에 따라 적절한 권한을 가진 객체에서 처리.

---

장점

1. 결합도 감소:
   • 요청을 처리하는 객체와 클라이언트 간의 직접적인 결합을 줄입니다.
2. 확장성 증가:
   • 새로운 처리자를 쉽게 추가할 수 있습니다.
3. 동적 처리 가능:
   • 요청 처리의 순서나 체인을 동적으로 변경할 수 있습니다.

---

단점

1. 디버깅 어려움:
   • 요청이 어디서 처리되었는지 추적하기 어려울 수 있습니다.
2. 요청 처리 실패 가능성:
   • 모든 처리자가 요청을 처리하지 못하면 요청이 처리되지 않고 끝날 수 있습니다.
3. 복잡성 증가:
   • 체인이 길어질수록 유지보수가 어려울 수 있습니다.