[디자인 패턴] 행위 패턴 - Command Pattern (커맨드 패턴)

목차

 

📇 개요

커맨드 패턴(Command Pattern)은 요청을 객체로 캡슐화하여 매개변수화된 클라이언트를 만들고, 요청 내역을 큐에 저장하거나 로그로 기록할 수 있게 하는 행동 디자인 패턴이다. 즉, 실행될 기능을 캡슐화하여 호출자(Invoker)와 수신자(Receiver) 사이의 의존성을 제거하는 패턴이다.

 

특징

• 명령(요청)을 객체로 표현하여 캡슐화한다.
• 실행될 기능의 변경에도 호출자 코드를 수정할 필요가 없다.
• 명령의 저장, 로깅, 취소 등 다양한 확장 기능을 구현할 수 있다.

 

👩🏻‍💻 코드로 알아보자

리모컨으로 다양한 가전제품을 제어하는 예제를 통해 커맨드 패턴을 살펴보자.

// 1. 커맨드 인터페이스
interface Command {
    void execute();
    void undo();
}

// 2. 수신자(Receiver) 클래스들
class Light {
    private String location;
    
    public Light(String location) {
        this.location = location;
    }
    
    public void on() {
        System.out.println(location + " 조명이 켜졌습니다.");
    }
    
    public void off() {
        System.out.println(location + " 조명이 꺼졌습니다.");
    }
}

class Television {
    public void on() {
        System.out.println("TV가 켜졌습니다.");
    }
    
    public void off() {
        System.out.println("TV가 꺼졌습니다.");
    }
    
    public void setChannel(int channel) {
        System.out.println("TV 채널이 " + channel + "번으로 변경되었습니다.");
    }
}

// 3. 구체적인 커맨드 클래스들
class LightOnCommand implements Command {
    private Light light;
    
    public LightOnCommand(Light light) {
        this.light = light;
    }
    
    @Override
    public void execute() {
        light.on();
    }
    
    @Override
    public void undo() {
        light.off();
    }
}

class LightOffCommand implements Command {
    private Light light;
    
    public LightOffCommand(Light light) {
        this.light = light;
    }
    
    @Override
    public void execute() {
        light.off();
    }
    
    @Override
    public void undo() {
        light.on();
    }
}

class TVOnCommand implements Command {
    private Television tv;
    
    public TVOnCommand(Television tv) {
        this.tv = tv;
    }
    
    @Override
    public void execute() {
        tv.on();
    }
    
    @Override
    public void undo() {
        tv.off();
    }
}

class TVOffCommand implements Command {
    private Television tv;
    
    public TVOffCommand(Television tv) {
        this.tv = tv;
    }
    
    @Override
    public void execute() {
        tv.off();
    }
    
    @Override
    public void undo() {
        tv.on();
    }
}

class TVChangeChannelCommand implements Command {
    private Television tv;
    private int channel;
    private int previousChannel;
    
    public TVChangeChannelCommand(Television tv, int channel) {
        this.tv = tv;
        this.channel = channel;
    }
    
    @Override
    public void execute() {
        // 실제 구현에서는 이전 채널을 저장할 수 있음
        tv.setChannel(channel);
    }
    
    @Override
    public void undo() {
        // 이전 채널로 돌아가는 기능 (여기서는 간단히 구현)
        System.out.println("이전 채널로 돌아갑니다.");
    }
}

// 4. 호출자(Invoker) 클래스
class RemoteControl {
    private Command[] onCommands;
    private Command[] offCommands;
    private Command undoCommand;
    
    public RemoteControl() {
        onCommands = new Command[5];
        offCommands = new Command[5];
        
        // NoCommand 객체로 초기화
        Command noCommand = new NoCommand();
        for (int i = 0; i < 5; i++) {
            onCommands[i] = noCommand;
            offCommands[i] = noCommand;
        }
        undoCommand = noCommand;
    }
    
    public void setCommand(int slot, Command onCommand, Command offCommand) {
        onCommands[slot] = onCommand;
        offCommands[slot] = offCommand;
    }
    
    public void onButtonWasPushed(int slot) {
        onCommands[slot].execute();
        undoCommand = onCommands[slot];
    }
    
    public void offButtonWasPushed(int slot) {
        offCommands[slot].execute();
        undoCommand = offCommands[slot];
    }
    
    public void undoButtonWasPushed() {
        undoCommand.undo();
    }
    
    @Override
    public String toString() {
        StringBuffer sb = new StringBuffer();
        sb.append("\n------ 리모컨 ------\n");
        for (int i = 0; i < onCommands.length; i++) {
            sb.append("[slot " + i + "] " + onCommands[i].getClass().getName() + "   " 
                    + offCommands[i].getClass().getName() + "\n");
        }
        sb.append("[undo] " + undoCommand.getClass().getName() + "\n");
        return sb.toString();
    }
}

// Null Object 패턴을 적용한 NoCommand 클래스
class NoCommand implements Command {
    @Override
    public void execute() {
        // 아무 동작도 하지 않음
    }
    
    @Override
    public void undo() {
        // 아무 동작도 하지 않음
    }
}

