Deep Dive Into Design Patterns - 책임 연쇄 패턴

💡 책임 연쇄(Chain of Responsibility) 패턴이란?

핸들러들의 체인(사슬)을 따라 요청을 전달할 수 있게 해주는 행동 디자인 패턴입니다. 클라이어트의 요청에 대한 세세한 처리를 하나의 객체가 몽땅 하는 것이 아닌, 여러 개의 처리 객체들로 나누고, 이들을 사슬(chain)처럼 연결해 집합 안에서 연쇄적으로 처리하는 행동 패턴입니다.

 

이러한 처리 객체들을 핸들러(handler)라고 부르는데, 요청을 받으면 각 핸들러는 요청을 처리할 수 있는지 판단하고, 없으면 체인의 다음 핸들러로 처리에 대한 책임을 전가합니다.

 

처리에 대한 책임을 요청을 보내는 쪽(sender)과 요청을 처리하는(receiver) 쪽을 분리하여 각 객체를 부품으로 독립시키고 결합도를 느슨하게 만들며, 상황에 따라서 요청을 처리할 객체가 변하는 프로그램에도 유연하게 대응할 수 있다는 장점을 가지고 있습니다. 

 

💡 클래스 다이어그램으로 본 책임 연쇄 패턴

 

1. Handler : 요청을 수신하고 처리 객체들의 집합을 정의하는 인터페이스이다.
2. BaseHandler : 모든 핸들러 클래스들을 묶는 추상 클래스로, 선택적이다.
3. ConcreteHandler : 요청을 처리하는 실제 처리 객체로, 핸들러에 대한 필드를 내부에 가지고 있으며 메서드를 통해 다음 핸들러를 체인시키고 다음  바라본다. 자신이 처리할 수 없는 요구가 나오면 바라보고 있는 다음 체인의 핸들러에게 요청을 떠넘긴다. ConcreteHandler1 - ConcreteHandler2 - ConcreteHandler3 - ... 이런식으로 체인 형식이 구성되게 된다.
4. Client : 요청을 Handler에게 전달한다. 요청은 모든 핸들러에 보낼 수 있고, 꼭 첫 번째 핸들러일 필요는 없다.

 

💡 책임 연쇄 패턴 구현

- Base Handler

// 구체적인 핸들러를 묶는 인터페이스 (추상 클래스)
abstract class Handler {
    // 다음 체인으로 연결될 핸들러
    protected Handler nextHandler = null;

    // 생성자를 통해 연결시킬 핸들러를 등록
    public Handler setNext(Handler handler) {
        this.nextHandler = handler;
        return handler; // 메서드 체이닝 구성을 위해 인자를 그대로 반환함
    }

    // 자식 핸들러에서 구체화 하는 추상 메서드
    protected abstract void process(String url);

    // 핸들러가 요청에 대해 처리하는 메서드 
    public void run(String url) {
        process(url);

        // 만일 핸들러가 연결된게 있다면 다음 핸들러로 책임을 떠넘긴다
        if (nextHandler != null)
            nextHandler.run(url);
    }
}

 

-  Concrete Handler

class ProtocolHandler extends Handler {
    @Override
    protected void process(String url) {
        int index = url.indexOf("://");
        if (index != -1) {
            System.out.println("PROTOCOL : " + url.substring(0, index));
        } else {
            System.out.println("NO PROTOCOL");
        }
    }
}

class DomianHandler extends Handler {
    @Override
    protected void process(String url) {
        int startIndex = url.indexOf("://");
        int lastIndex = url.lastIndexOf(":");

        System.out.print("DOMAIN : ");
        if (startIndex == -1) {
            if (lastIndex == -1) {
                System.out.println(url);
            } else {
                System.out.println(url.substring(0, lastIndex));
            }
        } else if (startIndex != lastIndex) {
            System.out.println(url.substring(startIndex + 3, lastIndex));
        } else {
            System.out.println(url.substring(startIndex + 3));
        }
    }
}

class PortHandler extends Handler {
    @Override
    protected void process(String url) {
        int index = url.lastIndexOf(":");
        if (index != -1) {
            String strPort = url.substring(index + 1);
            try {
                int port = Integer.parseInt((strPort));
                System.out.println("PORT : " + port);
            } catch (NumberFormatException e) {
                e.printStackTrace();
            }
        }
    }
}

 

-  Client

class Client {
    public static void main(String[] args) {
        // 1. 핸들러 생성
        Handler handler1 = new ProtocolHandler();
        Handler handler2 = new DomianHandler();
        Handler handler3 = new PortHandler();

        // 2. 핸들러 연결 설정 (handler1 → handler2 → handler3)
        handler1.setNext(handler2).setNext(handler3);

        // 3. 요청에 대한 처리 연쇄 실행
        String url1 = "<http://www.youtube.com:80>";
        System.out.println("INPUT: " + url1);
        handler1.run(url1);

        System.out.println();

        String url2 = "<https://www.inpa.tistory.com:443>";
        System.out.println("INPUT: " + url2);
        handler1.run(url2);

        System.out.println();

        String url3 = "";
        System.out.println("INPUT: " + url3);
        handler1.run(url3);
    }
}

 

💡 마무리

책임 연쇄 패턴은

1. 특정 요청을 2개 이상의 여러 객체에서 판별하고 처리해야 할 때
2. 특정 순서로 여러 핸들러를 실행해야 할 때
3. 프로그램이 다양한 방식과 종류의 요청을 처리할 것으로 예상되지만 정확한 요청 유형과 순서를 미리 알 수 없을 때
4. 요청을 처리할 수 있는 객체 집합이 동적으로 정의되어야 할 때 (체인 연결을 런타임에서 동적으로 설정)

에 사용할 수 있습니다.

 

책임 연쇄 패턴을 사용하면 클라이언트는 처리 객체의 체인 집합 내부의 구조를 알 필요가 없고, 각각의 체인은 자신이 해야하는 일만 하기 때문에 새로운 요청에 대한 처리 객체 생성이 편리해집니다(SRP 준수). 또한, 기존 클라이언트 코드를 변경하지 않고 핸들러를 체인에 동적으로 추가하거나 처리 순서를 변경하거나 삭제할 수 있습니다(OCP 준수).

 

그러나, 요청이 반드시 수행된다는 보장이 없습니다. (체인 끝까지 갔는데도 처리되지 않을 수 있음.)

 

책임 연쇄 패턴

💠 Chain Of Responsibility 패턴 - 완벽 마스터하기