// 5. 클라이언트
public class CommandPatternExample {
    public static void main(String[] args) {
        // 리모컨 생성
        RemoteControl remoteControl = new RemoteControl();
        
        // 수신자 객체들 생성
        Light livingRoomLight = new Light("거실");
        Light kitchenLight = new Light("주방");
        Television tv = new Television();
        
        // 커맨드 객체들 생성
        LightOnCommand livingRoomLightOn = new LightOnCommand(livingRoomLight);
        LightOffCommand livingRoomLightOff = new LightOffCommand(livingRoomLight);
        
        LightOnCommand kitchenLightOn = new LightOnCommand(kitchenLight);
        LightOffCommand kitchenLightOff = new LightOffCommand(kitchenLight);
        
        TVOnCommand tvOn = new TVOnCommand(tv);
        TVOffCommand tvOff = new TVOffCommand(tv);
        TVChangeChannelCommand tvChannel9 = new TVChangeChannelCommand(tv, 9);
        
        // 리모컨에 커맨드 설정
        remoteControl.setCommand(0, livingRoomLightOn, livingRoomLightOff);
        remoteControl.setCommand(1, kitchenLightOn, kitchenLightOff);
        remoteControl.setCommand(2, tvOn, tvOff);
        
        // 리모컨 정보 출력
        System.out.println(remoteControl);
        
        // 리모컨 버튼 누르기
        System.out.println("------ 리모컨 버튼 테스트 ------");
        remoteControl.onButtonWasPushed(0);  // 거실 조명 켜기
        remoteControl.offButtonWasPushed(0); // 거실 조명 끄기
        remoteControl.onButtonWasPushed(1);  // 주방 조명 켜기
        remoteControl.undoButtonWasPushed(); // 주방 조명 끄기 (실행 취소)
        
        remoteControl.onButtonWasPushed(2);  // TV 켜기
        // TV 채널 변경은 별도로 구현해야 함
        tvChannel9.execute();
        remoteControl.offButtonWasPushed(2); // TV 끄기
    }
}

• Command 인터페이스는 실행(execute())과 실행 취소(undo()) 메서드를 정의한다.
• 수신자 클래스(Light, Television)는 실제 작업을 수행하는 코드를 가진다.
• 구체적인 커맨드 클래스들(LightOnCommand, TVOffCommand 등)은 수신자 객체를 가지며 이를 통해 작업을 수행한다.
• 호출자(Invoker) 역할을 하는 RemoteControl은 Command 객체를 저장하고 필요한 시점에 실행한다.
• NoCommand 클래스는 Null Object 패턴을 적용하여 null 체크를 줄이고 코드를 단순화한다.

 

☘️ 장/단점

✅ 장점

1. 호출자와 수신자의 분리(Decoupling)
   • 명령을 실행하는 객체(호출자)와 실제 작업을 수행하는 객체(수신자)를 분리한다.
   • 이로 인해 시스템의 결합도가 낮아지고 유연성이 증가한다.
2. 명령의 확장 용이성
   • 기존 코드를 변경하지 않고도 새로운 명령을 쉽게 추가할 수 있다.
   • 예를 들어, 에어컨 제어 명령을 추가하더라도 RemoteControl 클래스는 수정할 필요가 없다.
3. 명령의 조합 가능
   • 여러 명령을 조합하여 복합 명령(Macro Command)을 만들 수 있다.
   • 예: "영화 모드" 버튼으로 조명 끄기, TV 켜기, 볼륨 조정 등을 한 번에 실행
4. 실행 취소(Undo) 및 재실행(Redo) 지원
   • 명령 객체가 상태를 저장하므로 이전 작업을 취소하는 기능을 쉽게 구현할 수 있다.
   • 명령 실행 기록을 스택에 저장하면 다중 실행 취소도 가능하다.
5. 명령 로깅 및 트랜잭션 지원
   • 명령을 객체로 저장하면 명령의 로깅과 시스템 복구가 가능해진다.
   • 트랜잭션 시스템에서는 명령 집합을 저장하고 실패 시 롤백할 수 있다.

❌ 단점

1. 클래스 수 증가
   • 각 명령마다 별도의 클래스가 필요하므로 시스템의 클래스 수가 많아질 수 있다.
   • 간단한 기능에도 새로운 클래스를 만들어야 하므로 오버헤드가 발생할 수 있다.
2. 복잡성 증가
   • 단순한 함수 호출이 여러 클래스의 상호작용으로 변하므로 시스템이 복잡해질 수 있다.
   • 특히 처음 패턴을 접하는 개발자에게는 이해하기 어려울 수 있다.
3. 메모리 사용량 증가
   • 각 명령마다 객체가 생성되므로 메모리 사용량이 증가할 수 있다.
   • 명령을 저장하고 관리하는 경우 더 많은 메모리가 필요하다.
4. 디버깅 어려움
   • 호출 체인이 길어지면 디버깅이 어려워질 수 있다.
   • 특히 undo/redo 기능이 있으면 상태 추적이 복잡해질 수 있다.

 

📌 정리

커맨드 패턴은 요청을 객체로 캡슐화하여 다양한 요청을 처리할 수 있는 유연한 시스템을 구축하는 디자인 패턴이다.

이 패턴은 호출자와 수신자를 분리하여 결합도를 낮추고, 명령의 실행, 취소, 로깅, 트랜잭션 등 다양한 기능을 지원한다. 대신 클래스 수가 많아지고 시스템이 복잡해질 수 있는 단점이 있다.

 

✅ 언제 사용하면 좋을까?

• 작업에 대한 실행 취소(undo)가 필요할 때
• 명령 기록, 로깅, 트랜잭션 시스템이 필요할 때
• 명령의 지연 실행이나 스케줄링이 필요할 때
• 매개변수화된 객체를 통한 동작 수행이 필요할 때
• 명령을 큐에 저장하고 순차적으로 실행해야 할 때

❌ 언제 피해야 할까?

• 단순한 작업에 과도한 복잡성을 추가할 때
• 명령 객체가 너무 많아져서 관리가 어려울 때
• 실행 취소나 로깅 등의 기능이 필요 없을 때
• 성능이 중요하고 명령 객체의 오버헤드가 문제가 될 때

 

📋 참고

• https://refactoring.guru/ko/design-patterns/command