SW

[개발서적] 헤드퍼스트 디자인 패턴 Ch12. 복합 패턴

SWKo — Thu, 24 Oct 2024 09:47:05 +0900

1. 복합 패턴

복합 패턴 = 여러 패턴을 함께 사용해서 다양한 문제를 해결하는 패턴 = 패턴으로 이루어진 패턴

오리 시뮬레이션 게임을 처음부터 다시 만들면서 몇 가지 기능을 추가해 봅시다.

이 과정에서 하나의 문제를 해결할 때 여러 패턴이 어떻게 공존하고 협력하는지 볼 수 있습니다.

1. Quackable 인터페이스 정의

public interface Quackable {
    public void quack();
}

Quackable 인터페이스는 quack() 메서드를 선언합니다. 이 메서드는 오리가 소리를 낼 때 사용됩니다.

2. Quackable 구현 클래스들

public class MallardDuck implements Quackable {
    public void quack() {
        System.out.println("꽥꽥");
    }
}

public class RedheadDuck implements Quackable {
    public void quack() {
        System.out.println("꽥꽥");
    }
}

public class DuckCall implements Quackable {
    public void quack() {
        System.out.println("꽉꽉");
    }
}

public class RubberDuck implements Quackable {
    public void quack() {
        System.out.println("삑삑");
    }
}

각 오리 클래스는 Quackable 인터페이스를 구현하여 자신의 고유한 quack() 메서드를 정의합니다.

3. DuckSimulator 클래스

public class DuckSimulator {
    public static void main(String[] args) {
        DuckSimulator simulator = new DuckSimulator();
        simulator.simulate();
    }

    void simulate() {
        Quackable mallardDuck = new MallardDuck();
        Quackable redheadDuck = new RedheadDuck();
        Quackable duckCall = new DuckCall();
        Quackable rubberDuck = new RubberDuck();

        System.out.println("\n오리 시뮬레이션 게임");

        simulate(mallardDuck);
        simulate(redheadDuck);
        simulate(duckCall);
        simulate(rubberDuck);
    }

    void simulate(Quackable duck) {
        duck.quack();
    }
}

DuckSimulator 클래스는 시뮬레이션을 실행하는 메인 클래스로, 다양한 오리 객체를 생성한 후 각 오리의 quack() 메서드를 호출하여 소리를 냅니다.
simulate() 메서드는 Quackable 객체를 받아서 quack() 메서드를 실행합니다. 이로 인해 다형성을 통해 각 오리의 소리를 동일한 방식으로 처리할 수 있습니다.

4. 거위 추가

public class Goose {
    public void honk() {
        System.out.println("끽끽");
    }
}

Goose 클래스는 honk() 메서드를 가지고 있으며, 거위가 소리를 낼 때 "끽끽" 소리를 냅니다. 그러나 Goose는 Quackable 인터페이스를 구현하지 않으므로 바로 시뮬레이션에 사용할 수 없습니다.

5. 어댑터 패턴 사용하기 (GooseAdapter)

public class GooseAdapter implements Quackable {
    Goose goose;

    public GooseAdapter(Goose goose) {
        this.goose = goose;
    }

    public void quack() {
        goose.honk();
    }
}

GooseAdapter는 어댑터 패턴을 사용하여 Goose 객체를 Quackable로 감싸줍니다.
quack() 메서드가 호출되면, 내부적으로 거위의 honk() 메서드가 호출되어 "끽끽" 소리가 나도록 합니다.

6. 시뮬레이터에 거위 추가

public class DuckSimulator {
    public static void main(String[] args) {
        DuckSimulator simulator = new DuckSimulator();
        simulator.simulate();
    }

    void simulate() {
        Quackable mallardDuck = new MallardDuck();
        Quackable redheadDuck = new RedheadDuck();
        Quackable duckCall = new DuckCall();
        Quackable rubberDuck = new RubberDuck();
        Quackable gooseDuck = new GooseAdapter(new Goose());

        System.out.println("\n오리 시뮬레이션 게임 (거위 어댑터)");

        simulate(mallardDuck);
        simulate(redheadDuck);
        simulate(duckCall);
        simulate(rubberDuck);
        simulate(gooseDuck);
    }

    void simulate(Quackable duck) {
        duck.quack();
    }
}

시뮬레이터에 거위를 추가할 때 GooseAdapter를 사용하여 Goose를 Quackable로 변환합니다.
이제 거위도 다른 오리들과 마찬가지로 simulate() 메서드에서 quack()을 호출할 수 있습니다. 이때 거위는 "끽끽" 소리를 냅니다.
Goose는 원래 Quackable을 구현하지 않지만, GooseAdapter를 통해 Quackable처럼 동작할 수 있도록 변환되었습니다.

7. Quack 소리 횟수 세기 (QuackCounter)

public class QuackCounter implements Quackable {
    Quackable duck;
    static int numberOfQuacks;

    public QuackCounter(Quackable duck) {
        this.duck = duck;
    }

    public void quack() {
        duck.quack();
        numberOfQuacks++;
    }

    public static int getQuacks() {
        return numberOfQuacks;
    }
}

QuackCounter(데코레이터) 클래스는 데코레이터 패턴을 사용하여 Quackable을 구현한 객체에 소리 횟수를 세는 기능을 추가합니다.
- 데코레이터 패턴은 객체에 새로운 기능을 동적으로 추가할 수 있도록 도와주는 디자인 패턴
- 기존의 Quackable 객체들에 직접 수정 없이 소리 횟수를 세는 기능 추가 가능
quack() 메서드가 호출될 때, 내부의 duck.quack()이 호출된 후, numberOfQuacks가 증가합니다.
getQuacks() 메서드는 지금까지 소리가 난 횟수를 반환합니다.

8. 시뮬레이터에서 모든 오리에 데코레이터 적용

public class DuckSimulator {
    public static void main(String[] args) {
        DuckSimulator simulator = new DuckSimulator();
        simulator.simulate();
    }

    void simulate() {
        Quackable mallardDuck = new QuackCounter(new MallardDuck());
        Quackable redheadDuck = new QuackCounter(new RedheadDuck());
        Quackable duckCall = new QuackCounter(new DuckCall());
        Quackable rubberDuck = new QuackCounter(new RubberDuck());
        Quackable gooseDuck = new GooseAdapter(new Goose());

        System.out.println("\n오리 시뮬레이션 게임 (데코레이터)");

        simulate(mallardDuck);
        simulate(redheadDuck);
        simulate(duckCall);
        simulate(rubberDuck);
        simulate(gooseDuck);

        System.out.println("오리가 소리 낸 횟수: " + QuackCounter.getQuacks() + " 번");
    }

    void simulate(Quackable duck) {
        duck.quack();
    }
}

QuackCounter 데코레이터는 모든 오리 객체에 적용되어 소리 낸 횟수를 기록합니다.
시뮬레이션이 끝난 후, QuackCounter.getQuacks()를 통해 총 몇 번 오리들이 소리를 냈는지 출력합니다.
이 코드에서는 GooseAdapter를 사용하여 거위도 포함되며, 각 오리가 소리를 낼 때마다 그 횟수가 기록됩니다.
"오리가 소리 낸 횟수: 4 번"

9. 팩토리 패턴을 통한 오리 생성

public abstract class AbstractDuckFactory {
    public abstract Quackable createMallardDuck();
    public abstract Quackable createRedheadDuck();
    public abstract Quackable createDuckCall();
    public abstract Quackable createRubberDuck();
}

팩토리 패턴은 여러 종류의 오리를 생성할 때 사용됩니다. (중앙화된 관리, 복잡한 로직 숨김)
AbstractDuckFactory는 각 오리 클래스를 생성하는 메서드를 선언하고, 이를 구체화한 팩토리 클래스에서 해당 메서드들을 구현하여 오리 객체를 생성할 수 있습니다.

public class CountingDuckFactory extends AbstractDuckFactory {
    public Quackable createMallardDuck() {
        return new QuackCounter(new MallardDuck());
    }
    public Quackable createRedheadDuck() {
        return new QuackCounter(new RedheadDuck());
    }
    public Quackable createDuckCall() {
        return new QuackCounter(new DuckCall());
    }
    public Quackable createRubberDuck() {
        return new QuackCounter(new RubberDuck());
    }
}

CountingDuckFactory는 QuackCounter 데코레이터를 사용해 각 오리의 quack() 메서드가 호출될 때마다 소리 횟수를 세도록 합니다.

public class DuckSimulator {
    public static void main(String[] args) {
        DuckSimulator simulator = new DuckSimulator();
        AbstractDuckFactory duckFactory = new CountingDuckFactory();
        simulator.simulate(duckFactory);
    }

    void simulate(AbstractDuckFactory duckFactory) {
        Quackable mallardDuck = duckFactory.createMallardDuck();
        Quackable redheadDuck = duckFactory.createRedheadDuck();
        Quackable duckCall = duckFactory.createDuckCall();
        Quackable rubberDuck = duckFactory.createRubberDuck();
        Quackable gooseDuck = new GooseAdapter(new Goose());

        System.out.println("\n오리 시뮬레이션 게임 (데코레이터)");

        simulate(mallardDuck);
        simulate(redheadDuck);
        simulate(duckCall);
        simulate(rubberDuck);
        simulate(gooseDuck);

        System.out.println("오리가 소리 낸 횟수: " + QuackCounter.getQuacks() + " 번");
    }

    void simulate(Quackable duck) {
        duck.quack();
    }
}

팩토리를 사용해 다양한 오리 객체들을 생성하고, 이들을 시뮬레이션에서 사용합니다.
QuackCounter를 사용한 오리들의 소리 횟수를 기록할 수 있습니다.

10. Flock 패턴 (무리 패턴)

public class Flock implements Quackable {
    List<Quackable> quackers = new ArrayList<>();

    public void add(Quackable quacker) {
        quackers.add(quacker);
    }

    public void quack() {
        Iterator<Quackable> iterator = quackers.iterator();
        while (iterator.hasNext()) {
            Quackable quacker = iterator.next();
            quacker.quack();
        }
    }
}

Flock 클래스는 Quackable 객체들의 리스트를 관리하고, 모든 객체의 quack() 메서드를 호출할 수 있습니다.
여러 오리 객체를 한 번에 관리할 수 있는 구조를 제공합니다.

11. Flock을 시뮬레이션에 적용

void simulate(AbstractDuckFactory duckFactory) {
    Flock flockOfDucks = new Flock();

    Quackable redheadDuck = duckFactory.createRedheadDuck();
    Quackable duckCall = duckFactory.createDuckCall();
    Quackable rubberDuck = duckFactory.createRubberDuck();
    Quackable gooseDuck = new GooseAdapter(new Goose());

    flockOfDucks.add(redheadDuck);
    flockOfDucks.add(duckCall);
    flockOfDucks.add(rubberDuck);
    flockOfDucks.add(gooseDuck);

    System.out.println("\n오리 시뮬레이션 게임: 무리");

    simulate(flockOfDucks);
}

Flock 패턴을 사용하여 오리의 무리를 만들고, 무리 내 모든 오리의 quack() 메서드를 호출합니다.
팩토리 패턴은 오리 객체 생성을 중앙화하고, 데코레이터 패턴을 사용하여 추가 기능(예: 소리 횟수 세기)을 쉽게 추가할 수 있습니다.
Flock 패턴은 오리 무리를 관리하고, 모든 오리가 동일한 행동을 하도록 쉽게 설정할 수 있습니다.

12. 옵저버 패턴 도입

옵저버 패턴은 객체의 행동을 관찰하고 추적하려는 시나리오에 적합한 패턴입니다. 여기서는 오리들이 소리를 낼 때 이를 추적하고자 옵저버 패턴을 적용합니다.

public interface QuackObservable {
    public void registerObserver(Observer observer);
    public void notifyObservers();
}

QuackObservable은 옵저버를 등록하고, 소리가 날 때 이를 옵저버에게 알리는 역할을 합니다.

Quackable 인터페이스

// Quackable은 QuackObservable을 확장하며, 오리가 소리를 낼 때 이를 옵저버에게 알릴 수 있도록 합니다.
public interface Quackable extends QuackObservable {
    public void quack();
}

// Observable 클래스는 옵저버를 등록하고, 오리가 소리를 낼 때마다 등록된 옵저버들에게 알립니다.
public class Observable implements QuackObservable {
    List<Observer> observers = new ArrayList<>();
    QuackObservable duck;

    public Observable(QuackObservable duck) {
        this.duck = duck;
    }

    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(duck);
        }
    }
}

// MallardDuck 클래스는 Observable 객체를 가지고 있으며, 소리가 날 때 옵저버들에게 알립니다.
public class MallardDuck implements Quackable {
    Observable observable;

    public MallardDuck() {
        observable = new Observable(this);
    }

    public void quack() {
        System.out.println("꽥꽥");
        notifyObservers();
    }

    public void registerObserver(Observer observer) {
        observable.registerObserver(observer);
    }

    public void notifyObservers() {
        observable.notifyObservers();
    }
}

// Observer 인터페이스는 옵저버가 업데이트될 때 호출되는 메서드를 정의합니다.
public interface Observer {
    public void update(QuackObservable duck);
}

// Quackologist는 Observer를 구현하여 오리가 소리를 낼 때 이를 출력합니다.
public class Quackologist implements Observer {
    public void update(QuackObservable duck) {
        System.out.println("꽥꽥학자: " + duck + "가 방금 소리냈다.");
    }
}

public class DuckSimulator {
    public static void main(String[] args) {
        DuckSimulator simulator = new DuckSimulator();
        AbstractDuckFactory duckFactory = new CountingDuckFactory();
        simulator.simulate(duckFactory);
    }

    void simulate(AbstractDuckFactory duckFactory) {
        Flock flockOfDucks = new Flock();
        Quackologist quackologist = new Quackologist();
        flockOfDucks.registerObserver(quackologist);

        simulate(flockOfDucks);
        System.out.println("오리가 소리 낸 횟수: " + QuackCounter.getQuacks() + " 번");
    }

    void simulate(Quackable duck) {
        duck.quack();
    }
}

옵저버인 Quackologist를 무리에 등록하고, 오리들이 소리를 낼 때마다 옵저버가 그 행동을 추적하도록 설정합니다.
옵저버 패턴을 통해 오리들이 소리를 낼 때 이를 추적할 수 있습니다.
옵저버는 여러 객체의 상태 변화를 실시간으로 반영하며, 이 패턴을 통해 객체 간의 의존성을 줄일 수 있습니다.

2. 정리

이미지에 있는 내용은 옵저버 패턴, 데코레이터 패턴, 반복자 패턴을 활용해 변경된 설계에 대한 설명입니다. 주요 내용을 요약하면 다음과 같습니다.

1. Quackable의 확장

처음에 Quackable 객체들은 기본적인 quack() 메서드를 구현했습니다. 하지만 거위가 등장하면서 거위도 Quackable이 되고 싶어 했고, 어댑터 패턴을 사용하여 거위를 Quackable로 만들었습니다. 이제 거위는 quack()을 호출하면 자동으로 honk()를 실행하게 되었습니다.

2. 데코레이터 패턴으로 소리 횟수 측정

팩퀵학자들이 오리의 소리 횟수를 측정하고 싶어했습니다. 이를 위해 데코레이터 패턴을 적용해 QuackCounter 데코레이터를 추가했고, 이로 인해 각 quack() 호출 시 소리 횟수를 셀 수 있게 되었습니다.

3. 팩토리 패턴을 이용한 객체 생성

데코레이터가 적용되지 않은 Quackable 객체들이 생길까 걱정한 팩퀵학자들은 팩토리 패턴을 사용해 항상 데코레이터가 적용된 Quackable 객체가 생성되도록 했습니다. 이를 통해 오리 객체의 생성이 중앙에서 관리되었습니다.

4. Flock 패턴(무리 패턴)과 반복자 패턴

모든 오리와 거위를 관리하는 것이 어려워졌습니다. 이를 해결하기 위해 Flock 패턴을 도입해 오리들을 무리 단위로 관리하게 되었습니다. 이 과정에서 반복자 패턴을 사용해 각 오리들의 quack()을 순차적으로 호출할 수 있게 했습니다.

5. 옵저버 패턴 도입

팩퀵학자들은 오리의 행동을 관찰하고 싶어했습니다. 옵저버 패턴을 적용해 Quackologist가 Quackable 객체의 옵저버로 등록되었고, 오리가 소리를 낼 때마다 옵저버에게 알릴 수 있었습니다.

결론

이러한 패턴들을 적용한 덕분에 복잡한 객체들 간의 관계를 효율적으로 관리하고, 소리 횟수 측정과 같은 추가적인 기능을 손쉽게 구현할 수 있었습니다. 옵저버 패턴, 데코레이터 패턴, 반복자 패턴 등 다양한 패턴이 잘 결합되어 문제를 해결했습니다.

3. MVC 패턴

1. 사용자와 뷰(View)의 상호작용

사용자는 뷰를 통해 모델의 상태를 볼 수 있습니다.
사용자가 뷰에서 특정 버튼을 누르면 그 정보가 컨트롤러에게 전달됩니다. 컨트롤러는 상황에 맞게 모델과 뷰에 적절한 작업을 요청합니다.

2. 컨트롤러가 모델에게 상태 변경 요청

컨트롤러는 사용자의 입력을 받아 그 의미를 해석한 후 모델에 상태 변경을 요청합니다.
예를 들어, 사용자가 버튼을 클릭하면 컨트롤러가 그 입력을 받아 모델에 처리 방법을 지시합니다.

3. 컨트롤러가 뷰(View)에게 요청

컨트롤러는 때로는 뷰에게도 변경을 요청할 수 있습니다.
예를 들어, 컨트롤러는 뷰의 특정 버튼이나 메뉴의 활성화/비활성화를 요청할 수 있습니다.

4. 모델이 뷰에게 상태 변경 알림

모델이 상태를 변경하면 뷰에게 그 사실을 알려줍니다.
예를 들어, 재생 목록에서 다음 곡으로 넘어가는 등의 상태 변화가 발생하면 모델은 뷰에 그 변화를 전달합니다.

5. 뷰가 모델에게 상태 요청

뷰는 모델의 상태를 직접 가져와 화면에 표시합니다.
예를 들어, 모델이 곡 목록을 업데이트하면 뷰는 그 정보를 모델에서 받아와 사용자에게 보여줍니다.

[개발서적] 헤드퍼스트 디자인 패턴 Ch11. 프록시 패턴

SWKo — Wed, 9 Oct 2024 23:50:40 +0900

1. 모니터링 코드 만들기

CEO는 원격에 있는 모든 뽑기 기계를 모니터링 하기를 원합니다.

뽑기 기계 코드의 알맹이의 개수를 알려주는 메소드와 기계의 현재 상태를 알려주는 메소드는 현재 존재합니다.

여기서, 모든 뽑기 기계의 재고와 현재 상태를 알려 주는 기능을 추가하려고 합니다.

우선 GumballMachine 클래스에 뽑기 기계의 현재 위치를 알려 주는 기능을 추가해봅니다.

public class GumballMachine {
    String location;  // 기계의 위치
    int count;        // 알맹이의 개수
    String state;     // 기계의 현재 상태
    
    // 생성자: 기계의 위치와 재고를 초기화
    public GumballMachine(String location, int count) {
        this.location = location;
        this.count = count;
        this.state = "대기 중"; // 초기 상태 설정
    }
    
    // 기계의 위치를 반환하는 메소드
    public String getLocation() {
        return location;
    }

    // 재고 수를 반환하는 메소드 (이미 구현된 것)
    public int getCount() {
        return count;
    }

    // 상태를 반환하는 메소드 (이미 구현된 것)
    public String getState() {
        return state;
    }
}

뽑기 기계의 위치, 재고, 현재 상태를 가져와서 보고서를 출력해주는 GumballMonitor 클래스를 만들어봅니다.

public class GumballMonitor {
    GumballMachine machine;  // 모니터링할 GumballMachine 객체

    // 생성자: GumballMachine 객체를 전달받아 초기화
    public GumballMonitor(GumballMachine machine) {
        this.machine = machine;
    }

    // 보고서 출력 메소드
    public void report() {
        System.out.println("뽑기 기계 위치: " + machine.getLocation());
        System.out.println("현재 재고: " + machine.getCount() + " 개");
        System.out.println("현재 상태: " + machine.getState());
    }
}

모니터링 테스트를 해봅니다.

public class GumballMachineTestDrive {
    public static void main(String[] args) {
        int count = 0;

        // 입력 값 유효성 확인
        if (args.length < 2) {
            System.out.println("GumballMachine <location> <inventory>");
            System.exit(1);  // 인수가 부족할 경우 프로그램 종료
        }

        // 명령줄 인수에서 위치와 초기 재고 개수 가져오기
        String location = args[0];  // 기계 위치
        count = Integer.parseInt(args[1]);  // 초기 재고 수

        // GumballMachine 객체 생성
        GumballMachine gumballMachine = new GumballMachine(location, count);

        // GumballMonitor 객체 생성
        GumballMonitor monitor = new GumballMonitor(gumballMachine);

        // 보고서 출력
        monitor.report();
    }
}

하지만, 요구사항은 원격 모니터링입니다.

현재 GumballMonitor는 로컬에서만 Gumball Machine을 모니터링할 수 있습니다.

원격 프록시를 통해 해결이 가능합니다.

프록시 개념: 프록시는 진짜 객체처럼 동작하지만, 실제 객체에 접근하기 전 이를 제어하거나 간접적으로 접근하게 만드는 디자인 패턴입니다.
원격 프록시(Remote Proxy): 원격 서버에 있는 객체에 접근하기 위해, 원격 통신을 관리하고 제어할 수 있는 대리 객체입니다.
- 역할: 로컬 객체처럼 보이지만 실제로는 원격 서버에 있는 진짜 객체와 통신하여 데이터를 주고받습니다.
- 동작: GumballMonitor는 진짜 Gumball Machine 대신 원격 프록시 객체에 접근합니다. 프록시는 원격으로 실제 기계의 상태와 재고를 조회하고, 이를 모니터에 전달합니다.

2. 원격 프록시의 역할

원격 프록시는 원격 객체의 로컬 대변자 역할을 합니다.

원격 객체 = 자바 가상 머신의 힙에 살고 있는 객체(다른 주소 공간에서 돌아가고 있는 객체)

로컬 대변자 = 어떤 메소드를 호출하면, 다른 원격 객체에게 그 메소드 호출을 전달해 주는 객체

클라이언트 객체(GumballMonitor)는 원격 객체의 메소드 호출을 하는 것처럼 행동합니다.

하지만 실제로는 로컬 힙에 들어있는 'Proxy' 객체의 메소드를 호출하고 있죠.

네트워크 통신과 관련된 저수준 작업은 이 'Proxy' 객체에서 처리해줍니다.

3. 모니터링 코드에 원격 프록시 추가하기

다른 JVM에 들어있는 객체의 메소드를 호출하는 프록시를 만들어봅시다.

아래와 같은 방법으로는 다른 힙에 들어있는 객체 레퍼런스를 가져올 수는 없습니다.

Duck d = <다른 힙에 있는 객체>

변수 d가 어떤 객체를 참조하든, 그 객체는 선언문이 있는 코드와 같은 힙 공간에 있어야 합니다.

여기서 이제 Java의 원격 메소드 호출(RMI, Remote Method Invocation)이 쓰입니다.

RMI를 사용하면 원격 JVM에 있는 객체를 찾아서 그 메소드를 호출할 수 있습니다.

4. 원격 메소드의 기초

클라이언트 객체: 메소드를 호출하는 원본 객체.
클라이언트 보조 객체(Proxy): 원격 메소드 호출을 포장하고 전달하는 프록시 객체.
서비스 보조 객체(Remote Skeleton): 클라이언트의 호출 정보를 해석하고, 서비스 객체의 메소드를 호출하는 역할.
서비스 객체: 실제 비즈니스 로직을 수행하고, 작업을 처리하는 원본 객체.

1. Client → [Client Proxy] : doBigThing()
2. [Client Proxy] → (네트워크) → [Remote Skeleton] : doBigThing() 호출 정보 전달
3. [Remote Skeleton] → [Service Object] : 메소드 해석 후, 서비스 객체 메소드 호출
4. [Service Object] : 비즈니스 로직 처리 후, 결과 반환
5. [Remote Skeleton] → (네트워크) → [Client Proxy] : 메소드 호출 결과 전달
6. [Client Proxy] → Client : 메소드 결과 리턴

5. 자바 RMI(Remote Method Invocation)로 원격 서비스 만들기

RMI는 클라이언트와 서비스 보조 객체를 만들어 줍니다. 보조 객체에는 원격 서비스와 똑같은 메소드가 들어있습니다.

클라이언트는 로컬 JVM에 있는 메소드를 호출하듯 원격 메소드(진짜 서비스 객체에 있는 메소드)를 호출할 수 있습니다.

또한 클라이언트가 원격 객체를 찾아서 접근할 때 쓸 수 있는 룩업(lookup) 서비스도 RMI에서 제공합니다.

RMI와 로컬 메소드의 차이점 : RMI는 클라이언트 보조 객체가 네트워크로 호출을 전송해야 하므로 네트워킹 및 입출력 기능이 반드시 필요합니다.

RMI(Remote Method Invocation)를 사용한 원격 서비스 구현 4단계

1. 원격 인터페이스 만들기 (Remote Interface)

목표: 클라이언트가 원격 객체에서 호출할 메소드를 정의하는 인터페이스를 생성합니다.
이 인터페이스는 java.rmi.Remote 인터페이스를 상속하고, 예외 처리용으로 RemoteException을 선언해야 합니다.
클라이언트와 서버 모두 이 인터페이스를 사용하여 통신하게 됩니다.
이 인터페이스는 원격 객체의 메소드 호출 방식을 클라이언트와 서버 간에 표준화해 줍니다.

import java.rmi.Remote;
import java.rmi.RemoteException;

public interface MyService extends Remote {
    // 클라이언트가 원격으로 호출할 메소드 정의
    public String getServiceMessage() throws RemoteException;
}

2. 서비스 구현 클래스 만들기 (Service Implementation)

목표: 원격 인터페이스(MyService)를 구현한 서비스 클래스를 작성하여, 원격 메소드의 실제 동작을 정의합니다.
이 클래스는 UnicastRemoteObject를 상속받고, 원격 메소드를 구현해야 합니다.
실제 작업을 수행하는 메소드의 구체적인 로직을 이 클래스에 작성합니다.
예를 들어, Gumball Machine의 getState(), getCount() 같은 메소드를 정의할 수 있습니다.

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

// MyService 인터페이스 구현 클래스
public class MyServiceImpl extends UnicastRemoteObject implements MyService {

    // 생성자: RemoteException을 던져야 함. 어떤 클래스가 생성될 때 그 슈퍼클래스의 생성자도 반드시
    // 호출되므로 슈퍼클래스 생성자가 어떤 예외를 던진다면 서브 클래스의 생성자도 그 예외를 선언해야 함.
    public MyServiceImpl() throws RemoteException {
        super();
    }

    // 원격으로 호출할 메소드 구현
    @Override
    public String getServiceMessage() throws RemoteException {
        return "원격 서비스에 접근 성공!";
    }
}

3. RMI 레지스트리 실행하기 (rmiregistry)

목표: RMI 레지스트리는 원격 객체를 클라이언트가 찾을 수 있도록 "전화번호부" 역할을 합니다.
레지스트리에는 각 원격 객체의 레퍼런스가 등록되어 있으며, 클라이언트는 이 레지스트리를 통해 객체를 찾고 접근할 수 있습니다.
레지스트리를 실행하면, RMI 시스템이 원격 객체의 프록시(Stub)를 생성하고 이를 레지스트리에 등록합니다.
RMI 레지스트리는 별도의 터미널 창에서 다음 명령어를 사용해 실행합니다.

# RMI 레지스트리 실행 명령어
rmiregistry

4. 원격 서비스 실행 및 등록하기

목표: 원격 객체의 인스턴스를 생성하고, 이를 RMI 레지스트리에 등록합니다.
이 과정에서 서비스 객체의 이름을 RMI 레지스트리에 바인딩하여, 클라이언트가 원격 객체에 접근할 수 있게 합니다.
스텁(Stub)과 스켈레톤(Skeleton)은 RMI 시스템이 자동으로 생성하므로, 개발자가 직접 작성할 필요가 없습니다.
클라이언트는 레지스트리에서 이 이름을 사용하여 원격 객체의 레퍼런스를 가져와 메소드를 호출하게 됩니다.

import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;

public class MyServiceServer {
    public static void main(String[] args) {
        try {
            // RMI 레지스트리 시작
            LocateRegistry.createRegistry(1099);
            
            // 원격 서비스 객체 생성
            MyService service = new MyServiceImpl();

            // RMI 레지스트리에 원격 객체를 바인딩
            Naming.rebind("rmi://localhost/MyService", service);
            
            System.out.println("원격 서비스가 시작되었습니다.");
        } catch (RemoteException | java.net.MalformedURLException e) {
            e.printStackTrace();
        }
    }
}

클라이언트가 RMI 레지스트리를 사용하여 원격 객체의 스텁(Stub) 객체를 가져와 메소드를 호출하는 과정

import java.rmi.Naming;

public class MyServiceClient {
    public static void main(String[] args) {
        new MyServiceClient().go();
    }

    // 원격 객체 호출을 수행하는 메소드
    public void go() {
        try {
            // 1. RMI 레지스트리에서 원격 객체 조회 (Object 타입이므로 명시적 캐스팅 필요)
            MyService service = (MyService) Naming.lookup("rmi://localhost/MyService");

            // 2. 스텁 객체의 메소드 호출 (원격 메소드 실행)
            String response = service.getServiceMessage();

            // 3. 결과 출력
            System.out.println("원격 서비스의 응답: " + response);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

6. 뽑기 기계용 원격 프록시

이제 뽑기 기계용 원격 프록시를 만들어보겠습니다.

원격 프록시를 쓸 수 있도록 가장 먼저 GumballMachine 클래스를 클라이언트로부터 전달된 원격 요청을 처리하도록 바꿉니다.

즉, 서비스를 구현한 클래스를 만들어야 합니다.

1. 원격 인터페이스 정의 (GumballMachineRemote)

GumballMachine의 원격 메소드를 정의하는 인터페이스를 생성합니다. 이 인터페이스는 Remote 인터페이스를 상속받고, 원격 호출할 수 있는 메소드들을 포함합니다. 각 메소드는 RemoteException을 던져야 하며, 리턴 타입은 직렬화 가능해야 합니다.

import java.rmi.Remote;
import java.rmi.RemoteException;

// GumballMachine의 원격 인터페이스
public interface GumballMachineRemote extends Remote {
    public int getCount() throws RemoteException;  // 알맹이의 개수를 반환
    public String getLocation() throws RemoteException;  // 기계의 위치 반환
    public State getState() throws RemoteException;  // 기계의 현재 상태 반환
}

2. 직렬화 가능한 State 인터페이스

GumballMachine의 메소드 중 getState()는 State 객체를 반환합니다. State 클래스가 원격 호출에서 사용되려면 Serializable 인터페이스를 구현해야 합니다. 따라서 State 인터페이스를 다음과 같이 변경합니다.

import java.io.Serializable;

// State 인터페이스에 Serializable 추가
public interface State extends Serializable {
    public void insertQuarter();
    public void ejectQuarter();
    public void turnCrank();
    public void dispense();
}

이렇게 State가 직렬화 가능해지면, RMI 시스템이 State 객체를 네트워크를 통해 안전하게 전송할 수 있습니다.

3. GumballMachine 클래스에서 원격 인터페이스 구현

이제 기존 GumballMachine 클래스를 원격 서비스 객체로 변경하여 GumballMachineRemote 인터페이스를 구현합니다. 또한, UnicastRemoteObject를 상속받아 RMI 시스템에서 사용할 수 있는 원격 객체로 설정합니다.

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

// GumballMachine 클래스가 GumballMachineRemote를 구현하도록 변경
public class GumballMachine extends UnicastRemoteObject implements GumballMachineRemote {
    String location;
    int count;
    State state;

    // 생성자: RemoteException을 던져야 함
    public GumballMachine(String location, int count) throws RemoteException {
        this.location = location;
        this.count = count;
        // 초기 상태 설정 (State 객체는 직렬화 가능해야 함)
        this.state = new NoQuarterState(this);  // 예: NoQuarterState는 State의 직렬화 가능 클래스
    }

    // 원격 메소드 구현
    @Override
    public int getCount() throws RemoteException {
        return count;
    }

    @Override
    public String getLocation() throws RemoteException {
        return location;
    }

    @Override
    public State getState() throws RemoteException {
        return state;
    }

    // 기타 GumballMachine 클래스의 메소드들...
}

이렇게 변경하면, GumballMachine 클래스가 원격 서비스로 동작하며, RMI 시스템에서 클라이언트가 호출할 수 있는 원격 메소드를 제공합니다.

4. GumballMachine 객체를 RMI 레지스트리에 등록

GumballMachine을 RMI 레지스트리에 등록하고, 클라이언트가 접근할 수 있도록 설정합니다. 기존 MyServiceServer 코드와 유사한 방식으로 RMI 레지스트리를 초기화하고, GumballMachine 객체를 등록할 수 있습니다.

import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;

public class GumballMachineServer {
    public static void main(String[] args) {
        try {
            // 1. RMI 레지스트리 시작
            LocateRegistry.createRegistry(1099);

            // 2. 원격 GumballMachine 객체 생성
            GumballMachine gumballMachine = new GumballMachine("Seattle", 100);

            // 3. RMI 레지스트리에 원격 GumballMachine 객체 바인딩
            Naming.rebind("rmi://localhost/GumballMachine", gumballMachine);

            System.out.println("Gumball Machine 원격 서비스가 시작되었습니다.");
        } catch (RemoteException | java.net.MalformedURLException e) {
            e.printStackTrace();
        }
    }
}

5. 클라이언트 코드 (GumballMonitor)

이제 클라이언트가 RMI 레지스트리에서 GumballMachineRemote 객체를 가져와서 원격 메소드를 호출할 수 있도록 클라이언트 코드를 작성합니다.

import java.rmi.Naming;

public class GumballMonitorTest {
    public static void main(String[] args) {
        try {
            // RMI 레지스트리에서 GumballMachine 원격 객체 가져오기
            GumballMachineRemote machine = (GumballMachineRemote) Naming.lookup("rmi://localhost/GumballMachine");

            // 원격 메소드 호출
            System.out.println("Gumball Machine 위치: " + machine.getLocation());
            System.out.println("현재 재고: " + machine.getCount());
            System.out.println("현재 상태: " + machine.getState());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

요약

GumballMachineRemote 원격 인터페이스 생성.
State 클래스 직렬화 가능하도록 수정.
GumballMachine 클래스를 원격 서비스로 변환.
RMI 레지스트리에 등록하여 원격 서비스 설정.
클라이언트 코드(GumballMonitorTest)를 통해 원격 메소드 호출.

이렇게 GumballMachine을 원격 서비스로 변환하여 클라이언트가 네트워크를 통해 접근할 수 있게 만들 수 있습니다.

7. 새로운 모니터링 기능 테스트

처음에 CEO가 만들고 싶어했던, 수많은 뽑기 기계를 모니터링 할 수 있는 코드를 작성해봅니다.

import java.rmi.Naming;

public class GumballMonitorTestDrive {
    public static void main(String[] args) {
        // 1. 여러 대의 Gumball Machine이 위치한 RMI URL 배열
        String[] location = {
            "rmi://santafe.mightygumball.com/gumballmachine",
            "rmi://boulder.mightygumball.com/gumballmachine",
            "rmi://austin.mightygumball.com/gumballmachine"
        };

        // 2. GumballMonitor 배열 생성 (각 Gumball Machine을 모니터링할 객체)
        GumballMonitor[] monitor = new GumballMonitor[location.length];

        // 3. RMI 레지스트리에서 각 원격 GumballMachine 객체를 가져와 모니터링 객체 생성
        for (int i = 0; i < location.length; i++) {
            try {
                // 3-1. RMI 레지스트리에서 GumballMachine 원격 객체 가져오기
                GumballMachineRemote machine = (GumballMachineRemote) Naming.lookup(location[i]);

                // 3-2. 각 GumballMachineRemote 객체에 대한 GumballMonitor 생성
                monitor[i] = new GumballMonitor(machine);
                System.out.println("모니터링할 Gumball Machine: " + location[i]);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        // 4. 각 Gumball Machine의 보고서 출력
        for (int i = 0; i < monitor.length; i++) {
            monitor[i].report();
        }
    }
}

8. 프록시 패턴의 정의

정의: 프록시 패턴은 특정 객체에 대한 접근을 제어하는 대리 객체를 제공하는 패턴입니다. 프록시는 실제 객체에 대한 대리인 역할을 하며, 클라이언트가 이 대리자를 통해 원래 객체에 접근할 수 있게 합니다.
목적: 실제 객체의 직접 접근을 제한하거나, 특정 상황에서 추가적인 기능을 제공하기 위해 사용됩니다. 클라이언트가 직접 접근하지 않고, 프록시를 통해 간접적으로 접근함으로써 접근 권한을 제어하고, 부가적인 로직을 추가하거나, 네트워크 호출 등을 투명하게 처리할 수 있습니다. => 다양한 목적으로 쓰인다.

프록시 패턴의 주요 변형

프록시 패턴에는 여러 변형이 있으며, 각 변형은 특정한 접근 제어 방법을 사용하여 프록시 객체의 역할을 다르게 정의합니다. 다음은 대표적인 프록시 패턴의 변형입니다:

원격 프록시(Remote Proxy):
- 정의: 원격 객체에 대한 접근을 제어하는 프록시입니다. 원격 프록시는 네트워크 통신을 통해 원격 서버에 있는 객체와 클라이언트 사이의 프록시 역할을 합니다.
- 예: GumballMachineRemote를 사용하여 원격 Gumball Machine 객체와 클라이언트 간의 통신을 관리.
가상 프록시(Virtual Proxy):
- 정의: 가상 프록시는 생성 비용이 높은 객체를 필요할 때만 생성하도록 제어합니다. 객체의 지연 초기화(Lazy Initialization)를 수행하며, 클라이언트가 요청할 때 실제 객체를 생성하여 접근을 제어합니다.
- 예: 이미지 로딩이 오래 걸리는 상황에서, 이미지를 보여줘야 할 때만 실제 이미지 객체를 생성하도록 가상 프록시를 사용.
보호 프록시(Protection Proxy):
- 정의: 보호 프록시는 접근 권한을 제어하여 특정 클라이언트만 실제 객체에 접근할 수 있도록 합니다. 보안 검사나 권한 관리가 필요할 때 사용됩니다.
- 예: 사용자 권한에 따라 읽기/쓰기 권한을 다르게 설정하여, 권한이 없는 사용자가 데이터에 접근할 수 없도록 보호.

Subject: 공통 인터페이스로, 실제 객체와 프록시가 같은 메소드를 가지고 있어야 합니다.
RealSubject: 실제 동작을 수행하는 진짜 객체로, 프록시를 통해 접근하는 대상 객체입니다.
Proxy: Subject 인터페이스를 구현한 대리자 객체로, RealSubject와 동일한 메소드를 제공합니다. 프록시는 클라이언트의 요청을 받아 이를 실제 객체에게 전달하고, 결과를 다시 클라이언트에게 반환합니다.

9. 원격 프록시와 가상 프록시 비교하기

원격 프록시

원격 프록시는 다른 JVM에 들어있는 객체의 대리인에 해당하는 로컬 객체입니다.

가상 프록시

가상 프록시는 생성하는 데 많은 비용이 드는 객체를 대신합니다.

진짜 객체가 필요한 상황이 오기 전까지 객체의 생성을 미루는 기능을 제공합니다.

객체 생성 전이나 객체 생성 도중에 객체를 대신하기도 합니다. 객체 생성이 끝나면 그냥 RealSubject에 직접 요청을 전달합니다.

가상 프록시를 사용하는 프레임워크 예

React와 Vue의 Lazy Loading:
- 동적 import를 통해 필요한 컴포넌트만 로드하여, 초기 렌더링을 최적화합니다.
IntersectionObserver API:
- 이미지나 비디오의 지연 로딩을 통해 사용자가 볼 때만 로드하여, 네트워크 트래픽을 최적화합니다.

10. 가상 프록시로 앨범 커버 뷰어 만들기

가상 프록시(Virtual Proxy)를 사용하여 앨범 커버 뷰어를 만드는 방식은, 네트워크로부터 이미지를 로드하는 동안 사용자에게 로딩 상태를 표시하고, 실제 이미지가 로드될 때 이를 화면에 보여줌으로써 사용자 경험을 개선하는 디자인 패턴입니다.

Icon (인터페이스):
- paintIcon(), getIconWidth(), getIconHeight() 등의 메소드를 정의하여 이미지를 화면에 그리는 표준 인터페이스 역할을 합니다.

import java.awt.Component;
import java.awt.Graphics;

// 공통 인터페이스: 아이콘을 그리기 위한 표준 메소드 정의
public interface Icon {
    void paintIcon(Component c, Graphics g, int x, int y);
    int getIconWidth();
    int getIconHeight();
}

RealImageIcon (구현 클래스):
- 실제로 이미지를 로드하고, 화면에 이미지를 표시하는 객체입니다.
- Icon 인터페이스를 구현하여 실제 이미지 데이터를 화면에 렌더링합니다.

import java.awt.*;
import javax.swing.*;
import java.net.*;

public class RealImageIcon implements Icon {
    private ImageIcon imageIcon;  // 실제 이미지 아이콘
    private URL imageUrl;

    // 생성자: 네트워크 URL에서 이미지를 가져옴
    public RealImageIcon(URL url) {
        this.imageUrl = url;
        try {
            this.imageIcon = new ImageIcon(imageUrl);  // 실제 이미지 로딩
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 이미지를 그리는 메소드
    @Override
    public void paintIcon(Component c, Graphics g, int x, int y) {
        if (imageIcon != null) {
            imageIcon.paintIcon(c, g, x, y);
        }
    }

    @Override
    public int getIconWidth() {
        return (imageIcon != null) ? imageIcon.getIconWidth() : 0;
    }

    @Override
    public int getIconHeight() {
        return (imageIcon != null) ? imageIcon.getIconHeight() : 0;
    }
}

ImageProxy (가상 프록시):
- Icon 인터페이스를 구현하지만, 실제 이미지가 로드되기 전까지 대체 메시지를 표시합니다.
- 이미지가 로드되면 RealImageIcon 객체로 모든 작업을 위임하여 실제 이미지를 화면에 표시합니다.

import java.awt.*;
import javax.swing.*;
import java.net.*;

public class ImageProxy implements Icon {
    private RealImageIcon realImageIcon;  // 실제 이미지 객체
    private URL imageUrl;
    private boolean retrieving = false;  // 이미지 로드 상태

    public ImageProxy(URL url) {
        this.imageUrl = url;
    }

    @Override
    public void paintIcon(Component c, Graphics g, int x, int y) {
        if (realImageIcon != null) {
            realImageIcon.paintIcon(c, g, x, y);  // 실제 이미지가 있으면 그리기
        } else {
            g.drawString("앨범 커버를 불러오는 중입니다... 잠시만 기다려 주세요.", x + 50, y + 50);
            if (!retrieving) {
                retrieving = true;
                new Thread(() -> {  // 비동기 로딩
                    realImageIcon = new RealImageIcon(imageUrl);
                    c.repaint();  // 이미지 로딩 후 화면 갱신
                }).start();
            }
        }
    }

    @Override
    public int getIconWidth() {
        return (realImageIcon != null) ? realImageIcon.getIconWidth() : 800;  // 기본 너비 설정
    }

    @Override
    public int getIconHeight() {
        return (realImageIcon != null) ? realImageIcon.getIconHeight() : 600;  // 기본 높이 설정
    }
}

11. 보호 프록시 만들기

동적 프록시(Dynamic Proxy)는 자바의 java.lang.reflect 패키지를 사용하여 런타임에 생성되는 프록시 객체입니다. 자바의 동적 프록시를 사용하면 인터페이스 기반으로 프록시를 생성하고, 메소드 호출을 제어하거나 특정 로직을 동적으로 추가할 수 있습니다. 이번에는 동적 프록시를 사용하여 보호 프록시(Protection Proxy)를 만들어 보겠습니다.

보호 프록시는 주로 권한 제어를 통해 클라이언트가 특정 메소드에 접근하지 못하게 막는 역할을 수행합니다. 예를 들어, 사용자가 자신의 정보를 수정할 수는 있지만, 다른 사용자의 정보를 수정할 수는 없도록 제한하는 로직을 포함할 수 있습니다.

인터페이스(Subject):
- 프록시와 실제 객체가 공통적으로 구현하는 인터페이스입니다.
- java.lang.reflect.Proxy는 반드시 인터페이스를 기반으로 프록시를 생성하기 때문에, 프록시로 사용할 객체는 인터페이스가 필요합니다.
실제 객체(Real Subject):
- 보호 프록시를 통해 접근을 제어할 실제 비즈니스 로직을 구현한 클래스입니다.
프록시 객체(Proxy):
- java.lang.reflect.Proxy와 InvocationHandler를 사용하여 동적으로 생성됩니다.
- InvocationHandler를 구현하여, 모든 메소드 호출을 가로채고 권한을 확인한 후 실제 객체로 메소드를 전달하거나, 접근이 허용되지 않은 경우 예외를 발생시킵니다.
InvocationHandler:
- 모든 메소드 호출을 가로채는 역할을 하며, 메소드 호출 시 접근 제어 로직을 추가하여 권한이 있는지 확인합니다.
- invoke() 메소드를 통해 모든 메소드 호출을 처리합니다.

12. 객체마을 데이팅 서비스

객체마을의 데이팅 서비스에서는 Person 인터페이스를 사용하여 사용자의 이름, 성별, 관심사 및 괴짜 지수(Geek Rating)를 설정하고 조회할 수 있습니다. 이 인터페이스를 구현한 PersonImpl 클래스를 통해 사용자의 데이터를 저장하고, get 및 set 메소드로 데이터를 조작할 수 있습니다.

그러나 여기서 보호 프록시(Protection Proxy)를 사용하여 권한에 따라 접근을 제어하고, 사용자가 자신의 프로필을 수정할 때와 다른 사용자의 프로필을 평가할 때 동작을 다르게 설정할 수 있습니다. 예를 들어, 사용자가 자신의 프로필을 수정할 수는 있지만, 다른 사용자의 프로필을 수정할 수는 없도록 제한할 수 있습니다.

이제 객체마을 데이팅 서비스의 보호 프록시를 사용하여 사용자의 접근 권한을 제어하는 방법을 구현해 보겠습니다.

서비스 시나리오

데이팅 서비스에는 두 가지 유형의 사용자가 있습니다:
1. 소유자(Owner): 자신의 정보를 수정하고, 이름, 성별, 관심사, 괴짜 지수를 설정할 수 있습니다.
2. 게스트(Guest): 다른 사람의 프로필을 볼 수 있지만, 평가(괴짜 지수 설정)만 가능합니다. 이름, 성별, 관심사는 변경할 수 없습니다.

1. 인터페이스 설계

Person 인터페이스

Person 인터페이스는 사용자의 정보를 설정하고 가져오는 메소드를 정의합니다.

public interface Person {
    String getName();
    void setName(String name);

    String getGender();
    void setGender(String gender);

    String getInterests();
    void setInterests(String interests);

    int getGeekRating();
    void setGeekRating(int rating);
}

PersonImpl 클래스

Person 인터페이스를 구현한 구체 클래스입니다. 사용자 정보를 저장하고 관리하는 역할을 수행합니다.

public class PersonImpl implements Person {
    private String name;
    private String gender;
    private String interests;
    private int rating;
    private int ratingCount = 0;

    @Override
    public String getName() {
        return name;
    }

    @Override
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String getGender() {
        return gender;
    }

    @Override
    public void setGender(String gender) {
        this.gender = gender;
    }

    @Override
    public String getInterests() {
        return interests;
    }

    @Override
    public void setInterests(String interests) {
        this.interests = interests;
    }

    @Override
    public int getGeekRating() {
        if (ratingCount == 0) return 0;
        return (rating / ratingCount);
    }

    @Override
    public void setGeekRating(int rating) {
        this.rating += rating;
        ratingCount++;
    }
}

2. 보호 프록시 설계

InvocationHandler 구현

두 가지 접근 제어 방식이 필요합니다:

OwnerInvocationHandler: 소유자가 자신의 프로필을 전체 수정할 수 있습니다.
NonOwnerInvocationHandler: 게스트는 프로필 평가(괴짜 지수 설정)만 가능하고, 다른 필드는 수정할 수 없습니다.

import java.lang.reflect.*;

public class OwnerInvocationHandler implements InvocationHandler {
    private Person person;

    public OwnerInvocationHandler(Person person) {
        this.person = person;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws IllegalAccessException {
        try {
            if (method.getName().startsWith("get")) {
                return method.invoke(person, args);
            } else if (method.getName().equals("setGeekRating")) {
                throw new IllegalAccessException("소유자는 자기 자신의 괴짜 지수를 설정할 수 없습니다.");
            } else if (method.getName().startsWith("set")) {
                return method.invoke(person, args);
            }
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        return null;
    }
}

public class NonOwnerInvocationHandler implements InvocationHandler {
    private Person person;

    public NonOwnerInvocationHandler(Person person) {
        this.person = person;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws IllegalAccessException {
        try {
            if (method.getName().startsWith("get")) {
                return method.invoke(person, args);
            } else if (method.getName().equals("setGeekRating")) {
                return method.invoke(person, args);
            } else if (method.getName().startsWith("set")) {
                throw new IllegalAccessException("게스트는 프로필을 수정할 수 없습니다.");
            }
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        return null;
    }
}

프록시 생성기

Proxy 클래스를 사용하여, Person 객체의 프록시 객체를 생성합니다. OwnerInvocationHandler와 NonOwnerInvocationHandler에 따라 소유자와 게스트 권한을 다르게 설정합니다.

public class ProxyFactory {
    public static Person getOwnerProxy(Person person) {
        return (Person) Proxy.newProxyInstance(
                person.getClass().getClassLoader(),
                person.getClass().getInterfaces(),
                new OwnerInvocationHandler(person)
        );
    }

    public static Person getNonOwnerProxy(Person person) {
        return (Person) Proxy.newProxyInstance(
                person.getClass().getClassLoader(),
                person.getClass().getInterfaces(),
                new NonOwnerInvocationHandler(person)
        );
    }
}

3. 테스트 코드

소유자와 게스트의 권한을 테스트하여, 보호 프록시가 권한에 따라 동작하는지 확인합니다.

public class DatingServiceTest {
    public static void main(String[] args) {
        Person joe = new PersonImpl();
        joe.setName("Joe Javabean");
        joe.setGender("Male");
        joe.setInterests("Programming, Tennis, Movies");

        // 1. 소유자 프록시 생성
        Person ownerProxy = ProxyFactory.getOwnerProxy(joe);
        System.out.println("이름: " + ownerProxy.getName());
        ownerProxy.setInterests("Programming and playing games");
        System.out.println("관심사: " + ownerProxy.getInterests());

        try {
            ownerProxy.setGeekRating(10);  // 소유자가 자신의 괴짜 지수를 설정하려고 하면 예외 발생
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }

        // 2. 게스트 프록시 생성
        Person nonOwnerProxy = ProxyFactory.getNonOwnerProxy(joe);
        System.out.println("\n게스트 권한 테스트:");
        System.out.println("이름: " + nonOwnerProxy.getName());
        try {
            nonOwnerProxy.setInterests("Watching movies");  // 게스트가 관심사를 설정하려고 하면 예외 발생
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        nonOwnerProxy.setGeekRating(5);  // 게스트는 괴짜 지수를 설정할 수 있음
        System.out.println("괴짜 지수: " + nonOwnerProxy.getGeekRating());
    }
}

결과

소유자:
- 프로필 정보(이름, 성별, 관심사)를 수정할 수 있지만, 괴짜 지수 설정은 불가능.
게스트:
- 프로필 정보는 읽기만 가능하며, 괴짜 지수 설정만 가능.

이렇게 구현하면 보호 프록시(Protection Proxy)를 통해 접근 권한을 제어하고, 사용자 권한에 따라 메소드 접근을 제한할 수 있습니다. 이 패턴을 통해 사용자의 잘못된 접근을 방지하고, 안정적인 시스템 제어를 할 수 있습니다.

[개발서적] 헤드퍼스트 디자인 패턴 Ch10. 상태 패턴

SWKo — Sun, 22 Sep 2024 23:47:50 +0900

1. 뽑기 기계 예시

뽑기 기계 회사는 최근 기술 발달에 맞춰 뽑기 기계에 CPU를 탑재하여 매출을 늘리고, 네트워크 연결을 통해 재고 관리 및 고객 만족도 집계를 하려는 목표를 가지고 있습니다.

아래 그림처럼 뽑기 기계를 제어할 수 있는 코드를 요청받았습니다.

1. 상태 정의 및 상태 변수 설정

// 상태 정의
final static int SOLD_OUT = 0;   // 매진 상태
final static int NO_QUARTER = 1; // 동전 없음 상태
final static int HAS_QUARTER = 2; // 동전 있음 상태
final static int SOLD = 3;       // 알맹이 판매 상태

// 현재 상태를 저장하는 변수
int state = SOLD_OUT;  // 처음에는 매진 상태로 시작

2. 행동 정의

시스템에서 일어날 수 있는 행동들을 모읍니다.

동전 투입, 동전 반환, 손잡이 돌림, 알맹이 내보냄

3. 행동을 상태에 따라 구현

public void insertQuarter() {
    if (state == HAS_QUARTER) {
        System.out.println("동전은 한 개만 넣어주세요.");
    } else if (state == NO_QUARTER) {
        state = HAS_QUARTER;  // 상태 변경: 동전 있음
        System.out.println("동전이 투입되었습니다.");
    } else if (state == SOLD_OUT) {
        System.out.println("매진되었습니다. 다음 기회에 이용해주세요.");
    } else if (state == SOLD) {
        System.out.println("알맹이를 내보내고 있습니다. 잠시만 기다려주세요.");
    }
}

뽑기 기계 코드

public class GumballMachine {
    // 상태 정의
    final static int SOLD_OUT = 0;
    final static int NO_QUARTER = 1;
    final static int HAS_QUARTER = 2;
    final static int SOLD = 3;
    
    // 현재 상태를 저장하는 변수
    int state = SOLD_OUT;
    // 알맹이 개수를 저장하는 변수
    int count = 0;
    
    // 생성자: 알맹이 개수를 초기화
    public GumballMachine(int count) {
        this.count = count;
        if (count > 0) {
            state = NO_QUARTER;  // 알맹이가 있으면 동전 대기 상태로
        }
    }

    // 동전 투입
    public void insertQuarter() {
        if (state == HAS_QUARTER) {
            System.out.println("동전은 한 개만 넣어 주세요.");
        } else if (state == NO_QUARTER) {
            state = HAS_QUARTER;
            System.out.println("동전을 넣으셨습니다.");
        } else if (state == SOLD_OUT) {
            System.out.println("매진되었습니다. 다음 기회에 이용해 주세요.");
        } else if (state == SOLD) {
            System.out.println("알맹이를 내보내고 있습니다.");
        }
    }

    // 동전 반환
    public void ejectQuarter() {
        if (state == HAS_QUARTER) {
            System.out.println("동전이 반환됩니다.");
            state = NO_QUARTER;
        } else if (state == NO_QUARTER) {
            System.out.println("동전을 넣어 주세요.");
        } else if (state == SOLD) {
            System.out.println("이미 알맹이를 뽑으셨습니다.");
        } else if (state == SOLD_OUT) {
            System.out.println("동전을 넣지 않으셨습니다. 동전이 반환되지 않습니다.");
        }
    }

    // 손잡이 돌림
    public void turnCrank() {
        if (state == SOLD) {
            System.out.println("손잡이는 한 번만 돌려 주세요.");
        } else if (state == NO_QUARTER) {
            System.out.println("동전을 넣어 주세요.");
        } else if (state == SOLD_OUT) {
            System.out.println("매진되었습니다.");
        } else if (state == HAS_QUARTER) {
            System.out.println("손잡이를 돌리셨습니다.");
            state = SOLD;
            dispense();
        }
    }

    // 알맹이 내보내기
    public void dispense() {
        if (state == SOLD) {
            System.out.println("알맹이를 내보내고 있습니다.");
            count = count - 1;
            if (count == 0) {
                System.out.println("더 이상 알맹이가 없습니다.");
                state = SOLD_OUT;
            } else {
                state = NO_QUARTER;
            }
        } else if (state == NO_QUARTER) {
            System.out.println("동전을 넣어 주세요.");
        } else if (state == SOLD_OUT) {
            System.out.println("알맹이가 없습니다.");
        } else if (state == HAS_QUARTER) {
            System.out.println("알맹이를 내보낼 수 없습니다.");
        }
    }

    // 기타 메소드: 기계 상태 출력
    @Override
    public String toString() {
        return "남은 알맹이 개수: " + count + ", 현재 상태: " + getStateString();
    }

    // 상태 문자열 반환
    private String getStateString() {
        switch (state) {
            case SOLD_OUT: return "매진";
            case NO_QUARTER: return "동전 대기";
            case HAS_QUARTER: return "동전 있음";
            case SOLD: return "알맹이 판매 중";
            default: return "알 수 없음";
        }
    }
    
    // 재고를 채우는 메소드
    public void refill(int numGumballs) {
        this.count = numGumballs;
        state = NO_QUARTER;
        System.out.println("재고가 보충되었습니다. 현재 알맹이 개수: " + count);
    }
}

사용 예시

public class GumballMachineTestDrive {
    public static void main(String[] args) {
        GumballMachine gumballMachine = new GumballMachine(5);

        System.out.println(gumballMachine);

        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();

        System.out.println(gumballMachine);

        gumballMachine.insertQuarter();
        gumballMachine.ejectQuarter();
        gumballMachine.turnCrank();

        System.out.println(gumballMachine);
    }
}

출력 예시

남은 알맹이 개수: 5, 현재 상태: 동전 대기
동전을 넣으셨습니다.
손잡이를 돌리셨습니다.
알맹이를 내보내고 있습니다.
남은 알맹이 개수: 4, 현재 상태: 동전 대기
동전을 넣으셨습니다.
동전이 반환됩니다.
동전을 넣어 주세요.
남은 알맹이 개수: 4, 현재 상태: 동전 대기

여기서, 뽑기에 게임 기능을 추가하면 좋겠다는 요청이 들어왔습니다.

뽑기에 게임 기능을 추가하려면 WINNER 상태를 추가해야 합니다.

그런데, 새로 추가된 WINNER 상태를 확인하는 조건문을 모든 메서드에 추가해줘야 하는 문제점이 생겼습니다.

2. 새로운 디자인 구상하기

기존 코드를 활용하는 대신 상태 객체를 별도 코드에 넣고, 어떤 행동이 일어나면 현재 상태 객체에서 필요한 작업을 처리하게 합니다.

뽑기 기계 행동에 관한 메서드가 들어있는 State 인터페이스를 정의해야 합니다.
기계의 모든 상태를 대상으로 상태 클래스를 구현해야 합니다.
조건문 코드를 모두 없애고, 상태 클래스에 모든 작업을 위임합니다.

모든 상태 클래스에서 구현할 State Interface를 정의해봅니다.

상태 클래스를 구현합니다.

NoQuarterState

public class NoQuarterState implements State {
    GumballMachine gumballMachine;

    // GumballMachine 인스턴스를 전달받는 생성자
    public NoQuarterState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }

    // 동전이 투입되었을 때 처리
    public void insertQuarter() {
        System.out.println("동전을 넣으셨습니다.");
        // 상태를 HasQuarterState로 전환
        gumballMachine.setState(gumballMachine.getHasQuarterState());
    }

    // 동전을 반환할 때 처리
    public void ejectQuarter() {
        System.out.println("동전을 넣지 않았습니다.");
    }

    // 손잡이를 돌렸을 때 처리
    public void turnCrank() {
        System.out.println("동전을 넣어 주세요.");
    }

    // 알맹이를 내보낼 때 처리
    public void dispense() {
        System.out.println("동전을 넣어 주세요.");
    }
}

HasQuarterState

public class HasQuarterState implements State {
    GumballMachine gumballMachine;

    public HasQuarterState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }

    // 동전이 이미 들어 있는 상태에서 동전을 다시 넣으려 할 때
    public void insertQuarter() {
        System.out.println("동전은 한 개만 넣어 주세요.");
    }

    // 동전 반환 요청 시, 동전을 반환하고 상태를 동전 없음 상태로 전환
    public void ejectQuarter() {
        System.out.println("동전이 반환됩니다.");
        gumballMachine.setState(gumballMachine.getNoQuarterState());
    }

    // 손잡이를 돌리면 알맹이를 내보낼 준비가 되고 상태를 판매 상태로 전환
    public void turnCrank() {
        System.out.println("손잡이를 돌리셨습니다.");
        gumballMachine.setState(gumballMachine.getSoldState());
    }

    // 아직 손잡이를 돌리지 않았으므로 알맹이를 내보낼 수 없음
    public void dispense() {
        System.out.println("알맹이를 내보낼 수 없습니다.");
    }
}

SoldState

public class SoldState implements State {
    GumballMachine gumballMachine;

    // 생성자: GumballMachine 인스턴스를 받음
    public SoldState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }

    // 동전 투입: 이미 알맹이를 내보내는 중이므로 부적절한 행동
    public void insertQuarter() {
        System.out.println("알맹이를 내보내고 있습니다.");
    }

    // 동전 반환: 이미 알맹이가 나갔기 때문에 동전을 반환할 수 없음
    public void ejectQuarter() {
        System.out.println("이미 알맹이를 뽑으셨습니다.");
    }

    // 손잡이 돌림: 이미 돌렸으므로 다시 돌리는 것은 부적절함
    public void turnCrank() {
        System.out.println("손잡이는 한 번만 돌려 주세요.");
    }

    // 알맹이 내보내기
    public void dispense() {
        // 알맹이를 내보내는 작업
        gumballMachine.releaseBall();

        // 남은 알맹이가 있는지 확인
        if (gumballMachine.getCount() > 0) {
            // 알맹이가 남아 있다면 상태를 NoQuarterState로 전환
            gumballMachine.setState(gumballMachine.getNoQuarterState());
        } else {
            // 알맹이가 없다면 SoldOutState로 전환
            System.out.println("Oops, out of gumballs!");
            gumballMachine.setState(gumballMachine.getSoldOutState());
        }
    }
}

SoldoutState

public class SoldOutState implements State {
    GumballMachine gumballMachine;

    // 생성자: GumballMachine 인스턴스를 받음
    public SoldOutState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }

    // 동전 투입: 매진 상태이므로 동전을 받을 수 없음
    public void insertQuarter() {
        System.out.println("매진되었습니다. 동전을 넣을 수 없습니다.");
    }

    // 동전 반환: 동전을 넣을 수 없으므로 반환할 동전도 없음
    public void ejectQuarter() {
        System.out.println("동전을 넣지 않으셨습니다. 반환할 동전이 없습니다.");
    }

    // 손잡이 돌림: 알맹이가 없으므로 손잡이를 돌려도 소용없음
    public void turnCrank() {
        System.out.println("매진되었습니다.");
    }

    // 알맹이 내보내기: 알맹이가 없으므로 내보낼 수 없음
    public void dispense() {
        System.out.println("알맹이가 없습니다.");
    }
}

뽑기 기계 코드를 수정합니다.

public class GumballMachine {
    // 상태 객체 선언
    State soldOutState;
    State noQuarterState;
    State hasQuarterState;
    State soldState;

    // 현재 상태를 저장하는 변수
    State state;
    // 알맹이 개수를 저장하는 변수
    int count = 0;

    // 생성자: 알맹이 개수를 설정하고 상태 객체들을 초기화
    public GumballMachine(int numberGumballs) {
        // 상태 객체 생성
        soldOutState = new SoldOutState(this);
        noQuarterState = new NoQuarterState(this);
        hasQuarterState = new HasQuarterState(this);
        soldState = new SoldState(this);
        
        // 알맹이 개수 설정
        this.count = numberGumballs;

        // 알맹이가 있으면 noQuarterState로, 없으면 soldOutState로 초기화
        if (numberGumballs > 0) {
            state = noQuarterState;
        } else {
            state = soldOutState;
        }
    }

    // 동전 투입
    public void insertQuarter() {
        state.insertQuarter();
    }

    // 동전 반환
    public void ejectQuarter() {
        state.ejectQuarter();
    }

    // 손잡이 돌리기
    public void turnCrank() {
        state.turnCrank();
        state.dispense();  // 알맹이 내보내기
    }

    // 상태 전환
    void setState(State state) {
        this.state = state;
    }

    // 알맹이 내보내기 (보조 메소드)
    void releaseBall() {
        System.out.println("알맹이를 내보내고 있습니다.");
        if (count > 0) {
            count = count - 1;
        }
    }

    // 현재 남은 알맹이 개수를 반환
    public int getCount() {
        return count;
    }

    // 상태 객체 반환 메소드들
    public State getSoldOutState() {
        return soldOutState;
    }

    public State getNoQuarterState() {
        return noQuarterState;
    }

    public State getHasQuarterState() {
        return hasQuarterState;
    }

    public State getSoldState() {
        return soldState;
    }

    // 재고를 보충하는 메소드
    public void refill(int numGumballs) {
        this.count += numGumballs;
        System.out.println("재고가 보충되었습니다. 현재 알맹이 개수: " + this.count);
        if (count > 0) {
            state = noQuarterState;
        }
    }

    @Override
    public String toString() {
        return "GumballMachine{알맹이 개수: " + count + ", 현재 상태: " + state.getClass().getSimpleName() + "}";
    }
}

3. 뽑기 기계 구조 다시 살펴보기

지금까지 구현한 GumballMachine 클래스 구조는 상태 패턴을 사용하여 개선되었으며, 초기의 조건문 기반 구조와는 큰 차이가 있습니다. 하지만, 기능적으로는 완전히 동일한 동작을 수행합니다.

상태의 행동을 별도의 클래스로 분리
상태 국지화, 모듈화
복잡한 조건문 제거
OCP(Open-Closed Principle) 적용
GumballMachine은 새로운 상태를 추가할 때 기존 코드를 수정할 필요 없이(Closed) 새로운 상태 클래스를 추가하면 됩니다.(Open)
더 직관적이고 이해하기 쉬운 구조
상태마다 독립적인 클래스가 있으므로, 모드를 읽는 사람이 상태별로 어떤 일이 벌어지는지 쉽게 알 수 있습니다.

4. 상태 패턴의 정의

상태 패턴(State Pattern)을 사용하면 객체의 내부 상태가 바뀜에 따라 객체의 행동을 바꿀 수 있습니다.

마치 객체의 클래스가 바뀌는 것과 같은 결과를 얻을 수 있습니다.

1. "객체의 내부 상태가 바뀜에 따라 객체의 행동을 바꿀 수 있습니다."

상태 패턴에서는 상태를 별도의 클래스로 캡슐화하고, 객체는 현재 상태를 나타내는 객체에게 행동을 위임합니다. 이로 인해 내부 상태가 바뀔 때 행동이 달라지게 됩니다.

NoQuarterState일 때: 동전을 넣으면 기계가 동전을 받아들임.
HasQuarterState일 때: 이미 동전이 들어 있으므로, 다시 동전을 넣으면 기계가 동전을 받아들이지 않음.

따라서 상태가 달라짐에 따라 동일한 메소드 호출이 다른 결과를 만들어냅니다.

2. "클래스가 바뀌는 것 같은 결과"

객체의 행동이 상태에 따라 완전히 달라진다면, 이는 객체가 다른 클래스로부터 만들어진 것처럼 느껴집니다. 실제로는 객체가 상태에 맞는 다른 상태 객체에게 행동을 위임하면서 이러한 결과가 나타나는 것입니다.

예를 들어, 사용자는 뽑기 기계가 NoQuarterState와 HasQuarterState에서 완전히 다른 방식으로 동작하는 것을 보고, 마치 기계가 다른 클래스로 변신한 것처럼 느낄 수 있습니다. 이는 상태 객체를 바꿔서 처리하는 것이므로, 객체가 실제로 다른 클래스로 변신하지는 않지만 다른 클래스로 바뀐 것 같은 효과를 줍니다.

Context(문맥, 예: GumballMachine): 상태 객체를 관리하고, 상태에 따른 행동을 위임합니다.
State(상태 인터페이스): 상태가 수행해야 할 행동을 정의합니다.
ConcreteState(구체적인 상태, 예: NoQuarterState, HasQuarterState): 상태 인터페이스를 구현하며, 상태별로 구체적인 동작을 정의합니다.

5. 전략 패턴 vs 상태 패턴

유사점

두 패턴 모두 행동(알고리즘)을 별도의 클래스로 캡슐화하고, Context 객체에서 그 행동을 위임받아 수행합니다.
다이어그램 상으로는 Context와 State/Strategy 객체들이 존재하며, Context 객체는 행동의 변화를 그 객체에 위임하여 처리한다는 공통점을 가지고 있습니다.

차이점

1. 상태 패턴

목적: 객체가 상태에 따라 행동이 달라질 때 사용됩니다. 각 상태는 독립된 클래스로 관리되고, 객체는 내부 상태에 따라 다른 상태 객체로 전환됩니다.
동작 방식: Context 객체는 상태가 바뀌면 내부적으로 상태 객체를 교체하며, 그에 따라 행동이 자동으로 달라집니다. 클라이언트는 상태 객체를 직접 지정하지 않습니다.
예시: 뽑기 기계에서 동전이 없을 때(상태 1), 동전이 있을 때(상태 2), 매진일 때(상태 3) 등 상태에 따라 행동이 달라집니다. 상태 전환은 내부적으로 이루어집니다.

2. 전략 패턴

목적: 특정 행동(알고리즘)을 실행할 때 클라이언트가 어떤 전략(행동)을 사용할지 직접 지정할 수 있도록 유연성을 제공하는 데 사용됩니다.
동작 방식: Context 객체가 어떤 전략 객체를 사용할지를 클라이언트가 선택합니다. 이는 주로 행동을 동적으로 변경할 필요가 있을 때 사용됩니다.
예시: 오리 게임에서 날 수 있는 오리와 날 수 없는 오리를 구분하여 날아가는 전략(알고리즘)을 클라이언트가 지정합니다. 각 오리에게 날 수 있는 전략이나 날지 못하는 전략을 선택해서 적용할 수 있습니다.

3. 핵심 차이점

상태 패턴에서는 상태에 따라 Context 객체가 스스로 변화하며, 클라이언트는 상태에 대해 직접 신경 쓸 필요가 없습니다. 상태가 자동으로 전환됩니다.
전략 패턴에서는 클라이언트가 전략을 명시적으로 선택합니다. 전략 객체는 동적으로 변경될 수 있으며, 클라이언트가 적절한 전략을 직접 설정합니다.

6. 보너스 알맹이 당첨 기능 추가하기

10번에 1번 꼴로 알맹이를 하나 더 주는 기능을 추가해봅니다.

GumballMachine 클래스에 먼저 상태를 추가해줍니다.

public class GumballMachine {
    State soldOutState;
    State noQuarterState;
    State hasQuarterState;
    State soldState;
    State winnerState;  // WinnerState 추가

    State state;
    int count = 0;

    public GumballMachine(int numberGumballs) {
        soldOutState = new SoldOutState(this);
        noQuarterState = new NoQuarterState(this);
        hasQuarterState = new HasQuarterState(this);
        soldState = new SoldState(this);
        winnerState = new WinnerState(this);  // WinnerState 초기화

        this.count = numberGumballs;
        if (numberGumballs > 0) {
            state = noQuarterState;
        } else {
            state = soldOutState;
        }
    }

    // 상태 전환 메소드
    public void setState(State state) {
        this.state = state;
    }

    public void releaseBall() {
        System.out.println("알맹이가 나왔습니다.");
        if (count > 0) {
            count--;
        }
    }

    // 알맹이 개수 반환 메소드
    public int getCount() {
        return count;
    }

    // 각 상태 객체에 대한 게터 메소드들
    public State getSoldOutState() {
        return soldOutState;
    }

    public State getNoQuarterState() {
        return noQuarterState;
    }

    public State getHasQuarterState() {
        return hasQuarterState;
    }

    public State getSoldState() {
        return soldState;
    }

    public State getWinnerState() {
        return winnerState;  // WinnerState 게터
    }
}

WinnerState 클래스 구현 - 당첨되었을 때 알맹이를 2개 배출하는 역할, 당첨 시에 첫 번째 알맹이를 배출 후, 기계에 알맹이가 남아있으면 추가로 한 개를 더 배출합합니다.

public class WinnerState implements State {
    GumballMachine gumballMachine;

    // 생성자
    public WinnerState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }

    // 동전 투입 시 오류 메시지
    public void insertQuarter() {
        System.out.println("알맹이가 나오는 중입니다. 잠시만 기다려 주세요.");
    }

    // 동전 반환 시 오류 메시지
    public void ejectQuarter() {
        System.out.println("이미 알맹이를 뽑으셨습니다.");
    }

    // 손잡이 돌림 시 오류 메시지
    public void turnCrank() {
        System.out.println("손잡이는 한 번만 돌려 주세요.");
    }

    // 알맹이 배출
    public void dispense() {
        // 첫 번째 알맹이 배출
        gumballMachine.releaseBall();
        if (gumballMachine.getCount() == 0) {
            gumballMachine.setState(gumballMachine.getSoldOutState());
        } else {
            // 두 번째 알맹이 배출
            System.out.println("축하드립니다! 알맹이를 하나 더 받으실 수 있습니다.");
            gumballMachine.releaseBall();
            if (gumballMachine.getCount() > 0) {
                gumballMachine.setState(gumballMachine.getNoQuarterState());
            } else {
                gumballMachine.setState(gumballMachine.getSoldOutState());
            }
        }
    }
}

GumballMachine에서 WinnerState로 상태 전환하기

public class HasQuarterState implements State {
    GumballMachine gumballMachine;

    public HasQuarterState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }

    public void insertQuarter() {
        System.out.println("동전은 한 개만 넣어 주세요.");
    }

    public void ejectQuarter() {
        System.out.println("동전이 반환됩니다.");
        gumballMachine.setState(gumballMachine.getNoQuarterState());
    }

    public void turnCrank() {
        System.out.println("손잡이를 돌리셨습니다.");
        // 10번에 1번 꼴로 WinnerState로 전환
        if (Math.random() < 0.1 && gumballMachine.getCount() > 1) {
            gumballMachine.setState(gumballMachine.getWinnerState());
        } else {
            gumballMachine.setState(gumballMachine.getSoldState());
        }
    }

    public void dispense() {
        System.out.println("알맹이를 내보낼 수 없습니다.");
    }
}

테스트 코드

public class GumballMachineTestDrive {
    public static void main(String[] args) {
        // 뽑기 기계에 5개의 알맹이를 넣고 생성
        GumballMachine gumballMachine = new GumballMachine(5);

        // 현재 기계 상태 출력
        System.out.println(gumballMachine);

        // 동전 투입 및 손잡이 돌리기
        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();

        // 현재 상태 출력
        System.out.println(gumballMachine);

        // 다시 동전 투입 및 손잡이 돌리기
        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();

        // 동전 투입 및 손잡이 돌리기
        gumballMachine.insertQuarter();
        gumballMachine.turnCrank();

        // 마지막 상태 출력
        System.out.println(gumballMachine);
    }
}

7. 정상성 점검(sanity check)하기

1. SoldState와 WinnerState의 중복 코드

문제점: SoldState와 WinnerState에서 알맹이를 내보내는 동작이 중복되어 있습니다. 비슷한 로직이 반복되므로 코드 중복 문제가 발생합니다.
해결책: 중복된 코드를 해결하려면, State를 추상 클래스로 만들어 공통 기능을 상속받도록 하면 됩니다. dispense()와 같은 공통 메소드를 추상 클래스에서 정의하고, 상태별로 필요한 부분만 오버라이드하면 됩니다. 각 상태 클래스는 공통 기능을 상속받고, 상태 전환 로직만 다르게 구현합니다.

public abstract class AbstractState implements State {
    GumballMachine gumballMachine;

    public AbstractState(GumballMachine gumballMachine) {
        this.gumballMachine = gumballMachine;
    }

    public void insertQuarter() {
        System.out.println("동전은 한 개만 넣어 주세요.");
    }

    public void ejectQuarter() {
        System.out.println("이미 알맹이를 뽑으셨습니다.");
    }

    public void turnCrank() {
        System.out.println("손잡이는 한 번만 돌려 주세요.");
    }

    // 공통 dispense() 메소드
    public void dispense() {
        System.out.println("알맹이를 내보낼 수 없습니다.");
    }
}

2. dispense() 메소드 호출 문제

문제점: dispense() 메소드가 동전 없이 손잡이를 돌렸을 때도 호출됩니다. 잘못된 상태에서 호출되더라도 알맹이는 배출되지 않지만, 비효율적인 호출이 발생할 수 있습니다.
해결책 1. 불리언 값을 리턴하는 방식
turnCrank() 메소드가 성공적으로 동작했는지를 불리언 값으로 리턴하여, 그 값에 따라 dispense()를 호출할지 말지를 결정할 수 있습니다.

public boolean turnCrank() {
    if (state == hasQuarterState || state == winnerState) {
        state.turnCrank();
        state.dispense();
        return true;
    }
    return false;
}

해결책 2. 예외 처리 방식
예외 처리를 도입하여, 잘못된 상태에서 호출될 때 예외를 던지게 할 수 있습니다. 이는 잘못된 상태에서의 호출을 명확하게 처리할 수 있지만, 예외 처리가 복잡해질 수 있습니다.

public void dispense() throws IllegalStateException {
    if (state != hasQuarterState && state != winnerState) {
        throw new IllegalStateException("잘못된 상태에서 dispense 호출");
    }
    state.dispense();
}

3. 상태 전환 정보를 상태 클래스에 넣는 문제

문제점: 현재 상태 전환 로직이 각 상태 클래스에 분산되어 있습니다. 이는 상태 전환 관리의 복잡성을 초래할 수 있습니다.
해결책: 상태 전환 로직을 GumballMachine 클래스에서 관리하는 방법을 고려할 수 있습니다. 이렇게 하면 상태 전환을 한 곳에서 중앙 집중식으로 관리할 수 있어, 상태 간의 흐름이 명확해집니다.
- 장점 : 상태 전환 로직이 한 곳에 모이기 때문에 유지보수가 쉬워집니다.
- 단점 : 상태별로 독립적인 처리가 어려워질 수 있으며, 상태 패턴의 캡슐화 이점이 사라질 수 있습니다. 이는 상태 패턴의 의도를 훼손할 수 있습니다.

4. 상태 인스턴스를 정적 변수로 만들어 공유하는 문제

문제점: 여러 개의 GumballMachine 인스턴스를 만들 때 각 기계가 상태 인스턴스를 공유할 수 있도록 개선할 수 있습니다.
해결책: 상태 인스턴스를 정적(static) 변수로 만들어, 모든 기계가 상태 인스턴스를 공유하도록 설계할 수 있습니다. 이를 통해 상태 인스턴스의 재사용이 가능해져 메모리 효율을 높일 수 있습니다.

public class GumballMachine {
    private static final State soldOutState = new SoldOutState();
    private static final State noQuarterState = new NoQuarterState();
    private static final State hasQuarterState = new HasQuarterState();
    private static final State soldState = new SoldState();
    private static final State winnerState = new WinnerState();

    // 상태 전환 로직
}

장점: 여러 기계가 동일한 상태를 사용할 경우 메모리 절약 효과가 있습니다.
단점: 상태 인스턴스를 공유하면 상태 변경이 전역적으로 적용될 수 있습니다. 즉, 한 기계의 상태가 변경될 때 다른 기계에도 영향을 줄 수 있으므로, 상태 관리가 더욱 복잡해질 수 있습니다.

FE 상태 패턴

프론트엔드에서도 **상태 패턴(State Pattern)**을 적용할 수 있습니다. 특히 상태에 따라 UI가 변화해야 하거나 사용자 인터랙션에 따라 여러 동작이 다르게 수행되는 경우에 유용합니다.

다음은 React에서 상태 패턴을 적용하여 버튼의 상태에 따라 다른 동작을 수행하는 간단한 예시입니다. 여기서 버튼의 상태는 "idle", "loading", "success", "error" 등으로 변하고, 각 상태에 따라 버튼의 UI와 동작이 달라집니다.

1. 상태 인터페이스 정의

React에서 상태 패턴을 적용하려면, 각 상태의 행동을 정의하는 인터페이스처럼 사용할 수 있습니다.

// ButtonState.js
export class ButtonState {
    onClick(context) {
        throw new Error("This method should be overridden by subclasses.");
    }
}

export class IdleState extends ButtonState {
    onClick(context) {
        context.setState({ status: "loading" });
        setTimeout(() => {
            if (Math.random() > 0.5) {
                context.setState({ status: "success" });
            } else {
                context.setState({ status: "error" });
            }
        }, 1000); // Simulate network request
    }
}

export class LoadingState extends ButtonState {
    onClick(context) {
        console.log("Loading... please wait.");
    }
}

export class SuccessState extends ButtonState {
    onClick(context) {
        console.log("Already successful.");
    }
}

export class ErrorState extends ButtonState {
    onClick(context) {
        context.setState({ status: "idle" });
    }
}

2. React 컴포넌트에서 상태 패턴 적용

이제 React 컴포넌트에서 상태에 따라 버튼의 동작을 다르게 구현합니다.

import React, { useState } from "react";
import {
    ButtonState,
    IdleState,
    LoadingState,
    SuccessState,
    ErrorState,
} from "./ButtonState";

const StatefulButton = () => {
    // 상태 관리 (idle, loading, success, error)
    const [status, setStatus] = useState("idle");

    // 상태에 따른 클래스 할당
    const getButtonState = () => {
        switch (status) {
            case "idle":
                return new IdleState();
            case "loading":
                return new LoadingState();
            case "success":
                return new SuccessState();
            case "error":
                return new ErrorState();
            default:
                return new IdleState();
        }
    };

    const buttonState = getButtonState();

    // 버튼 클릭 시 상태에 따른 동작 수행
    const handleClick = () => {
        buttonState.onClick({ setState: setStatus });
    };

    // 상태에 따른 버튼 스타일 및 텍스트 변경
    const renderButtonText = () => {
        switch (status) {
            case "idle":
                return "Submit";
            case "loading":
                return "Loading...";
            case "success":
                return "Success!";
            case "error":
                return "Error! Try Again";
            default:
                return "Submit";
        }
    };

    return (
        <button
            onClick={handleClick}
            disabled={status === "loading"}
            style={{
                padding: "10px 20px",
                backgroundColor: status === "success" ? "green" : status === "error" ? "red" : "blue",
                color: "white",
                border: "none",
                borderRadius: "5px",
                cursor: status === "loading" ? "not-allowed" : "pointer",
            }}
        >
            {renderButtonText()}
        </button>
    );
};

export default StatefulButton;

3. 설명:

StatefulButton 컴포넌트는 상태에 따라 버튼의 동작과 UI가 달라집니다.
IdleState: 사용자가 버튼을 클릭하면, onClick 메소드를 통해 상태가 loading으로 전환되고, 가상 네트워크 요청이 완료되면 상태가 success 또는 error로 전환됩니다.
LoadingState: 버튼이 "Loading..." 상태일 때는 클릭 이벤트가 비활성화되며, 콘솔에 "Loading... please wait." 메시지가 출력됩니다.
SuccessState: 성공 상태에서는 버튼을 다시 클릭해도 아무런 동작을 하지 않습니다.
ErrorState: 실패 상태에서는 다시 "idle" 상태로 전환됩니다.

4. 상태 변화 과정

처음 버튼은 idle 상태에서 "Submit" 텍스트를 표시합니다.
사용자가 버튼을 클릭하면 loading 상태로 전환되며, "Loading..." 텍스트가 표시됩니다.
네트워크 요청이 완료된 후 성공 시 success 상태로, 실패 시 error 상태로 전환됩니다.
success 상태에서는 "Success!"를 표시하며, error 상태에서는 "Error! Try Again"을 표시하여 사용자가 재시도를 할 수 있습니다.

요약:

이 예시에서 상태 패턴은 각 버튼 상태(Idle, Loading, Success, Error)에 대한 행동을 별도의 클래스로 관리하고, React의 상태와 연결하여 버튼의 동작과 UI를 제어합니다. 상태 패턴을 사용하면 상태별로 서로 다른 행동을 캡슐화하고, 상태 전환에 따른 행동 변화를 명확하게 관리할 수 있습니다.

[개발서적] 헤드퍼스트 디자인 패턴 Ch9. 반복자 패턴과 컴포지트 패턴

SWKo — Wed, 4 Sep 2024 01:37:19 +0900

1. 객체 마을 식당과 팬케이스 하우스 합병

팬케이스 하우스에서 파는 아침 메뉴, 객체마을 식당에서 파는 점심 메뉴를 한 곳에서 먹을 수 있게 되었습니다만, 문제가 생겼습니다.

아침, 점심에 각각 다른 메뉴를 써야합니다. 일단 MenuItem 클래스의 구현 방법은 합의했습니다.

public class MenuItem {
    String name;           // 메뉴 이름
    String description;    // 메뉴 설명
    boolean vegetarian;    // 채식주의 여부
    double price;          // 가격

    // 생성자: 메뉴 아이템의 속성을 초기화
    public MenuItem(String name, String description, boolean vegetarian, double price) {
        this.name = name;
        this.description = description;
        this.vegetarian = vegetarian;
        this.price = price;
    }

    // 메뉴 이름 반환
    public String getName() {
        return name;
    }

    // 메뉴 설명 반환
    public String getDescription() {
        return description;
    }

    // 가격 반환
    public double getPrice() {
        return price;
    }

    // 채식주의 여부 반환
    public boolean isVegetarian() {
        return vegetarian;
    }
}

두 사람은 각자 메뉴 항목을 저장하는 방식에서 차이가 있으며, 그로 인해 다툼이 생겼습니다.

팬케이스 하우스

public class PancakeHouseMenu {
    List<MenuItem> menuItems;

    public PancakeHouseMenu() {
        menuItems = new ArrayList<MenuItem>();
        addItem("K&B 팬케이크 세트", "스크램블 에그와 토스트가 곁들여진 팬케이크", false, 2.99);
        addItem("레귤러 팬케이크 세트", "달걀 프라이와 소시지가 곁들여진 팬케이크", false, 2.99);
        addItem("블루베리 팬케이크", "신선한 블루베리와 블루베리 시럽으로 만든 팬케이크", true, 3.49);
        addItem("와플", "취향에 따라 블루베리나 딸기를 얹을 수 있는 와플", true, 3.59);
    }

    public void addItem(String name, String description, boolean vegetarian, double price) {
        MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
        menuItems.add(menuItem);
    }

    public List<MenuItem> getMenuItems() {
        return menuItems;
    }
}

저장 방식: ArrayList<MenuItem>을 사용하여 메뉴 항목을 동적으로 관리합니다.
유연성: 메뉴 항목을 추가하는 데 제한이 없으며, ArrayList는 크기가 동적으로 조정됩니다.
추가 기능: addItem() 메서드를 사용해 언제든지 새로운 항목을 추가할 수 있습니다.
확장성: ArrayList를 사용하므로 항목 개수에 제한이 없고 유연한 확장이 가능합니다.

객체마을 식당

public class DinerMenu {
    static final int MAX_ITEMS = 6;
    int numberOfItems = 0;
    MenuItem[] menuItems;

    public DinerMenu() {
        menuItems = new MenuItem[MAX_ITEMS];
        addItem("채식주의자용 BLT", "통밀 위에 콩고기 베이컨, 상추, 토마토를 얹은 메뉴", true, 2.99);
        addItem("BLT", "통밀 위에 베이컨, 상추, 토마토를 얹은 메뉴", false, 2.99);
        addItem("오늘의 스프", "감자 샐러드를 곁들인 오늘의 스프", false, 3.29);
        addItem("핫도그", "사워크라우트, 갖은 양념, 양파, 치즈가 곁들여진 핫도그", false, 3.05);
    }

    public void addItem(String name, String description, boolean vegetarian, double price) {
        MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
        if (numberOfItems >= MAX_ITEMS) {
            System.err.println("죄송합니다, 메뉴가 꽉 찼습니다. 더 이상 추가할 수 없습니다.");
        } else {
            menuItems[numberOfItems] = menuItem;
            numberOfItems++;
        }
    }

    public MenuItem[] getMenuItems() {
        return menuItems;
    }
}

저장 방식: 배열(MenuItem[])을 사용하여 메뉴 항목을 저장하며, 최대 항목 개수를 MAX_ITEMS = 6으로 제한합니다.
제한점: 배열을 사용하기 때문에 메뉴 항목의 개수가 고정되어 있으며, 6개를 초과할 수 없습니다.
효율성: 배열을 사용하여 메모리 관리가 직관적이지만, 메뉴 항목을 동적으로 추가하는 데는 어려움이 있습니다.
추가 기능: addItem() 메서드를 통해 항목을 추가할 수 있으나, 최대 개수를 넘으면 항목을 추가할 수 없습니다.

2. 종업원 구현하기

종업원은 주문 내용에 맞춰 주문 메뉴를 출력하고, 어떤 메뉴가 채식주의자용인지 알아내는 능력도 갖춰야 합니다.

printMenu 메소드를 구현하는 방법을 보겠습니다.

1. 각 메뉴에 들어있는 항목을 모두 출력하려면 두 클래스의 getMenuItems() 메소드를 호출해서 메뉴 항목을 가져와야 합니다.

두 메소드의 리턴 형식이 다름에 주의해야합니다.

PancakeHouseMenu pancakeHouseMenu = new PancakeHouseMenu();
ArrayList<MenuItem> breakfastItems = pancakeHouseMenu.getMenuItems();

DinerMenu dinerMenu = new DinerMenu();
MenuItem[] lunchItems = dinerMenu.getMenuItems();

2. breakfastItems ArrayList에 들어있는 모든 항목에 순환문을 돌려 PancakeHouse Menu 항목을 출력합니다.

그리고 DinerMenu에 들어있는 항목을 출력할 때는 배열에 순환문을 돌립니다.

for (int i = 0; i < breakfastItems.size(); i++) {
    MenuItem menuItem = breakfastItems.get(i);
    System.out.print(menuItem.getName() + " ");
    System.out.println(menuItem.getPrice() + " ");
    System.out.println(menuItem.getDescription());
}

for (int i = 0; i < lunchItems.length; i++) {
    MenuItem menuItem = lunchItems[i];
    System.out.print(menuItem.getName() + " ");
    System.out.println(menuItem.getPrice() + " ");
    System.out.println(menuItem.getDescription());
}

3. 종업원은 항상 두 메뉴를 사용하고, 2개의 순환문을 사용해야 합니다. 만약 다른 구현법을 사용하는 레스토랑과 또 합병한다면 3개의 순환문이 필요하게 됩니다.

이처럼 확장성이 좋지 않습니다. 어떻게 인터페이스를 통합할 수 있을까요?

3. 반복자 패턴

반복자 패턴(Iterator Pattern)을 도입하면, ArrayList나 배열이 어떻게 저장되어 있든 상관없이 동일한 방식으로 반복 작업을 처리할 수 있습니다. 즉, size()나 length에 의존하지 않고, Iterator를 사용하여 항목을 순차적으로 처리할 수 있게 됩니다.

Iterator 인터페이스 구현: ArrayList나 배열 모두에 대해 Iterator 인터페이스를 구현하면, 클라이언트 코드에서 순회 방법에 의존하지 않고 항목을 처리할 수 있습니다.
createIterator 메서드 추가: 각 메뉴 클래스에 createIterator() 메서드를 추가하여 반복자를 반환하도록 합니다.
클라이언트 코드의 변경: size()나 length를 직접 호출하는 대신, Iterator를 사용해 항목을 하나씩 가져옵니다.

// ArrayList를 사용하는 PancakeHouseMenu
Iterator<MenuItem> breakfastIterator = pancakeHouseMenu.createIterator();
while (breakfastIterator.hasNext()) {
    MenuItem menuItem = breakfastIterator.next();
    System.out.println(menuItem.getName() + " " + menuItem.getPrice() + " " + menuItem.getDescription());
}

// 배열을 사용하는 DinerMenu
Iterator<MenuItem> lunchIterator = dinerMenu.createIterator();
while (lunchIterator.hasNext()) {
    MenuItem menuItem = lunchIterator.next();
    System.out.println(menuItem.getName() + " " + menuItem.getPrice() + " " + menuItem.getDescription());
}

반복자(Iterator) 패턴은 컬렉션(JAVA List, Set, Map 등 객체를 담는 컨테이너) 내의 객체들에 순차적으로 접근하는 방법을 제공하면서, 그 객체들의 내부 표현 방식에는 의존하지 않는 디자인 패턴입니다. 이 패턴은 다양한 자료구조에서 일관된 방식으로 객체를 순회할 수 있도록 도와줍니다.

4. 두 식당에 반복자 패턴 적용

먼저 Iterator 인터페이스를 정의합니다. 이 인터페이스는 두 가지 중요한 메서드를 포함하고 있습니다:

hasNext(): 컬렉션에 더 탐색할 항목이 있는지 확인합니다.
next(): 다음 항목을 반환합니다.

public interface Iterator {
    boolean hasNext();  // 다음 항목이 있는지 확인
    MenuItem next();    // 다음 항목을 반환
}

DinerMenuIterator 클래스는 Iterator 인터페이스를 구현하며, DinerMenu의 배열을 순회하는 역할을 합니다.

public class DinerMenuIterator implements Iterator {
    MenuItem[] items;  // 메뉴 항목 배열
    int position = 0;  // 현재 반복 작업의 위치

    public DinerMenuIterator(MenuItem[] items) {
        this.items = items;
    }

    // 다음 항목을 반환하고, position을 증가시킴
    public MenuItem next() {
        MenuItem menuItem = items[position];
        position = position + 1;
        return menuItem;
    }

    // 배열에 더 이상 항목이 없거나, null을 만나면 false 반환
    public boolean hasNext() {
        if (position >= items.length || items[position] == null) {
            return false;
        } else {
            return true;
        }
    }
}

DinerMenu 클래스에서 반복자를 사용해봅니다.

public class DinerMenu {
    static final int MAX_ITEMS = 6;  // 메뉴의 최대 항목 수
    int numberOfItems = 0;           // 현재 메뉴 항목 수
    MenuItem[] menuItems;            // 메뉴 항목 배열

    public DinerMenu() {
        menuItems = new MenuItem[MAX_ITEMS];
        addItem("채식주의자용 BLT", "통밀 위에 콩고기 베이컨, 상추, 토마토를 얹은 메뉴", true, 2.99);
        addItem("BLT", "통밀 위에 베이컨, 상추, 토마토를 얹은 메뉴", false, 2.99);
        addItem("오늘의 스프", "감자 샐러드를 곁들인 오늘의 스프", false, 3.29);
        addItem("핫도그", "사워크라우트, 갖은 양념, 양파, 치즈가 곁들여진 핫도그", false, 3.05);
        // 기타 메뉴 추가
    }

    public void addItem(String name, String description, boolean vegetarian, double price) {
        MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
        if (numberOfItems >= MAX_ITEMS) {
            System.err.println("죄송합니다, 메뉴가 꽉 찼습니다. 더 이상 추가할 수 없습니다.");
        } else {
            menuItems[numberOfItems] = menuItem;
            numberOfItems++;
        }
    }

    // DinerMenuIterator를 생성하고 반환
    public Iterator createIterator() {
        return new DinerMenuIterator(menuItems);
    }
}

PancakeHouseMenu에도 반복자를 적용해보겠습니다.

PancakeHouseMenu는 ArrayList를 사용하기 때문에, 기본적으로 제공되는 Iterator를 사용할 수 있습니다. 여기에도 동일하게 createIterator() 메서드를 추가합니다.

public class PancakeHouseMenu {
    List<MenuItem> menuItems;

    public PancakeHouseMenu() {
        menuItems = new ArrayList<>();
        addItem("K&B 팬케이크 세트", "스크램블 에그와 토스트가 곁들여진 팬케이크", false, 2.99);
        addItem("레귤러 팬케이크 세트", "달걀 프라이와 소시지가 곁들여진 팬케이크", false, 2.99);
        addItem("블루베리 팬케이크", "신선한 블루베리와 블루베리 시럽으로 만든 팬케이크", true, 3.49);
        addItem("와플", "취향에 따라 블루베리나 딸기를 얹을 수 있는 와플", true, 3.59);
    }

    public void addItem(String name, String description, boolean vegetarian, double price) {
        MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
        menuItems.add(menuItem);
    }

    // ArrayList의 기본 Iterator 반환
    public Iterator<MenuItem> createIterator() {
        return menuItems.iterator();
    }
}

이제 종업원 코드에 반복자를 적용해보겠습니다.

public class Waitress {
    PancakeHouseMenu pancakeHouseMenu;
    DinerMenu dinerMenu;

    public Waitress(PancakeHouseMenu pancakeHouseMenu, DinerMenu dinerMenu) {
        this.pancakeHouseMenu = pancakeHouseMenu;
        this.dinerMenu = dinerMenu;
    }

    public void printMenu() {
        Iterator<MenuItem> pancakeIterator = pancakeHouseMenu.createIterator();
        Iterator<MenuItem> dinerIterator = dinerMenu.createIterator();

        System.out.println("아침 메뉴:");
        printMenu(pancakeIterator);

        System.out.println("점심 메뉴:");
        printMenu(dinerIterator);
    }

    private void printMenu(Iterator<MenuItem> iterator) {
        while (iterator.hasNext()) {
            MenuItem menuItem = iterator.next();
            System.out.print(menuItem.getName() + " ");
            System.out.println(menuItem.getPrice() + " ");
            System.out.println(menuItem.getDescription());
        }
    }
}

main 실행 코드를 보겠습니다.

public class MenuTestDrive {
    public static void main(String args[]) {
        // 메뉴 생성
        PancakeHouseMenu pancakeHouseMenu = new PancakeHouseMenu();
        DinerMenu dinerMenu = new DinerMenu();

        // 종업원 생성 (두 메뉴를 인자로 전달)
        Waitress waitress = new Waitress(pancakeHouseMenu, dinerMenu);

        // 메뉴 출력
        waitress.printMenu();
    }
}

5. 반복자 패턴의 특징 알아보기

두 식당 모두 원래의 코드를 활용할 수 있게 되었습니다.

관리하기 힘든 종업원 코드	Iterator가 장착된 신형 종업원 코드
메뉴가 캡슐화되어 있지 않아서 각 식당에서 어떤 자료구조를 썼는지 알 수 있습니다.	메뉴 구현법이 캡슐화되어 있어서 종업원은 메뉴에서 메뉴 항목의 컬렉션을 어떤 식으로 저장하는지 알 수 없습니다.
MenuItems로 반복 작업을 하려면 2개의 순환문이 필요합니다.	반복자만 구현하면 다형성을 활용해서 어떤 컬렉션이든 1개의 순환문으로 처리할 수 있습니다.
종업원이 구상 클래스(MenuItem[], ArrayList)에 직접 연결되어 있습니다.	종업원은 인터페이스(반복자)만 알면 됩니다.
유사한 인터페이스를 가졌음에도 2개의 서로 다른 구상 메뉴 클래스에 묶여 있습니다.	Menu 인터페이스가 약간 다르지만, 통일시킬 수 있습니다.

6. 인터페이스 개선하기

PancakeHouseMenu와 DinerMenu에서 사용하는 반복자 인터페이스를 자바의 기본 java.util.Iterator 인터페이스로 통일하고, 기존에 만든 반복자 인터페이스를 대체하여 코드를 개선해봅시다.

1. PancakeHouseMenu와 DinerMenu가 공통으로 사용하는 Menu 인터페이스는 자바의 Iterator를 반환하도록 수정합니다.

import java.util.Iterator;

public interface Menu {
    Iterator<MenuItem> createIterator();  // 자바의 Iterator 인터페이스 사용
}

2. DinerMenuIterator 클래스는 자바의 Iterator 인터페이스를 구현하여 배열을 순회합니다.

import java.util.Iterator;

// 자바의 Iterator 인터페이스를 구현
public class DinerMenuIterator implements Iterator<MenuItem> {
    MenuItem[] items;
    int position = 0;

    public DinerMenuIterator(MenuItem[] items) {
        this.items = items;
    }

    // 배열에 다음 항목이 있는지 확인
    @Override
    public boolean hasNext() {
        return position < items.length && items[position] != null;
    }

    // 배열의 다음 항목 반환
    @Override
    public MenuItem next() {
        MenuItem menuItem = items[position];
        position++;
        return menuItem;
    }

    // remove()는 지원하지 않음
    @Override
    public void remove() {
        throw new UnsupportedOperationException("remove()는 지원되지 않습니다.");
    }
}

3. 이제 Waitress 클래스는 PancakeHouseMenu와 DinerMenu의 구체적인 클래스에 의존하지 않고, Menu 인터페이스에 의존하게 됩니다. => "구현보다는 인터페이스에 맞춰서 프로그래밍한다."

따라서 더 유연하게 작동하며, 두 메뉴를 같은 방식으로 처리할 수 있습니다.

import java.util.Iterator;

public class Waitress {
    Menu pancakeHouseMenu;
    Menu dinerMenu;

    public Waitress(Menu pancakeHouseMenu, Menu dinerMenu) {
        this.pancakeHouseMenu = pancakeHouseMenu;
        this.dinerMenu = dinerMenu;
    }

    public void printMenu() {
        Iterator<MenuItem> pancakeIterator = pancakeHouseMenu.createIterator();
        Iterator<MenuItem> dinerIterator = dinerMenu.createIterator();

        System.out.println("아침 메뉴:");
        printMenu(pancakeIterator);
        System.out.println("\n점심 메뉴:");
        printMenu(dinerIterator);
    }

    private void printMenu(Iterator<MenuItem> iterator) {
        while (iterator.hasNext()) {
            MenuItem menuItem = iterator.next();
            System.out.print(menuItem.getName() + ", ");
            System.out.print(menuItem.getPrice() + " -- ");
            System.out.println(menuItem.getDescription());
        }
    }
}

7. 반복자 패턴의 정의

반복자 패턴(Iterator Pattern)은 컬렉션의 구현 방법을 노출하지 않으면서
집합체 내의 모든 항목에 접근하는 방법을 제공합니다.

반복자(Iterator) 패턴의 클래스 다이어그램이 유사한 패턴은 바로 팩토리 메서드(Factory Method) 패턴입니다.

팩토리 메서드 패턴과 반복자 패턴의 유사점:

역할 분리: 두 패턴 모두 구체적인 구현을 캡슐화하고, 클라이언트가 세부 사항을 알 필요 없이 추상화를 통해 작업을 처리합니다.
인터페이스를 통해 객체 생성: 팩토리 메서드 패턴에서는 객체 생성을 서브클래스에서 결정하고, 반복자 패턴에서는 컬렉션의 세부 구현을 캡슐화하여 Iterator를 통해 항목을 순회합니다.

팩토리 메서드 패턴:

팩토리 메서드 패턴은 객체 생성을 서브클래스가 결정하도록 하여, 상위 클래스에서는 구체적인 객체 생성에 의존하지 않도록 합니다. 즉, 객체의 생성을 캡슐화하는 패턴입니다.

예시: 팩토리 메서드 패턴에서 상위 클래스는 특정 인터페이스나 추상 클래스를 통해 객체를 생성하지만, 구체적으로 어떤 객체가 생성될지는 서브클래스에서 정의합니다. 이 방식은 반복자 패턴에서 Iterator를 생성하는 과정과 유사합니다.

반복자 패턴:

반복자 패턴은 컬렉션의 내부 구조를 숨기고, 객체의 순회를 Iterator를 통해 처리하도록 캡슐화합니다. createIterator() 메서드를 통해 Iterator 객체를 반환하는 방식이, 팩토리 메서드 패턴의 객체 생성 방식과 유사합니다.

유사점 정리:

추상화된 객체 생성:
- 팩토리 메서드 패턴: 객체 생성 방식을 서브클래스가 결정하며, 클라이언트는 추상화된 인터페이스를 통해 객체를 생성합니다.
- 반복자 패턴: 컬렉션의 세부 구조에 관계없이 Iterator를 통해 객체를 순회합니다.
캡슐화:
- 팩토리 메서드 패턴: 객체 생성 과정을 캡슐화하여 클라이언트가 구체적인 클래스에 의존하지 않게 만듭니다.
- 반복자 패턴: 컬렉션 내부 구조를 숨기고, Iterator를 통해 항목을 캡슐화된 방식으로 처리합니다.

8. 단일 역할 원칙

디자인 원칙 - 어떤 클래스가 바뀌는 이유는 하나뿐이어야 한다.

집합체에서 컬렉션 관련 기능과 반복자용 메소드 관련 기능을 전부 구현하면 2가지 이유로 그 클래스가 바뀔 수 있습니다.

클래스를 고치는 일은 최대한 피해야하기 때문에 컬렉션 관리와 반복자 생성 기능을 각각 다른 클래스로 분리하여, 각 클래스가 하나의 책임만 갖도록 설계해야 합니다.

9. Iterable 인터페이스 알아보기

자바의 모든 컬렉션 유형에서 Iterable 인터페이스를 구현합니다.

Iterable 인터페이스에는 Iterator 인터페이스를 구현하는, 반복자를 리턴하는 iterator() 메소드가 들어있습니다.

어떤 클래스에서 Iterable을 구현한다면 그 클래스는 Iterator() 메소드를 구현해야합니다.

Iterator() 메소드는 Iterator 객체를 반환합니다.이 객체는 hasNext(), next() 메서드를 제공하며, 컬렉션 내의 요소를 순회할 수 있게 합니다.

또한 Iterable 인터페이스에는 컬렉션에 있는 항목을 대상으로 반복 작업을 수행하는 forEach() 메소드가 기본으로 포함됩니다.

그 외에도 JAVA는 향상된 for 순환문으로 몇 가지 편리한 문법적 기능을 제공합니다.

기존 방식

List<MenuItem> menuItems = new ArrayList<>();
// 메뉴 항목을 추가했다고 가정
menuItems.add(new MenuItem("팬케이크", "버터와 시럽이 함께 제공", false, 2.99));

// 기존 방식: 반복자를 사용한 컬렉션 순회
Iterator<MenuItem> iterator = menuItems.iterator();
while (iterator.hasNext()) {
    MenuItem menuItem = iterator.next();
    System.out.print(menuItem.getName() + ", ");
    System.out.print(menuItem.getPrice() + " — ");
    System.out.println(menuItem.getDescription());
}

향상된 for 순환문 적용 방식

List<MenuItem> menuItems = new ArrayList<>();
// 메뉴 항목을 추가했다고 가정
menuItems.add(new MenuItem("팬케이크", "버터와 시럽이 함께 제공", false, 2.99));

// 향상된 for 루프를 사용한 컬렉션 순회
for (MenuItem menuItem : menuItems) {
    System.out.print(menuItem.getName() + ", ");
    System.out.print(menuItem.getPrice() + " — ");
    System.out.println(menuItem.getDescription());
}

향상된 for 문을 사용할 때 주의사항이 있습니다. 배열은 Iterable이 아닙니다.

팬케이크하우스에서는 Iterator 대신 Iterable을 받고, for-each 순환문을 쓰도록 종업원 코드의 printMenu() 메소드를 고쳐봅니다.

public void printMenu(Iterable<MenuItem> iterable) {
        for (MenuItem menuItem : iterable) {
            System.out.print(menuItem.getName() + ", ");
            System.out.print(menuItem.getPrice() + " — ");
            System.out.println(menuItem.getDescription());
        }
    }
    
printMenu(lunchItems)； // 오류 발생

배열은 Iterable이 아니기 때문에 오류가 발생합니다.

따라서 일단은 두 식당에 향상된 for문을 모두 적용하지 않고, 기존 방식으로 둡니다.

10. 객체마을 카페 메뉴 살펴보기

public class CafeMenu {
    // HashMap을 사용하여 메뉴 항목을 저장 (키: 메뉴 이름, 값: MenuItem 객체)
    Map<String, MenuItem> menuItems = new HashMap<>();

    // 생성자: 초기 메뉴 항목 추가
    public CafeMenu() {
        addItem("베지 버거와 에어 프라이", "통밀빵, 상추, 토마토, 감자 튀김이 첨가된 베지 버거", true, 3.99);
        addItem("오늘의 스프", "샐러드가 곁들여진 오늘의 스프", false, 3.69);
        addItem("부리토", "통 핀토콩과 살사, 구아카몰이 곁들여진 푸짐한 부리토", true, 4.29);
    }

    // 메뉴 항목을 HashMap에 추가하는 메서드
    public void addItem(String name, String description, boolean vegetarian, double price) {
        MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
        menuItems.put(name, menuItem);  // 이름을 키로, MenuItem 객체를 값으로 저장
    }

    // 메뉴 항목 전체를 반환하는 메서드 (여기서는 Map 전체를 반환)
    public Map<String, MenuItem> getMenuItems() {
        return menuItems;
    }
}

Hashtable도 Iterable을 지원하는 자바 컬렉션이지만, ArrayList와는 조금 다릅니다.

public class CafeMenu implements Menu {
    // 메뉴 항목을 저장하는 HashMap (키: 메뉴 이름, 값: MenuItem 객체)
    Map<String, MenuItem> menuItems = new HashMap<>();

    // 생성자: 메뉴 항목 추가
    public CafeMenu() {
        addItem("베지 버거와 에어 프라이", "통밀빵, 상추, 토마토, 감자 튀김이 첨가된 베지 버거", true, 3.99);
        addItem("오늘의 스프", "샐러드가 곁들여진 오늘의 스프", false, 3.69);
        addItem("부리토", "통 핀토콩과 살사, 구아카몰이 곁들여진 푸짐한 부리토", true, 4.29);
    }

    // 메뉴 항목을 HashMap에 추가하는 메서드
    public void addItem(String name, String description, boolean vegetarian, double price) {
        MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
        menuItems.put(name, menuItem);  // HashMap에 메뉴 항목 저장
    }

    // HashMap에서 메뉴 항목에 대한 Iterator를 반환
    @Override
    public Iterator<MenuItem> createIterator() {
        return menuItems.values().iterator();  // 값들에 대한 Iterator 반환
    }
}

종업원 코드에 카페 메뉴를 추가해보겠습니다.

import java.util.Iterator;

public class Waitress {
    Menu pancakeHouseMenu;
    Menu dinerMenu;
    Menu cafeMenu; // 추가된 곳

    // 생성자: 각 메뉴 객체를 인자로 받아 인스턴스 변수로 저장
    public Waitress(Menu pancakeHouseMenu, Menu dinerMenu, Menu cafeMenu) {
        this.pancakeHouseMenu = pancakeHouseMenu;
        this.dinerMenu = dinerMenu;
        this.cafeMenu = cafeMenu; // 추가된 곳
    }

    // 전체 메뉴 출력
    public void printMenu() {
        // 각 메뉴의 반복자(Iterator)를 가져옴
        Iterator<MenuItem> pancakeIterator = pancakeHouseMenu.createIterator();
        Iterator<MenuItem> dinerIterator = dinerMenu.createIterator();
        Iterator<MenuItem> cafeIterator = cafeMenu.createIterator(); // 추가된 곳

        // 각 메뉴 출력
        System.out.println("메뉴\n---\n아침 메뉴:");
        printMenu(pancakeIterator);

        System.out.println("\n점심 메뉴:");
        printMenu(dinerIterator);

        System.out.println("\n저녁 메뉴:"); // 추가된 곳
        printMenu(cafeIterator);
    }

    // 개별 메뉴 항목을 출력하는 메서드 => 이 부분은 전혀 바뀔 것이 없음
    private void printMenu(Iterator<MenuItem> iterator) {
        while (iterator.hasNext()) {
            MenuItem menuItem = iterator.next();  // 다음 메뉴 항목을 가져옴
            System.out.print(menuItem.getName() + ", ");
            System.out.print(menuItem.getPrice() + " — ");
            System.out.println(menuItem.getDescription());
        }
    }
}

테스트용 코드

public class MenuTestDrive {
    public static void main(String args[]) {
        // 각 메뉴 객체 생성
        PancakeHouseMenu pancakeHouseMenu = new PancakeHouseMenu();
        DinerMenu dinerMenu = new DinerMenu();
        CafeMenu cafeMenu = new CafeMenu();

        // Waitress 생성 시, PancakeHouseMenu, DinerMenu, CafeMenu를 전달
        Waitress waitress = new Waitress(pancakeHouseMenu, dinerMenu, cafeMenu);

        // 3가지 메뉴 모두 출력
        waitress.printMenu();
    }
}

11. 종업원 코드 개선하기

현재, 종업원 코드 printMenu() 메서드에서 printMenu를 3번 호출하고 있습니다.

즉, 새로운 메뉴가 추가될 때마다 printMenu() 메서드를 수정해야 합니다. 이는 **OCP(Open Closed Principle, 개방-폐쇄 원칙)**을 위배하고 있습니다.

이 문제를 해결하기 위해 여러 메뉴를 한꺼번에 관리할 수 있는 방식이 필요합니다.

여러 메뉴를 하나의 컬렉션이나 자료구조에 담아 관리하고, 이를 순차적으로 순회하면서 출력하는 방식으로 개선할 수 있습니다.

import java.util.Iterator;
import java.util.List;
import java.util.ArrayList;

public class Waitress {
    List<Menu> menus;

    // 여러 메뉴를 리스트로 받아서 관리
    public Waitress(List<Menu> menus) {
        this.menus = menus;
    }

    // 모든 메뉴를 출력하는 메서드
    public void printMenu() {
        for (Menu menu : menus) {
            printMenu(menu.createIterator());
        }
    }

    private void printMenu(Iterator<MenuItem> iterator) {
        while (iterator.hasNext()) {
            MenuItem menuItem = iterator.next();
            System.out.println(menuItem.getName() + ", " + menuItem.getPrice() + " -- " + menuItem.getDescription());
        }
    }
}

Menu 객체들을 List<Menu>와 같은 컬렉션에 담아 관리하면, 새로운 메뉴가 추가되더라도 Waitress 클래스는 수정할 필요가 없습니다. 컬렉션에 메뉴를 추가하기만 하면 되므로 OCP 원칙을 지킬 수 있습니다.

그런데, 디저트 메뉴를 특정 메뉴의 서브 메뉴로 넣어달라는 요청이 들어왔습니다.

디저트 메뉴를 DinerMenu 컬렉션의 원소로 넣을 수 있으면 좋겠지만, 현재 코드로는 그럴 수 없습니다.

이를 개선하기 위해서는 아래 작업이 필요합니다.

트리 구조 필요: 메뉴, 서브메뉴, 메뉴 항목을 모두 포함할 수 있는 트리 구조를 만들어야 합니다.
편리한 작업 수행: 각 메뉴의 모든 항목을 대상으로 반복자처럼 편리하게 작업을 수행할 수 있어야 합니다.
유연한 반복 작업: 특정 서브메뉴나 항목만 대상으로 작업할 수 있으면서도, 전체 메뉴를 대상으로 반복 작업을 할 수 있는 유연성을 제공해야 합니다.

12. 컴포지트 패턴

컴포지트 패턴
객체를 트리구조로 구성해서 부분-전체 계층구조를 구현합니다.
컴포지트 패턴을 사용하면 클라이언트에서 개별 객체와 복합 객체를 똑같은 방법으로 다룰 수 있습니다.

Composite 패턴 사용: 메뉴 관리에 반복자 패턴만으로는 부족하므로, Composite 패턴을 적용하여 트리 구조를 구성하고, 부분-전체 계층 구조를 구현하기로 했습니다.
부분-전체 계층구조: 메뉴와 메뉴 항목을 같은 구조에 넣어, 부분(메뉴 및 항목)들이 계층을 이루면서도 전체로 다룰 수 있는 구조를 만듭니다.
동일한 방식으로 처리: Composite 패턴을 통해, 개별 객체와 복합 객체를 동일한 방식으로 처리할 수 있습니다.
트리 구조: 메뉴, 서브메뉴, 서브서브메뉴 등 중첩된 메뉴 구조를 트리로 구성하고, 간단한 코드를 반복 적용하여 전체 구조에 똑같이 작업을 수행할 수 있습니다.

13. 컴포지트 패턴으로 메뉴 디자인하기

컴포지트 패턴을 메뉴에 적용하기 위해 먼저 Menu(Composite)와 MenuItem(Leaf)에 공통적으로 적용되는 구성 요소 인터페이스를 만들어야 합니다.

이 인터페이스를 통해 Menu와 MenuItem을 동일한 방식으로 처리할 수 있으며, 같은 메소드를 호출할 수 있게 됩니다.

물론, MenuItem(Leaf)에는 적합하지 않은 메소드나 Menu(Composite)에 적합하지 않은 메소드도 있을 수 있지만, 이 문제는 나중에 해결할 것입니다.

우선은 컴포지트 패턴 구조에 Menu를 어떻게 맞출 수 있을지 고민하는 것이 중요합니다.

MenuComponent 추상 클래스는 메뉴 구성 요소로, 잎(개별 항목, Leaf)과 복합 객체(메뉴, Composite) 모두에 적용되는 역할을 합니다.

이 클래스는 각 구성 요소에 공통적으로 필요한 메소드를 정의하지만, 잎과 복합 객체가 모두 사용하지는 않는 메소드도 있습니다.

그런 메소드들은 기본적으로 UnsupportedOperationException 예외를 던지도록 설정하여, 필요한 곳에서만 메소드를 오버라이드해 사용할 수 있게 합니다

이로써 각 구성 요소가 자신에게 맞지 않는 메소드를 반드시 구현하지 않아도 됩니다.

public abstract class MenuComponent {

    // Composite 객체에 요소를 추가하는 메소드 (Menu에서는 사용, MenuItem에서는 사용 안 함)
    public void add(MenuComponent menuComponent) {
        throw new UnsupportedOperationException();
    }

    // Composite 객체에서 요소를 제거하는 메소드 (Menu에서는 사용, MenuItem에서는 사용 안 함)
    public void remove(MenuComponent menuComponent) {
        throw new UnsupportedOperationException();
    }

    // Composite 객체에서 하위 요소를 가져오는 메소드 (Menu에서는 사용, MenuItem에서는 사용 안 함)
    public MenuComponent getChild(int i) {
        throw new UnsupportedOperationException();
    }

    // 이름을 가져오는 메소드 (MenuItem에서는 사용, Menu에서는 사용 안 함)
    public String getName() {
        throw new UnsupportedOperationException();
    }

    // 설명을 가져오는 메소드 (MenuItem에서는 사용, Menu에서는 사용 안 함)
    public String getDescription() {
        throw new UnsupportedOperationException();
    }

    // 가격을 가져오는 메소드 (MenuItem에서는 사용, Menu에서는 사용 안 함)
    public double getPrice() {
        throw new UnsupportedOperationException();
    }

    // 채식 여부를 확인하는 메소드 (MenuItem에서는 사용, Menu에서는 사용 안 함)
    public boolean isVegetarian() {
        throw new UnsupportedOperationException();
    }

    // 모든 구성 요소를 출력하는 메소드 (Menu와 MenuItem 모두에서 오버라이드 가능)
    public void print() {
        throw new UnsupportedOperationException();
    }
}

MenuItem

public class MenuItem extends MenuComponent {
    String name;
    String description;
    boolean vegetarian;
    double price;

    // 생성자: 메뉴 항목의 이름, 설명, 채식 여부, 가격을 설정
    public MenuItem(String name, String description, boolean vegetarian, double price) {
        this.name = name;
        this.description = description;
        this.vegetarian = vegetarian;
        this.price = price;
    }

    // 메뉴 항목의 이름을 반환
    public String getName() {
        return name;
    }

    // 메뉴 항목의 설명을 반환
    public String getDescription() {
        return description;
    }

    // 메뉴 항목의 가격을 반환
    public double getPrice() {
        return price;
    }

    // 메뉴 항목이 채식주의자용인지 여부를 반환
    public boolean isVegetarian() {
        return vegetarian;
    }

    // 메뉴 항목의 내용을 출력하는 메소드
    public void print() {
        System.out.print("  " + getName());
        if (isVegetarian()) {
            System.out.print("(v)");
        }
        System.out.println(", " + getPrice());
        System.out.println("     -- " + getDescription());
    }
}

Menu

import java.util.ArrayList;
import java.util.List;

public class Menu extends MenuComponent {
    List<MenuComponent> menuComponents = new ArrayList<>();
    String name;
    String description;

    // 생성자: 메뉴의 이름과 설명을 설정
    public Menu(String name, String description) {
        this.name = name;
        this.description = description;
    }

    // 메뉴에 구성 요소를 추가하는 메소드
    public void add(MenuComponent menuComponent) {
        menuComponents.add(menuComponent);
    }

    // 메뉴에서 구성 요소를 제거하는 메소드
    public void remove(MenuComponent menuComponent) {
        menuComponents.remove(menuComponent);
    }

    // 특정 인덱스의 구성 요소를 반환하는 메소드
    public MenuComponent getChild(int i) {
        return menuComponents.get(i);
    }

    // 메뉴의 이름을 반환하는 메소드
    public String getName() {
        return name;
    }

    // 메뉴의 설명을 반환하는 메소드
    public String getDescription() {
        return description;
    }

    // 가격이나 채식 여부는 메뉴에는 적용되지 않으므로 기본적으로 예외를 던집니다.
    @Override
    public double getPrice() {
        throw new UnsupportedOperationException();
    }

    @Override
    public boolean isVegetarian() {
        throw new UnsupportedOperationException();
    }

    // 메뉴와 메뉴 항목을 출력하는 메소드
    public void print() {
        System.out.print("\n" + getName());
        System.out.println(", " + getDescription());
        System.out.println("---------------------");

        // 하위 구성 요소들도 출력
        for (MenuComponent menuComponent : menuComponents) {
            menuComponent.print();
        }
    }
}

Waitress

public class Waitress {
    MenuComponent allMenus;

    // 종업원은 최상위 메뉴 구성 요소를 전달받음
    public Waitress(MenuComponent allMenus) {
        this.allMenus = allMenus;
    }

    // 최상위 메뉴의 print() 메소드를 호출하여 전체 메뉴를 출력
    public void printMenu() {
        allMenus.print();
    }
}

Waitress 클래스에 컴포지트 패턴을 적용한 코드는 매우 간단하고 효율적입니다.

이제 종업원은 메뉴의 최상위 MenuComponent만 받으면 되고, 이를 통해 전체 메뉴와 서브메뉴를 한 번에 출력할 수 있습니다.

컴포지트 패턴 덕분에 종업원은 메뉴의 각 항목과 서브메뉴를 별도로 처리할 필요 없이, 일관된 방식으로 메뉴 구조를 출력할 수 있습니다.

메뉴 Test Code

public class MenuTestDrive {
    public static void main(String[] args) {
        // 각 메뉴 생성
        MenuComponent pancakeHouseMenu = new Menu("팬케이크 하우스 메뉴", "아침 메뉴");
        MenuComponent dinerMenu = new Menu("객체마을 식당 메뉴", "점심 메뉴");
        MenuComponent cafeMenu = new Menu("카페 메뉴", "저녁 메뉴");
        MenuComponent dessertMenu = new Menu("디저트 메뉴", "디저트를 즐겨 보세요");

        // 최상위 메뉴 생성
        MenuComponent allMenus = new Menu("전체 메뉴", "전체 메뉴");

        // 최상위 메뉴에 각 하위 메뉴 추가
        allMenus.add(pancakeHouseMenu);
        allMenus.add(dinerMenu);
        allMenus.add(cafeMenu);

        // DinerMenu에 메뉴 항목 추가
        dinerMenu.add(new MenuItem("파스타", "마리나라 소스 스파게티, 효모빵도 드립니다.", true, 3.89));

        // DinerMenu에 디저트 메뉴 추가
        dinerMenu.add(dessertMenu);

        // 디저트 메뉴에 메뉴 항목 추가
        dessertMenu.add(new MenuItem("애플 파이", "바삭바삭한 크러스트에 바닐라 아이스크림이 얹혀 있는 애플 파이", true, 1.59));

        // 종업원 생성
        Waitress waitress = new Waitress(allMenus);

        // 전체 메뉴 출력
        waitress.printMenu();
    }
}

결과

현재 컴포지트 패턴에서는 Leaf와 Composite 2개의 역할을 갖고 있습니다.

컴포지트 패턴은 단일 책임 원칙(SRP)을 일부 희생하고 투명성을 확보하는 패턴입니다.

Component 인터페이스에 자식 관리 기능과 잎의 기능을 모두 포함시켜, 클라이언트가 복합 객체와 잎을 동일한 방식으로 다룰 수 있게 합니다.

이로 인해 클라이언트가 객체의 내부 구조를 신경 쓰지 않아도 되지만, 안전성이 떨어질 수 있습니다.

즉, 부적절한 메소드 호출이 발생할 수 있으며, 이를 예외로 처리합니다. 결국, 투명성과 안전성 사이에서 균형을 맞추는 설계 결정이 필요합니다.

14. 컴포지트 패턴에서 추가로 고려할 점들

컴포지트 패턴에서 자식 객체가 부모의 레퍼런스를 가질 수 있습니다.

자식에게 부모의 포인터를 넣으면 트리 구조를 돌아다니기 편리해지며, 자식 객체를 삭제할 때 부모에게 직접 삭제 요청을 할 수 있어 관리가 더 쉬워집니다.

이는 복합 객체를 처리할 때 자주 사용하는 패턴 중 하나입니다. 하지만 몇 가지 더 고려해야 할 점이 있습니다.

추가로 고려할 점들:

자식의 순서: 복합 객체 내에서 자식들의 순서를 고려해야 할 때, 자식 추가와 삭제를 더 복잡하게 관리해야 할 수 있습니다. 예를 들어, 특정 순서대로 자식 노드를 저장하거나 순회할 필요가 있을 때는 순서 관리 로직을 추가해야 합니다.
캐시(Caching): 복합 구조가 커지면 자원 소모가 클 수 있습니다. 따라서 계산 결과를 캐싱하는 방법을 고려할 수 있습니다. 계산이나 복잡한 연산이 자주 반복되는 경우, 계산 결과를 캐시해 두면 성능을 향상시킬 수 있습니다.
계층구조 순회: 트리 구조를 순회할 때도 신중해야 합니다. 자식에게 부모의 레퍼런스를 넣으면 상향식 순회가 가능하지만, 무한 루프나 메모리 누수 같은 문제가 발생하지 않도록 주의해야 합니다.

컴포지트 패턴의 가장 큰 장점:

컴포지트 패턴의 가장 큰 장점은 클라이언트 코드의 단순화입니다. 클라이언트는 복합 객체와 잎 객체를 구분할 필요 없이 동일한 방식으로 다룰 수 있으며, 객체 구조를 신경 쓰지 않고 일관된 인터페이스를 통해 작업을 처리할 수 있습니다. 이를 통해 코드가 간결해지고, 유연성이 높아집니다.

컴포지트 패턴은 강력한 설계 패턴으로, 복잡한 객체들을 한 번에 관리할 수 있는 방법을 제공합니다. 하지만 그만큼 복잡성이 높아지므로, 효율적인 관리가 필요합니다.

FE 반복자, 컴포지트 패턴

반복자 패턴은 컬렉션에 있는 요소를 순차적으로 처리할 때 사용하며, React의 map() 함수와 같이 리스트를 렌더링할 때 유용하게 사용됩니다.
컴포짓 패턴은 트리 구조로 컴포넌트를 구성할 때 사용되며, React의 컴포넌트 트리 구조가 이를 잘 나타냅니다.

[개발서적] 헤드퍼스트 디자인 패턴 Ch8. 템플릿 메소드 패턴

SWKo — Fri, 30 Aug 2024 00:08:52 +0900

템플릿 메소드

템플릿 메소드는 알고리즘의 각 단계를 정의하며, 서브클래스에서 일부 단계를 구현할 수 있도록 유도합니다.

추상 클래스 - CaffeineBeverage

abstract class CaffeineBeverage {
    // 템플릿 메서드
    final void prepareRecipe() {
        boilWater();
        brew();
        pourInCup();
        if (customerWantsCondiments()) {
            addCondiments();
        }
    }

    abstract void brew();

    abstract void addCondiments();

    void boilWater() {
        System.out.println("물을 끓이는 중");
    }

    void pourInCup() {
        System.out.println("컵에 따르는 중");
    }

    // Hook - 서브클래스에서 필요시 오버라이드
    boolean customerWantsCondiments() {
        return true;
    }
}

Coffee 클래스

import java.util.Scanner;

public class Coffee extends CaffeineBeverage {

    @Override
    void brew() {
        System.out.println("필터를 통해 커피를 우려내는 중");
    }

    @Override
    void addCondiments() {
        System.out.println("설탕과 우유를 추가하는 중");
    }

    @Override
    boolean customerWantsCondiments() {
        String answer = getUserInput("커피에 설탕과 우유를 넣어 드릴까요? (y/n): ");
        return answer.toLowerCase().startsWith("y");
    }

    private String getUserInput(String prompt) {
        System.out.print(prompt);
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        return input;
    }
}

Tea 클래스

import java.util.Scanner;

public class Tea extends CaffeineBeverage {

    @Override
    void brew() {
        System.out.println("찻잎을 우려내는 중");
    }

    @Override
    void addCondiments() {
        System.out.println("레몬을 추가하는 중");
    }

    @Override
    boolean customerWantsCondiments() {
        String answer = getUserInput("차에 레몬을 넣어 드릴까요? (y/n): ");
        return answer.toLowerCase().startsWith("y");
    }

    private String getUserInput(String prompt) {
        System.out.print(prompt);
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        return input;
    }
}

메인 클래스

public class BeverageTestDrive {
    public static void main(String[] args) {
        CaffeineBeverage tea = new Tea();
        CaffeineBeverage coffee = new Coffee();

        System.out.println("\n차 준비 중:");
        tea.prepareRecipe();

        System.out.println("\n커피 준비 중:");
        coffee.prepareRecipe();
    }
}

CaffeineBeverage 클래스:
- prepareRecipe() 메서드는 알고리즘의 골격을 정의하는 템플릿 메서드입니다. 이 메서드는 final로 선언되어 서브클래스에서 오버라이드할 수 없습니다.
- brew()와 addCondiments()는 추상 메서드로, 서브클래스에서 구체적으로 구현해야 합니다.
- customerWantsCondiments()는 후크(Hook) 메서드로, 기본적으로 true를 반환하며, 서브클래스에서 오버라이드하여 사용자의 입력에 따라 다른 행동을 하도록 할 수 있습니다. 후크(Hook)는 추상 클래스에서 선언되지만 기본적인 내용만 구현되어 있거나 아무 코드도 들어있지 않은 메소드입니다. 이러면 서브클래스는 다양한 위치에서 알고리즘에 끼어들 수 있습니다.
Coffee 클래스:
- brew() 메서드에서는 커피를 우려내는 과정을 정의합니다.
- addCondiments() 메서드에서는 설탕과 우유를 추가하는 과정을 정의합니다.
- customerWantsCondiments() 후크 메서드를 오버라이드하여, 사용자가 설탕과 우유를 원하는지 물어보고 그에 따라 행동을 결정합니다.
Tea 클래스:
- brew() 메서드에서는 차를 우려내는 과정을 정의합니다.
- addCondiments() 메서드에서는 레몬을 추가하는 과정을 정의합니다.
- customerWantsCondiments() 후크 메서드를 오버라이드하여, 사용자가 레몬을 원하는지 물어보고 그에 따라 행동을 결정합니다.
BeverageTestDrive 클래스:
- Tea와 Coffee 객체를 생성하고, 각각의 prepareRecipe() 메서드를 호출하여 음료를 준비하는 전체 과정을 실행합니다.

템플릿 메서드 패턴은 알고리즘의 뼈대를 정의하고, 일부 단계를 서브클래스에서 재정의할 수 있게 하는 패턴입니다. 이 패턴을 통해 코드를 재사용하고, 알고리즘의 구조를 변경하지 않으면서 세부 구현을 다르게 할 수 있습니다.

주요 개념

템플릿 메서드(Template Method):
- 상위 클래스에 정의된 메서드로, 알고리즘의 전체 구조를 결정합니다.
- 이 메서드는 일련의 단계로 이루어져 있으며, 각 단계는 메서드 호출로 표현됩니다.
- 일부 단계는 서브클래스에서 구현해야 하는 추상 메서드로 정의됩니다.
추상 메서드(Abstract Method):
- 템플릿 메서드 내에서 호출되며, 서브클래스에서 구체적으로 구현해야 합니다.
- 예: brew()와 addCondiments() 메서드는 서브클래스에서 구체적으로 정의해야 하는 단계입니다.
후크(Hook):
- 후크는 선택적으로 오버라이드할 수 있는 메서드입니다. 기본 구현을 제공하지만, 서브클래스에서 필요에 따라 변경할 수 있습니다.
- 후크를 통해 알고리즘의 특정 단계를 실행할지 말지를 결정하거나, 기본 동작을 변경할 수 있습니다.
- 예: customerWantsCondiments()는 후크로 사용자가 추가 재료를 원하는지 여부를 확인할 수 있게 합니다.
상속을 통한 확장:
- 템플릿 메서드 패턴은 상속을 통해 기능을 확장합니다. 상위 클래스에 정의된 템플릿 메서드를 그대로 사용하면서, 하위 클래스에서 구체적인 동작을 변경할 수 있습니다.

템플릿 메서드 패턴의 장점

코드 재사용성: 알고리즘의 공통 부분을 상위 클래스에서 정의하여 코드 중복을 줄일 수 있습니다.
알고리즘의 안정성 유지: 템플릿 메서드는 상위 클래스에서 정의되어 알고리즘의 기본 구조를 변경하지 않으면서, 서브클래스에서 세부 구현을 다르게 할 수 있습니다.
유연성: 후크 메서드를 통해 서브클래스에서 알고리즘의 동작을 필요에 따라 변경할 수 있습니다.
확장성: 새로운 서브클래스를 추가함으로써 알고리즘의 새로운 변형을 쉽게 구현할 수 있습니다.

템플릿 메서드 패턴 사용 시 고려 사항

상속을 통한 확장이라는 구조적 특성 때문에 모든 서브클래스가 상위 클래스의 알고리즘에 의존하게 됩니다. 따라서 상위 클래스의 변경이 서브클래스에 영향을 미칠 수 있습니다.
후크 메서드를 제공함으로써 알고리즘의 유연성을 높일 수 있지만, 후크 메서드를 너무 많이 제공하면 서브클래스의 복잡성이 증가할 수 있습니다.

템플릿 메서드 패턴은 알고리즘의 핵심 구조를 보호하면서도 확장 가능하게 유지할 수 있는 강력한 디자인 패턴입니다.

[개발서적] 헤드퍼스트 디자인 패턴 Ch7. 어댑터 패턴과 퍼사드 패턴

SWKo — Thu, 29 Aug 2024 20:20:31 +0900

1. 객체지향 어댑터

어댑터는 클라이언트로부터 요청을 받아서 새로운 업체에서 제공하는 클래스를 클라이언트가 받아들일 수 있는 형태의 요청으로 변환해주는 중개인 역할을 합니다.

Duck과 Turkey 예시를 보겠습니다.

public interface Duck {
    void quack();
    void fly();
}

public interface Turkey {
    void gobble();
    void fly();
}

public class TurkeyAdapter implements Duck {
    Turkey turkey;

    public TurkeyAdapter(Turkey turkey) {
        this.turkey = turkey;
    }

    @Override
    public void quack() {
        turkey.gobble();  // 터키의 골골거리는 소리를 꽥꽥거리는 소리로 대체
    }

    @Override
    public void fly() {
        for (int i = 0; i < 5; i++) {  // 터키는 짧게 날기 때문에 5번 반복하여 날도록 한다
            turkey.fly();
        }
    }
}

이제 클라이언트 코드에서는 Turkey 객체를 Duck 인터페이스로 사용하여 다음과 같이 호출할 수 있습니다.

public class DuckTestDrive {
    public static void main(String[] args) {
        MallardDuck duck = new MallardDuck();

        WildTurkey turkey = new WildTurkey();
        Duck turkeyAdapter = new TurkeyAdapter(turkey);

        System.out.println("The Turkey says...");
        turkey.gobble();
        turkey.fly();

        System.out.println("\nThe Duck says...");
        testDuck(duck);

        System.out.println("\nThe TurkeyAdapter says...");
        testDuck(turkeyAdapter);
    }

    static void testDuck(Duck duck) {
        duck.quack();
        duck.fly();
    }
}

TurkeyAdapter 클래스는 Duck 인터페이스를 구현하고, 내부에 Turkey 객체를 가집니다.
TurkeyAdapter의 quack() 메서드는 Turkey 객체의 gobble() 메서드를 호출하여 꽥꽥 소리 대신 골골 소리를 냅니다.
TurkeyAdapter의 fly() 메서드는 터키가 짧게 날기 때문에, 이 동작을 여러 번 반복하여 Duck의 fly() 메서드를 흉내냅니다.
testDuck() 메서드는 Duck 인터페이스를 사용하여 객체를 테스트하며, 이 메서드를 통해 TurkeyAdapter도 Duck처럼 동작하게 됩니다.

어댑터 패턴을 사용하면 서로 다른 인터페이스를 가진 클래스들이 함께 동작하도록 할 수 있습니다.

이 예시에서는 Turkey를 Duck 인터페이스로 사용할 수 있게 하여 코드의 유연성을 높이고, 기존 코드를 변경하지 않고도 새로운 기능을 추가할 수 있음을 보여줍니다.

2. 어댑터 패턴 알아보기

- 타깃 인터페이스 : Duck

- 어뎁티 인터페이스 : Turkey

- TurckeyAdapter에서는 타깃 인터페이스인 Duck을 구현했습니다.

1. 클라이언트에서 타깃 인터페이스(Duck)로 메서드(fly, quack)를 호출해서 어댑터에 요청을 보냅니다.

2. 어댑터(TurkeyAdapter)는 어댑티 인터페이스(Turkey)로 그 요청을 어댑티에 관한 하나 이상의 메서드(gobble) 호출로 변환합니다

3. 클라이언트는 호출 결과를 받긴 하지만 중간에 어댑터(TurkeyAdapter)가 있다는 사실을 모릅니다.

3. 어댑터 패턴의 정의

어댑터 패턴은 특정 클래스 인터페이스를 클라이언트에서 요구하는 다른 인터페이스로 변환합니다.

인터페이스가 호환되지 않아 같이 쓸 수 없었던 클래스를 사용할 수 있게 도와줍니다.

4. 객체 어댑터와 클래스 어댑터

5. 실전 적용

어댑터 패턴에서 Enumeration과 Iterator가 자주 언급되는 이유는, 이 두 인터페이스의 역할과 변환이 어댑터 패턴의 전형적인 예이기 때문입니다. 이를 통해 어댑터 패턴이 어떻게 사용되는지 더 잘 이해할 수 있습니다.

Enumeration과 Iterator의 차이

Enumeration (Java 1.0):
- Enumeration은 Java의 초기 컬렉션 인터페이스입니다.
- 주요 메서드:
  - boolean hasMoreElements(): 더 가져올 요소가 있는지 확인합니다.
  - Object nextElement(): 다음 요소를 반환합니다.
- 사용법은 비교적 단순하지만, 유연성이 부족합니다. 예를 들어, 요소를 제거하는 기능이 없습니다.
Iterator (Java 1.2):
- Iterator는 Enumeration의 진화된 형태로, 컬렉션을 순회(iterate)하는 더 현대적이고 강력한 방법을 제공합니다.
- 주요 메서드:
  - boolean hasNext(): 다음 요소가 있는지 확인합니다.
  - Object next(): 다음 요소를 반환합니다.
  - void remove(): 현재 요소를 제거합니다.

어댑터 패턴의 적용

Java 컬렉션 프레임워크가 발전하면서, 기존에 Enumeration을 사용하는 코드를 Iterator를 사용하는 코드로 변경해야 하는 상황이 발생할 수 있습니다. 하지만, 이미 작성된 코드를 변경하는 대신, 어댑터 패턴을 활용해 Enumeration을 Iterator로 변환하는 방법을 사용할 수 있습니다.

import java.util.Enumeration;
import java.util.Iterator;

public class EnumerationIterator implements Iterator<Object> {
    Enumeration<?> enumeration;

    public EnumerationIterator(Enumeration<?> enumeration) {
        this.enumeration = enumeration;
    }

    @Override
    public boolean hasNext() {
        return enumeration.hasMoreElements();
    }

    @Override
    public Object next() {
        return enumeration.nextElement();
    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException("Remove not supported");
    }
}

어댑터 패턴의 동작

클라이언트 호출: 클라이언트는 Iterator 인터페이스를 기대하고 있습니다.
어댑터 역할: EnumerationIterator 어댑터는 Enumeration을 받아 Iterator로 변환합니다.
요청 변환: 클라이언트가 Iterator의 메서드(hasNext(), next())를 호출하면, 어댑터는 이 요청을 Enumeration의 메서드(hasMoreElements(), nextElement())로 변환하여 호출합니다.
결과 반환: 클라이언트는 Iterator를 사용하여 결과를 얻습니다. 이 과정에서 Enumeration이 실제로 사용되었지만, 클라이언트는 이를 알지 못합니다.

6. 퍼사드 패턴

홈시어터 퍼사드(Home Theater Facade)는 퍼사드(Facade) 패턴의 대표적인 예시 중 하나로, 복잡한 서브시스템들을 단순화하여 사용자가 쉽게 사용할 수 있도록 도와줍니다. 퍼사드 패턴은 여러 개의 클래스로 이루어진 복잡한 시스템에 단순한 인터페이스를 제공하는 구조적 디자인 패턴입니다.

홈시어터 퍼사드의 개념

현대적인 홈시어터 시스템은 여러 개의 서브시스템으로 구성되어 있습니다. 예를 들어:

TV 또는 프로젝터
DVD 플레이어 또는 블루레이 플레이어
사운드 시스템 (앰프, 스피커 등)
게임 콘솔
조명 시스템

이 각각의 장치는 고유한 기능과 인터페이스를 가지고 있으며, 사용자가 이를 모두 개별적으로 제어하려면 복잡한 절차가 필요합니다.

홈시어터 퍼사드 패턴의 역할

퍼사드 패턴을 적용하여 홈시어터 시스템을 설계하면, 복잡한 과정을 단순화할 수 있습니다. 홈시어터 퍼사드는 여러 서브시스템을 제어하기 위해 고안된 하나의 단순한 인터페이스를 제공합니다.

예를 들어, 사용자가 영화를 보고 싶을 때 다음과 같은 복잡한 과정을 거쳐야 할 수 있습니다:

TV 또는 프로젝터를 켜기
DVD 플레이어를 켜고, 디스크를 넣기
사운드 시스템을 켜고, 입력 소스를 DVD로 설정하기
조명을 어둡게 하기

퍼사드를 사용하면, 이러한 과정을 하나의 메서드 호출로 단순화할 수 있습니다.

public class HomeTheaterFacade {
    private Amplifier amp;
    private DvdPlayer dvd;
    private Projector projector;
    private Screen screen;
    private TheaterLights lights;
    private PopcornPopper popper;

    public HomeTheaterFacade(Amplifier amp, DvdPlayer dvd, Projector projector, Screen screen, TheaterLights lights, PopcornPopper popper) {
        this.amp = amp;
        this.dvd = dvd;
        this.projector = projector;
        this.screen = screen;
        this.lights = lights;
        this.popper = popper;
    }

    public void watchMovie(String movie) {
        System.out.println("Get ready to watch a movie...");
        popper.on();
        popper.pop();
        lights.dim(10);
        screen.down();
        projector.on();
        projector.wideScreenMode();
        amp.on();
        amp.setDvd(dvd);
        amp.setSurroundSound();
        amp.setVolume(5);
        dvd.on();
        dvd.play(movie);
    }

    public void endMovie() {
        System.out.println("Shutting movie theater down...");
        popper.off();
        lights.on();
        screen.up();
        projector.off();
        amp.off();
        dvd.stop();
        dvd.eject();
        dvd.off();
    }
}

홈시어터 퍼사드의 동작

watchMovie() 메서드: 이 메서드를 호출하면 퍼사드는 여러 서브시스템의 복잡한 상호작용을 처리하여, 사용자가 영화 시청을 준비하는 모든 단계를 수행합니다.
endMovie() 메서드: 이 메서드는 영화를 종료할 때 필요한 모든 단계를 자동으로 수행합니다.

public class HomeTheaterTestDrive {
    public static void main(String[] args) {
        // 홈시어터 서브시스템 객체들 생성
        Amplifier amp = new Amplifier("Top-O-Line Amplifier");
        Tuner tuner = new Tuner("Top-O-Line AM/FM Tuner", amp);
        DvdPlayer dvd = new DvdPlayer("Top-O-Line DVD Player", amp);
        CdPlayer cd = new CdPlayer("Top-O-Line CD Player", amp);
        Projector projector = new Projector("Top-O-Line Projector", dvd);
        TheaterLights lights = new TheaterLights("Theater Ceiling Lights");
        Screen screen = new Screen("Theater Screen");
        PopcornPopper popper = new PopcornPopper("Popcorn Popper");

        // 홈시어터 퍼사드 생성
        HomeTheaterFacade homeTheater = new HomeTheaterFacade(
                amp, dvd, projector, screen, lights, popper);

        // 영화를 보는 과정
        homeTheater.watchMovie("Raiders of the Lost Ark");

        // 영화를 종료하는 과정
        homeTheater.endMovie();
    }
}

7. 어댑터 패턴 vs 퍼사드 패턴

어댑터 패턴과 퍼사드 패턴은 둘 다 구조적 디자인 패턴으로, 기존 코드와의 인터페이스를 조정하거나 단순화하는 데 사용됩니다. 하지만 이 두 패턴은 서로 다른 목적과 상황에서 사용됩니다. 각각의 패턴의 차이점과 사용 목적을 비교해 보겠습니다.

1. 목적 (Purpose)

어댑터 패턴 (Adapter Pattern):
- 목적: 서로 호환되지 않는 인터페이스를 가진 클래스들이 함께 동작할 수 있도록 합니다.
- 상황: 기존의 클래스나 인터페이스를 수정할 수 없거나 수정하지 않고도 다른 인터페이스를 사용해야 할 때 사용됩니다.
- 사용 예시: Enumeration을 Iterator로 변환하거나, 서로 다른 API를 사용하여 동일한 기능을 수행해야 할 때.
퍼사드 패턴 (Facade Pattern):
- 목적: 복잡한 시스템의 인터페이스를 단순화하여, 서브시스템의 기능을 쉽게 사용할 수 있도록 합니다.
- 상황: 복잡한 서브시스템을 가진 라이브러리나 클래스들을 단순화된 인터페이스로 제공하여 사용 편의성을 높이고 싶을 때 사용됩니다.
- 사용 예시: 홈시어터 시스템의 여러 구성 요소를 간단한 인터페이스로 묶어 사용하거나, 복잡한 API를 쉽게 사용할 수 있게 하는 단순화된 클래스 제공.

2. 구조 (Structure)

어댑터 패턴:
- 어댑터 패턴은 두 개의 이미 존재하는 인터페이스를 연결합니다. 어댑터 클래스가 한 인터페이스를 구현하고, 내부적으로 다른 인터페이스를 사용하는 객체를 호출하여, 두 인터페이스 간의 호환성을 제공합니다.
- 예: TurkeyAdapter는 Duck 인터페이스를 구현하면서 Turkey 객체를 사용하여 quack()을 gobble()로 변환합니다.
퍼사드 패턴:
- 퍼사드 패턴은 복잡한 서브시스템을 단순화하기 위해 설계된 새로운 인터페이스를 제공합니다. 퍼사드는 여러 서브시스템에 대한 메서드 호출을 간단하게 조합하여 제공하는 하나의 간단한 인터페이스를 만듭니다.
- 예: HomeTheaterFacade는 여러 서브시스템(앰프, DVD 플레이어, 프로젝터 등)을 관리하여 watchMovie()와 같은 단순한 메서드로 복잡한 작업을 수행할 수 있게 합니다.

3. 사용 방법 (Usage)

어댑터 패턴:
- 어댑터 패턴은 기존 시스템에 새로운 기능이나 호환성을 추가해야 할 때 사용됩니다.
- 특정 인터페이스를 요구하는 클라이언트 코드가 기존 클래스와 호환되지 않을 때, 어댑터를 통해 그 차이를 메워줍니다.
퍼사드 패턴:
- 퍼사드 패턴은 복잡한 시스템의 사용을 단순화하고자 할 때 사용됩니다.
- 복잡한 API나 서브시스템을 사용하는 대신, 퍼사드를 통해 간단한 명령으로 여러 작업을 수행할 수 있습니다.

4. 클라이언트의 인식 (Client Awareness)

어댑터 패턴:
- 클라이언트는 어댑터가 사용된다는 것을 알고 있습니다. 클라이언트는 어댑터를 통해 요청을 보내며, 어댑터가 요청을 변환하여 실제 작업을 수행합니다.
퍼사드 패턴:
- 클라이언트는 퍼사드의 내부 작동 방식에 대해 알 필요가 없습니다. 클라이언트는 단순히 퍼사드를 사용하여 복잡한 작업을 간편하게 수행할 수 있으며, 퍼사드가 내부적으로 어떻게 서브시스템을 제어하는지는 알지 못합니다.

5. 유사점과 차이점

유사점:
- 둘 다 구조적 패턴으로, 복잡한 시스템과의 상호작용을 단순화합니다.
- 둘 다 클라이언트가 더 쉽게 특정 기능을 사용할 수 있도록 돕습니다.
차이점:
- 어댑터는 기존의 두 개의 호환되지 않는 인터페이스를 연결하는 반면, 퍼사드는 복잡한 서브시스템에 대한 단순화된 인터페이스를 제공하는 데 중점을 둡니다.
- 어댑터 패턴은 주로 호환성 문제를 해결하고, 퍼사드 패턴은 복잡성 문제를 해결합니다.

결론

어댑터 패턴과 퍼사드 패턴은 각각의 상황에 맞게 선택해야 합니다. 어댑터 패턴은 인터페이스의 불일치를 해결하는 데 사용하고, 퍼사드 패턴은 복잡한 시스템을 단순화하는 데 사용됩니다. 둘 다 코드의 재사용성과 유지 보수성을 높이지만, 사용 목적과 방식이 다르기 때문에 각 패턴의 장단점을 이해하고 적절히 활용하는 것이 중요합니다.

8. 최소 지식 원칙

최소 지식 원칙(Principle of Least Knowledge)에 따르면 객체 사이의 상호작용은 될 수 있으면 아주 가까운 '친구' 사이에만 허용하는 편이 좋습니다.

진짜 절친에게만 이야기해야 한다.

이 원칙을 잘 따르면 여러 클래스가 복잡하게 얽혀 있어서, 시스템의 한 부분을 변경했을 때 다른 부분까지 줄줄이 고쳐야 하는 상황을 방지할 수 있습니다.

FE 에서 사용되는 어댑터 패턴

예제 1

https://velog.io/@superlipbalm/how-i-use-adapter-pattern-in-reactjs

(번역) 리액트에서 어댑터(Adapter) 패턴을 사용하는 방법

프론트엔드와 백엔드 사이의 개발은 별도로 진행됩니다. 따라서 데이터 구조가 일치하지 않는 것은 불가피합니다. 바로 이 지점에서 어댑터(Adapter) 패턴이라는 디자인 패턴을 적용할 수 있습니

velog.io

어댑터 패턴을 프론트엔드(Frontend)에 적용할 수 있는 여러 가지 예제가 있습니다. 프론트엔드 개발에서 어댑터 패턴은 기존 코드와의 호환성을 유지하거나, 다른 API 또는 라이브러리의 인터페이스를 통일하는 데 유용하게 사용됩니다. 다음은 프론트엔드에서 어댑터 패턴을 활용할 수 있는 대표적인 예입니다.

예제 2: 서로 다른 API 간의 호환성 문제 해결

가장 흔한 예 중 하나는 서로 다른 서드파티 API를 통합할 때 발생합니다. 예를 들어, 두 개의 서드파티 API가 동일한 기능(예: 데이터 가져오기)을 제공하지만, 각기 다른 인터페이스를 가지고 있다고 가정해 보겠습니다. 이 경우 어댑터 패턴을 사용해 두 API를 통합된 방식으로 사용할 수 있습니다.

시나리오

API 1: REST API를 사용해 데이터를 가져옴.
API 2: GraphQL을 사용해 데이터를 가져옴.

기존 인터페이스

// API 1: REST
function fetchDataFromRestApi(endpoint) {
    return fetch(endpoint).then(response => response.json());
}

// API 2: GraphQL
function fetchDataFromGraphQL(query) {
    return fetch('/graphql', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ query }),
    }).then(response => response.json());
}

어댑터 패턴 적용

두 API를 통일된 인터페이스로 사용할 수 있도록 어댑터를 만듭니다.

// 어댑터 인터페이스
class DataAdapter {
    fetchData() {
        throw new Error('This method should be overridden.');
    }
}

// REST API 어댑터
class RestApiAdapter extends DataAdapter {
    constructor(endpoint) {
        super();
        this.endpoint = endpoint;
    }

    fetchData() {
        return fetchDataFromRestApi(this.endpoint);
    }
}

// GraphQL API 어댑터
class GraphQLAdapter extends DataAdapter {
    constructor(query) {
        super();
        this.query = query;
    }

    fetchData() {
        return fetchDataFromGraphQL(this.query);
    }
}

// 클라이언트 코드
function displayData(adapter) {
    adapter.fetchData().then(data => {
        console.log('Fetched Data:', data);
    });
}

// 사용 예시
const restAdapter = new RestApiAdapter('/api/data');
const graphqlAdapter = new GraphQLAdapter('{ data { id name } }');

displayData(restAdapter);
displayData(graphqlAdapter);

이 예제에서 RestApiAdapter와 GraphQLAdapter는 각각 DataAdapter라는 공통 인터페이스를 구현합니다. 이를 통해 클라이언트 코드(displayData)는 API의 종류에 상관없이 데이터를 가져올 수 있습니다.

1. 타겟 인터페이스 (Target Interface)

타겟 인터페이스는 클라이언트 코드가 기대하는 인터페이스입니다. 이 인터페이스를 통해 클라이언트는 특정 기능을 사용할 수 있으며, 이 인터페이스를 통해 여러 구현체를 동일한 방식으로 사용할 수 있습니다.

타겟 인터페이스: DataAdapter 클래스
- DataAdapter 클래스는 fetchData()라는 메서드를 정의하는 인터페이스로, REST API와 GraphQL API를 동일한 방식으로 사용할 수 있도록 합니다.
- 클라이언트 코드(displayData 함수)는 이 인터페이스를 통해 데이터를 가져옵니다.

2. 어댑터 (Adapter)

어댑터는 타겟 인터페이스를 구현하고, 내부적으로 어댑티(Adaptee)의 인터페이스를 사용하여 요청을 변환하는 클래스입니다. 어댑터는 타겟 인터페이스와 어댑티 간의 호환성을 제공하여, 클라이언트 코드가 어댑티의 복잡한 인터페이스를 신경 쓰지 않고도 이를 사용할 수 있게 해줍니다.

어댑터: RestApiAdapter 클래스와 GraphQLAdapter 클래스
- RestApiAdapter는 REST API를 사용하여 데이터를 가져오는 어댑터입니다. 이 클래스는 타겟 인터페이스인 DataAdapter를 구현하고, 내부적으로 fetchDataFromRestApi 함수를 호출합니다.
- GraphQLAdapter는 GraphQL API를 사용하여 데이터를 가져오는 어댑터입니다. 이 클래스 역시 타겟 인터페이스인 DataAdapter를 구현하고, 내부적으로 fetchDataFromGraphQL 함수를 호출합니다.

3. 어댑티 (Adaptee)

어댑티는 클라이언트가 직접 사용하기에는 인터페이스가 맞지 않지만, 어댑터를 통해 변환될 기존 클래스나 함수입니다. 어댑티는 어댑터에 의해 타겟 인터페이스에 맞게 변환되어 클라이언트에 제공됩니다.

어댑티: fetchDataFromRestApi 함수와 fetchDataFromGraphQL 함수
- fetchDataFromRestApi는 REST API를 통해 데이터를 가져오는 기존 함수입니다.
- fetchDataFromGraphQL는 GraphQL API를 통해 데이터를 가져오는 기존 함수입니다.
- 이 두 함수는 클라이언트 코드에서 직접 사용되기에는 인터페이스가 맞지 않기 때문에, 어댑터를 통해 타겟 인터페이스에 맞게 변환됩니다.

요약

타겟 인터페이스 (DataAdapter): 클라이언트 코드가 기대하는 공통 인터페이스.
어댑터 (RestApiAdapter, GraphQLAdapter): 타겟 인터페이스를 구현하고, 내부적으로 어댑티를 호출하여 요청을 처리하는 클래스.
어댑티 (fetchDataFromRestApi, fetchDataFromGraphQL): 원래의 클래스나 함수로, 어댑터에 의해 타겟 인터페이스에 맞게 변환되는 객체.

이 구조를 통해 클라이언트 코드(displayData)는 어떤 API가 실제로 사용되는지 알 필요 없이, 일관된 인터페이스(fetchData)를 사용하여 데이터를 가져올 수 있습니다.

[개발서적] 헤드퍼스트 디자인 패턴 Ch6. 커맨드(Command) 패턴

SWKo — Thu, 15 Aug 2024 12:23:07 +0900

1. 커맨드 패턴 소개

커맨드 패턴은 요청을 객체로 캡슐화하여 서로 다른 요청을 매개변수화하거나, 요청의 취소 및 재실행 등을 가능하게 하는 디자인 패턴입니다. 이 패턴을 사용하면 요청을 처리하는 객체(Receiver)와 요청을 발행하는 객체(Client)를 분리할 수 있습니다.

처음에 말만 들어서는 이해가 잘 안가니 아래 내용을 따라가 보겠습니다.

객체 마을 식당 예시

고객: 요청을 발행하는 역할 (커맨드 객체를 생성).
종업원: 커맨드 객체를 전달하는 역할.
주방장: 커맨드 객체에 따라 실제로 작업을 수행하는 역할.

주문서 (Command 객체):
- 역할: 주문서 객체는 주문 내용을 캡슐화합니다. 이는 요청을 특정한 형식으로 묶어서 다른 객체에게 전달할 수 있도록 하는 역할을 합니다.
- 특징: 주문서에는 orderUp() 메소드(execute())가 포함되어 있으며, 이 메소드를 호출하면 주문이 실행됩니다. 주문서에는 식사를 준비할 주방장의 레퍼런스가 포함되어 있지만, 이를 사용하는 종업원은 그 세부 내용을 알 필요가 없습니다.
종업원 (Invoker):
- 역할: 종업원은 고객의 주문서를 받아서 이를 처리할 책임이 있습니다. 그러나 종업원은 주문의 세부 내용을 알지 못하며, 단지 orderUp() 메소드를 호출하여 주문이 실행되도록 합니다.
- 특징: 종업원은 주문서를 전달하고 orderUp() 메소드를 호출하는 역할만 수행하며, 주문서에 무엇이 포함되어 있는지, 누가 음식을 준비하는지에 대해서는 알 필요가 없습니다. 이로써 종업원과 주방장은 완전히 분리됩니다.
주방장 (Receiver):
- 역할: 주방장은 실제로 주문된 음식을 준비하는 역할을 합니다. 주문서에 포함된 정보를 사용하여 음식을 만들며, 이 과정은 주방장만이 알고 있습니다.
- 특징: 주방장은 종업원과 직접 상호작용하지 않습니다. 종업원이 orderUp() 메소드를 호출하면, 주방장은 그에 따라 음식을 준비하는 작업을 처리합니다.

2. 객체마을 식당과 커맨드 패턴

3. 첫번째 커맨드 객체 만들기

예시로 여러 가지 기능을 수행할 수 있는 리모컨을 들어보겠습니다.

1. 커맨드 인터페이스 구현

커맨드 객체는 모두 같은 인터페이스를 구현해야 합니다. 인터페이스에는 execute() 메소드 하나만 존재합니다. (이름은 변경 가능 ex. orderUp())

public interface Command {
    public void execute();
}

2. 조명을 켤 때 필요한 커맨드 클래스 구현

Light는 Receiver

public class Light {
    
    // 조명을 켜는 메소드
    public void on() {
        System.out.println("The light is on");
    }

    // 조명을 끄는 메소드
    public void off() {
        System.out.println("The light is off");
    }
}

public class LightOnCommand implements Command {
    Light light;

    // 생성자: 제어할 Light 객체를 받아서 저장
    public LightOnCommand(Light light) {
        this.light = light;
    }

    // Command 인터페이스의 execute() 메소드 구현
    public void execute() {
        light.on();  // Light 객체의 on() 메소드를 호출하여 조명을 켬
    }
}

LightOnCommand 클래스: 조명을 켜는 커맨드 객체입니다.
Light 객체: 커맨드 객체가 제어할 조명을 나타냅니다.
생성자: Light 객체를 받아서 내부에 저장합니다.
execute() 메소드: 저장된 Light 객체의 on() 메소드를 호출하여 조명을 켭니다.

3. 커맨드 객체 사용하기

SimpleRemotecontrol은 Invoker

public class SimpleRemoteControl {
    Command slot;  // 커맨드를 저장할 슬롯

    public SimpleRemoteControl() {
        // 기본 생성자
    }

    // 커맨드를 설정하는 메소드
    public void setCommand(Command command) {
        slot = command;
    }

    // 버튼이 눌렸을 때 커맨드를 실행하는 메소드
    public void buttonWasPressed() {
        slot.execute();  // 슬롯에 저장된 커맨드를 실행
    }
}

SimpleRemoteControl 클래스: 매우 간단한 리모컨을 나타내며, 하나의 커맨드 객체만을 저장하고 실행할 수 있습니다.
slot 변수: Command 인터페이스를 구현한 객체를 저장하는 변수입니다.
setCommand() 메소드: 리모컨의 버튼에 연결될 커맨드를 설정합니다.
buttonWasPressed() 메소드: 버튼이 눌렸을 때 호출되며, 슬롯에 저장된 커맨드 객체의 execute() 메소드를 호출합니다.

public class RemoteControlTest {

    public static void main(String[] args) {
        // SimpleRemoteControl 인스턴스 생성 (Invoker 역할) (종업원)
        SimpleRemoteControl remote = new SimpleRemoteControl();

        // Light 인스턴스 생성 (Receiver 역할) (주방장)
        Light light = new Light();

        // LightOnCommand 인스턴스 생성 (Command 역할), light 객체를 전달
        LightOnCommand lightOn = new LightOnCommand(light);

        // 리모컨에 커맨드 설정
        remote.setCommand(lightOn);

        // 버튼을 눌러 커맨드 실행 (조명을 켜는 작업 수행)
        remote.buttonWasPressed();
    }
}

Invoker 역할 (SimpleRemoteControl 클래스):
- SimpleRemoteControl 클래스의 remote 객체가 Invoker 역할을 합니다. 이 객체는 커맨드를 저장하고, 버튼이 눌렸을 때 해당 커맨드를 실행하는 역할을 합니다.
Receiver 역할 (Light 클래스):
- Light 클래스의 light 객체는 Receiver 역할을 합니다. 실제로 조명을 켜고 끄는 작업을 수행하는 객체입니다.
Command 역할 (LightOnCommand 클래스):
- LightOnCommand 클래스는 Command 인터페이스를 구현하여 조명을 켜는 작업을 캡슐화한 커맨드 객체입니다. light 객체를 생성자에서 받아서 execute() 메소드가 호출되면 light.on()을 실행합니다.
커맨드 실행:
- remote.setCommand(lightOn)을 통해 리모컨의 버튼에 LightOnCommand 커맨드를 설정하고, remote.buttonWasPressed() 메소드를 호출하면 커맨드가 실행되어 조명이 켜집니다.

4. 커맨트 패턴의 정의 & 다이어그램

커맨드 패턴(Command Pattern)을 사용하면 요청 내역을 객체로 캡슐화해서 객체를 서로 다른 요청 내역에 따라 매개변수화(command 객체를 넘김)할 수 있습니다. (ex. remote.setCommand(lightOn))

이러면 요청을 큐에 저장하거나 로그로 기록하거나 작업 취소 기능을 사용할 수 있습니다.

5. 리모컨 코드 만들기

public class RemoteControl {
    Command[] onCommands;
    Command[] offCommands;

    public RemoteControl() {
        onCommands = new Command[7];
        offCommands = new Command[7];
        Command noCommand = new NoCommand();

        // 모든 슬롯에 noCommand로 초기화
        for (int i = 0; i < 7; i++) {
            onCommands[i] = noCommand;
            offCommands[i] = noCommand;
        }
    }

    // 특정 슬롯에 커맨드 설정
    public void setCommand(int slot, Command onCommand, Command offCommand) {
        onCommands[slot] = onCommand;
        offCommands[slot] = offCommand;
    }

    // on 버튼을 누르면 해당 슬롯의 onCommand 실행
    public void onButtonWasPushed(int slot) {
        onCommands[slot].execute();
    }

    // off 버튼을 누르면 해당 슬롯의 offCommand 실행
    public void offButtonWasPushed(int slot) {
        offCommands[slot].execute();
    }

    // 리모컨의 상태를 출력
    public String toString() {
        StringBuffer stringBuff = new StringBuffer();
        stringBuff.append("\n----- 리모컨 ---------\n");
        for (int i = 0; i < onCommands.length; i++) {
            stringBuff.append("[slot " + i + "] " + onCommands[i].getClass().getName()
                              + " " + offCommands[i].getClass().getName() + "\n");
        }
        return stringBuff.toString();
    }
}

커맨드 클래스 만들기

1. 조명 끄는 커맨트

public class LightOffCommand implements Command {
    Light light;

    // 생성자: 리시버인 Light 객체를 받아서 저장
    public LightOffCommand(Light light) {
        this.light = light;
    }

    // execute 메소드: 리시버의 off 메소드를 호출하여 조명을 끔
    public void execute() {
        light.off();
    }
}

2. 오디오 켜는 커맨드

오디오를 켤 때 자동으로 CD가 재생

public class StereoOnWithCDCommand implements Command {
    Stereo stereo;

    // 생성자: 제어할 Stereo 객체를 받아서 저장
    public StereoOnWithCDCommand(Stereo stereo) {
        this.stereo = stereo;
    }

    // execute 메소드: Stereo 객체의 on(), setCD(), setVolume() 메소드 호출
    public void execute() {
        stereo.on();        // 오디오 시스템을 켬
        stereo.setCD();     // CD 모드로 설정
        stereo.setVolume(11);  // 볼륨을 11로 설정
    }
}

리모컨 테스트

public class RemoteLoader {
    public static void main(String[] args) {
        // 리모컨 객체 생성
        RemoteControl remoteControl = new RemoteControl();

        // 각 장치 생성 (Receiver 들)
        Light livingRoomLight = new Light("Living Room");
        Light kitchenLight = new Light("Kitchen");
        CeilingFan ceilingFan = new CeilingFan("Living Room");
        GarageDoor garageDoor = new GarageDoor("Garage");
        Stereo stereo = new Stereo("Living Room");

        // 조명용 커맨드 객체 생성
        LightOnCommand livingRoomLightOn = new LightOnCommand(livingRoomLight);
        LightOffCommand livingRoomLightOff = new LightOffCommand(livingRoomLight);
        LightOnCommand kitchenLightOn = new LightOnCommand(kitchenLight);
        LightOffCommand kitchenLightOff = new LightOffCommand(kitchenLight);

        // 선풍기용 커맨드 객체 생성
        CeilingFanOnCommand ceilingFanOn = new CeilingFanOnCommand(ceilingFan);
        CeilingFanOffCommand ceilingFanOff = new CeilingFanOffCommand(ceilingFan);

        // 차고 문용 커맨드 객체 생성
        GarageDoorUpCommand garageDoorUp = new GarageDoorUpCommand(garageDoor);
        GarageDoorDownCommand garageDoorDown = new GarageDoorDownCommand(garageDoor);

        // 오디오 시스템용 커맨드 객체 생성
        StereoOnWithCDCommand stereoOnWithCD = new StereoOnWithCDCommand(stereo);
        StereoOffCommand stereoOff = new StereoOffCommand(stereo);

        // 리모컨 슬롯에 커맨드 로드
        remoteControl.setCommand(0, livingRoomLightOn, livingRoomLightOff);
        remoteControl.setCommand(1, kitchenLightOn, kitchenLightOff);
        remoteControl.setCommand(2, ceilingFanOn, ceilingFanOff);
        remoteControl.setCommand(3, stereoOnWithCD, stereoOff);

        // 리모컨 버튼 테스트
        remoteControl.onButtonWasPushed(0);
        remoteControl.offButtonWasPushed(0);
        remoteControl.onButtonWasPushed(1);
        remoteControl.offButtonWasPushed(1);
        remoteControl.onButtonWasPushed(2);
        remoteControl.offButtonWasPushed(2);
        remoteControl.onButtonWasPushed(3);
        remoteControl.offButtonWasPushed(3);

        // 리모컨의 슬롯 정보를 출력
        System.out.println(remoteControl);
    }
}

6. 작업 취소 기능 추가하기

작업 취소 기능을 지원하려면 excute()와 비슷한 undo() 메소드가 있어야 합니다.

public interface Command {
    public void execute();  // 커맨드를 실행하는 메소드
    public void undo();     // 커맨드를 취소(되돌리기)하는 메소드
}

LightOnCommand의 undo 예시

public class LightOnCommand implements Command {
    Light light;

    // 생성자: 제어할 Light 객체를 받아서 저장
    public LightOnCommand(Light light) {
        this.light = light;
    }

    // execute 메소드: Light 객체의 on 메소드를 호출하여 조명을 켬
    public void execute() {
        light.on();
    }

    // undo 메소드: Light 객체의 off 메소드를 호출하여 조명을 끔 (실행 취소)
    public void undo() {
        light.off();
    }
}

RemoteControlWithUndo

public class RemoteControlWithUndo {
    Command[] onCommands;
    Command[] offCommands;
    Command undoCommand;  // 마지막으로 실행된 커맨드를 저장하는 변수

    public RemoteControlWithUndo() {
        onCommands = new Command[7];
        offCommands = new Command[7];
        
        Command noCommand = new NoCommand();
        for (int i = 0; i < 7; i++) {
            onCommands[i] = noCommand;
            offCommands[i] = noCommand;
        }
        undoCommand = noCommand;  // 초기값으로 noCommand 설정
    }

    // 특정 슬롯에 onCommand와 offCommand 설정
    public void setCommand(int slot, Command onCommand, Command offCommand) {
        onCommands[slot] = onCommand;
        offCommands[slot] = offCommand;
    }

    // on 버튼이 눌렸을 때 실행
    public void onButtonWasPushed(int slot) {
        onCommands[slot].execute();  // 커맨드 실행
        undoCommand = onCommands[slot];  // 마지막으로 실행된 커맨드를 undoCommand에 저장
    }

    // off 버튼이 눌렸을 때 실행
    public void offButtonWasPushed(int slot) {
        offCommands[slot].execute();  // 커맨드 실행
        undoCommand = offCommands[slot];  // 마지막으로 실행된 커맨드를 undoCommand에 저장
    }

    // undo 버튼이 눌렸을 때 실행
    public void undoButtonWasPushed() {
        undoCommand.undo();  // 마지막으로 실행된 커맨드의 undo 메소드 호출
    }

    // 리모컨의 상태를 출력하는 toString 메소드 (생략 가능)
    public String toString() {
        StringBuilder stringBuff = new StringBuilder();
        stringBuff.append("\n----- 리모컨 ---------\n");
        for (int i = 0; i < onCommands.length; i++) {
            stringBuff.append("[slot " + i + "] " + onCommands[i].getClass().getName()
                              + "    " + offCommands[i].getClass().getName() + "\n");
        }
        stringBuff.append("[undo] " + undoCommand.getClass().getName() + "\n");
        return stringBuff.toString();
    }
}

RemoteLoader에서 undo 실행

public class RemoteLoader {
    public static void main(String[] args) {
        // Undo 기능이 있는 리모컨 객체 생성
        RemoteControlWithUndo remoteControl = new RemoteControlWithUndo();

        // 거실 조명 객체 생성
        Light livingRoomLight = new Light("Living Room");

        // 조명을 켜고 끄는 커맨드 객체 생성
        LightOnCommand livingRoomLightOn = new LightOnCommand(livingRoomLight);
        LightOffCommand livingRoomLightOff = new LightOffCommand(livingRoomLight);

        // 리모컨의 0번 슬롯에 조명 커맨드 설정
        remoteControl.setCommand(0, livingRoomLightOn, livingRoomLightOff);

        // 조명을 켜고 끄는 명령을 실행
        remoteControl.onButtonWasPushed(0);  // 조명을 켬
        remoteControl.offButtonWasPushed(0); // 조명을 끔

        // 현재 리모컨의 상태 출력
        System.out.println(remoteControl);

        // 마지막 명령을 취소 (undo)
        remoteControl.undoButtonWasPushed(); // 조명을 다시 켬 (undo)

        // 다시 조명을 끄고, 켜는 명령을 실행
        remoteControl.offButtonWasPushed(0); // 조명을 끔
        remoteControl.onButtonWasPushed(0);  // 조명을 켬

        // 현재 리모컨의 상태 출력
        System.out.println(remoteControl);

        // 마지막 명령을 취소 (undo)
        remoteControl.undoButtonWasPushed(); // 조명을 다시 끔 (undo)
    }
}

7. 여러 동작을 한 번에 처리하기

매크로 커맨드

public class MacroCommand implements Command {
    Command[] commands;  // 여러 커맨드를 담을 배열

    // 생성자: Command 배열을 받아서 MacroCommand 안에 저장
    public MacroCommand(Command[] commands) {
        this.commands = commands;
    }

    // execute 메소드: 배열에 저장된 모든 커맨드를 실행
    public void execute() {
        for (int i = 0; i < commands.length; i++) {
            commands[i].execute();
        }
    }

    // undo 메소드: 배열에 저장된 모든 커맨드를 거꾸로 실행 취소
    public void undo() {
        for (int i = commands.length - 1; i >= 0; i--) {
            commands[i].undo();
        }
    }
}

매크로 커맨드 사용하기

public class RemoteLoader {
    public static void main(String[] args) {
        RemoteControlWithUndo remoteControl = new RemoteControlWithUndo();

        // 장치들 생성
        Light livingRoomLight = new Light("Living Room");
        Stereo stereo = new Stereo("Living Room");
        CeilingFan ceilingFan = new CeilingFan("Living Room");

        // 개별 커맨드 생성
        LightOnCommand livingRoomLightOn = new LightOnCommand(livingRoomLight);
        StereoOnWithCDCommand stereoOnWithCD = new StereoOnWithCDCommand(stereo);
        CeilingFanOnCommand ceilingFanOn = new CeilingFanOnCommand(ceilingFan);

        LightOffCommand livingRoomLightOff = new LightOffCommand(livingRoomLight);
        StereoOffCommand stereoOff = new StereoOffCommand(stereo);
        CeilingFanOffCommand ceilingFanOff = new CeilingFanOffCommand(ceilingFan);

        // MacroCommand로 여러 커맨드를 묶음
        Command[] partyOn = { livingRoomLightOn, stereoOnWithCD, ceilingFanOn };
        Command[] partyOff = { livingRoomLightOff, stereoOff, ceilingFanOff };

        MacroCommand partyOnMacro = new MacroCommand(partyOn);
        MacroCommand partyOffMacro = new MacroCommand(partyOff);

        // 리모컨에 MacroCommand 설정
        remoteControl.setCommand(0, partyOnMacro, partyOffMacro);

        // 리모컨 테스트
        System.out.println("--- Pushing Macro On---");
        remoteControl.onButtonWasPushed(0);  // 여러 장치가 한 번에 켜짐

        System.out.println("--- Pushing Macro Off---");
        remoteControl.offButtonWasPushed(0);  // 여러 장치가 한 번에 꺼짐

        System.out.println("--- Pushing Undo---");
        remoteControl.undoButtonWasPushed();  // 마지막 명령들을 모두 취소
    }
}

[개발서적] 헤드퍼스트 디자인 패턴 Ch5. 싱글턴(Singleton) 패턴

SWKo — Mon, 12 Aug 2024 21:45:27 +0900

1. 싱글턴 패턴 vs 전역 변수

전역 변수의 단점은 애플리케이션 시작 시 객체가 생성되어 자원을 낭비할 수 있다는 것입니다.

예를 들어, 전역 변수에 자원을 많이 차지하는 객체를 대입했지만, 애플리케이션 종료까지 사용되지 않는다면 쓸모없는 자원 낭비가 됩니다. 이를 방지하기 위해 싱글턴 패턴을 사용하면 필요할 때만 객체를 생성할 수 있습니다.

2. 고전적인 싱글턴 패턴 구현법

클래스 내에서 자신의 유일한 인스턴스를 정적 변수로 보유
- 클래스 내부에 static 변수를 사용하여 자신의 인스턴스를 저장합니다.
생성자를 private으로 설정
- 외부에서 객체를 생성하지 못하도록 생성자를 private으로 선언합니다.
- 이렇게 하면 클래스 외부에서는 새로운 인스턴스를 만들 수 없습니다.
유일한 인스턴스에 접근할 수 있는 정적 메서드 제공
- 정적 메서드를 통해 외부에서 이 클래스의 인스턴스에 접근할 수 있도록 합니다.
- 이 메서드에서는 객체가 이미 생성되었는지 확인한 후, 생성되지 않았다면 객체를 생성하고, 생성된 인스턴스를 반환합니다.

public class Singleton {
    // 유일한 인스턴스를 정적 변수로 선언
    private static Singleton uniqueInstance;

    // private 생성자: 외부에서 인스턴스 생성을 막음
    private Singleton() {}

    // 유일한 인스턴스를 반환하는 정적 메서드
    public static Singleton getInstance() {
        if (uniqueInstance == null) {
            uniqueInstance = new Singleton(); // 인스턴스가 없으면 생성
        }
        return uniqueInstance; // 이미 생성된 인스턴스를 반환
    }
}

3. 초콜릿 보일러

초콜릿 보일러는 초콜릿과 우유를 특정 조건에서만 혼합하고 가열하는 기계입니다.

하지만 두 개 이상의 인스턴스가 동시에 작동하면 시스템이 잘못된 상태에 빠질 수 있어 문제가 발생합니다.

이 문제를 해결하기 위해 싱글턴 패턴을 적용합니다.

싱글턴 패턴을 사용하면 초콜릿 보일러 클래스의 인스턴스가 하나만 생성되고, 이 인스턴스에만 접근할 수 있습니다.

이를 통해 여러 개의 보일러 인스턴스가 생성되어 발생할 수 있는 문제를 방지할 수 있습니다.

public class ChocolateBoiler {
    private boolean empty;
    private boolean boiled;

    // 유일한 인스턴스를 저장할 static 변수
    private static ChocolateBoiler uniqueInstance;

    // private 생성자: 외부에서 인스턴스를 생성하지 못하게 막음
    private ChocolateBoiler() {
        empty = true;
        boiled = false;
    }

    // 유일한 인스턴스를 반환하는 static 메서드
    public static ChocolateBoiler getInstance() {
        if (uniqueInstance == null) {
            uniqueInstance = new ChocolateBoiler();
        }
        return uniqueInstance;
    }

    public void fill() {
        if (isEmpty()) {
            empty = false;
            boiled = false;
            // 보일러에 초콜릿과 우유를 채움
        }
    }

    public void drain() {
        if (!isEmpty() && isBoiled()) {
            // 보일러를 비움
            empty = true;
        }
    }

    public void boil() {
        if (!isEmpty() && !isBoiled()) {
            // 보일러를 가열
            boiled = true;
        }
    }

    public boolean isEmpty() {
        return empty;
    }

    public boolean isBoiled() {
        return boiled;
    }
}

4. 싱글턴 패턴의 정의

싱글턴 패턴(Singleton Pattern)은 클래스 인스턴스를 하나 만들고, 그 인스턴스로의 전역 접근을 제공합니다.

5. 멀티스레딩 문제 해결하기

멀티쓰레드 환경에서 동시에 여러 쓰레드가 getInstance() 메서드를 호출할 경우, 여러 개의 인스턴스가 생성될 수 있는 위험이 있습니다.

메서드 동기화 (synchronized)

getInstance() 메서드 전체를 synchronized 키워드를 사용해 동기화하여, 한 번에 하나의 쓰레드만 메서드를 실행할 수 있게 합니다.

public static synchronized ChocolateBoiler getInstance() {
    if (uniqueInstance == null) {
        uniqueInstance = new ChocolateBoiler();
    }
    return uniqueInstance;
}

이 방법은 안전하지만, 모든 접근이 동기화되어 성능이 저하(100배 차이)될 수 있습니다.

6. 더 효율적으로 멀티스레딩 문제 해결하기

방법 1

getInstance() 메서드의 속도가 중요하지 않다면, 동기화를 그대로 사용해도 괜찮습니다.

동기화는 구현이 간단하고 효율적일 수 있지만, 성능 저하가 발생할 수 있습니다.

만약 getInstance()가 애플리케이션에서 성능 병목이 된다면, 다른 해결 방법을 고려해야 합니다.

방법 2

싱글턴 인스턴스를 필요할 때 생성하지 말고, 처음부터 생성하는 방법입니다.

정적 초기화 부분에서 Singleton 인스턴스를 미리 생성하여, 멀티쓰레드 환경에서도 안전하게 사용할 수 있습니다.

getInstance() 메서드는 이미 생성된 인스턴스를 반환하기만 하면 되므로 간단하고 효율적입니다.

public class Singleton {
    // 클래스 로딩 시점에 인스턴스를 생성
    private static final Singleton uniqueInstance = new Singleton();

    // private 생성자: 외부에서 인스턴스 생성 불가
    private Singleton() {}

    // 이미 생성된 인스턴스를 반환
    public static Singleton getInstance() {
        return uniqueInstance;
    }
}

방법 3

DCL(Double-Checked Locking)을 사용할 수 있습니다.

getInstance() 메서드에서 인스턴스가 이미 생성되었는지 먼저 확인하고, 생성되지 않은 경우에만 동기화 블록에 들어가 인스턴스를 생성합니다.

이로써, 인스턴스가 처음 생성될 때만 동기화가 일어나고, 그 이후에는 동기화 없이 인스턴스에 접근할 수 있어 성능이 향상됩니다.

public class Singleton {
    // volatile 키워드를 사용하여 인스턴스 변수 선언
    private volatile static Singleton uniqueInstance;

    // private 생성자: 외부에서 인스턴스 생성 불가
    private Singleton() {}

    // 인스턴스 생성 메서드
    public static Singleton getInstance() {
        if (uniqueInstance == null) { // 인스턴스가 없으면
            synchronized (Singleton.class) { // 클래스에 대해 동기화
                if (uniqueInstance == null) { // 다시 한 번 인스턴스가 없는지 확인
                    uniqueInstance = new Singleton(); // 인스턴스 생성
                }
            }
        }
        return uniqueInstance; // 이미 생성된 인스턴스를 반환
    }
}

volatile 키워드: uniqueInstance 변수를 volatile로 선언하여, 인스턴스가 생성되는 과정을 다른 쓰레드들이 정확하게 인식할 수 있도록 합니다.
이중 검증: getInstance() 메서드에서 인스턴스가 null인지 두 번 확인합니다. 처음에는 동기화 없이 확인하고, 두 번째는 동기화 블록 내에서 확인하여 인스턴스가 없는 경우에만 생성합니다.

방법 4

enum을 사용합니다.

enum은 자바 언어 스펙에 의해 인스턴스가 단 한 번만 생성되고, 그 인스턴스는 enum의 생애주기 동안 계속 유지됩니다.

따라서 싱글턴 인스턴스가 하나만 존재하는 것이 자동으로 보장됩니다.

public enum Singleton {
    UNIQUE_INSTANCE;  // enum 상수로 싱글턴 인스턴스 정의

    // 기타 필요한 필드와 메서드를 정의할 수 있습니다.
    public void someMethod() {
        // 싱글턴 객체로 수행할 작업들
        System.out.println("Doing something with the singleton instance.");
    }
}

public class SingletonClient {
    public static void main(String[] args) {
        // Singleton 인스턴스에 접근
        Singleton singleton = Singleton.UNIQUE_INSTANCE;
        
        // 여기서 싱글턴을 사용
        singleton.someMethod();  // "Doing something with the singleton instance." 출력
    }
}

https://patterns-dev-kr.github.io/design-patterns/singleton-pattern/

Singleton 패턴

앱 전체에서 공유 및 사용되는 단일 인스턴스 - Singleton은 1회에 한하여 인스턴스화가 가능하며 전역에서 접근 가능한 클래스를 지칭한다. 만들어진 Singleton…

patterns-dev-kr.github.io

[개발서적] 헤드퍼스트 디자인 패턴 Ch4. 팩토리(Factory) 패턴

SWKo — Sun, 28 Jul 2024 18:47:57 +0900

1. 최첨단 피자 코드 만들기

피자 종류를 고르고 그에 맞는 피자를 만드는 코드를 작성해야 합니다.

초기 코드

public class PizzaStore {
    public Pizza orderPizza(String type) {
        Pizza pizza = null;

        if (type.equals("cheese")) {
            pizza = new CheesePizza();
        } else if (type.equals("greek")) {
            pizza = new GreekPizza();
        } else if (type.equals("pepperoni")) {
            pizza = new PepperoniPizza();
        } else if (type.equals("clam")) {
            pizza = new ClamPizza();
        } else if (type.equals("veggie")) {
            pizza = new VeggiePizza();
        }

        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();

        return pizza;
    }
}

위 코드의 문제점은 인스턴스를 만드는 구상 클래스(new ~~)를 선택하는 부분입니다.

확장성 부족: 새로운 피자 종류를 추가하거나 기존 피자 종류를 제거하려면 PizzaStore 클래스의 orderPizza 메서드를 수정해야 합니다.
유지보수 어려움: 피자 종류가 많아질수록 orderPizza 메서드의 조건문이 길어지고 복잡해집니다.

2. 객체 생성 부분 캡슐화하기

객체 생성 부분을 orderPizza() 메소드에서 뽑아내야 합니다.

새로 만들 객체를 팩토리라고 부르겠습니다.

객체 생성을 처리하는 클래스를 팩토리(Factory)라고 부릅니다.

일단 SimplePizzaFactory를 만들고 나면 orderPizza() 메소드는 새로 만든 객체의 클라이언트가 됩니다.

피자가 필요할 때마다 피자 공장에 피자 하나 만들어 달라고 부탁한다고 생각하면 됩니다.

더 이상 orderPizza() 메소드에서 어떤 피자를 만들지 고민하지 않아도 됩니다.

public class SimplePizzaFactory {
    public Pizza createPizza(String type) {
        Pizza pizza = null;
        
        if (type.equals("cheese")) {
            pizza = new CheesePizza();
        } else if (type.equals("pepperoni")) {
            pizza = new PepperoniPizza();
        } else if (type.equals("clam")) {
            pizza = new ClamPizza();
        } else if (type.equals("veggie")) {
            pizza = new VeggiePizza();
        }
        
        return pizza;
    }
}

3. 클라이언트 코드 수정하기

// PizzaStore 클래스
public class PizzaStore {
    SimplePizzaFactory factory;

    // 생성자: SimplePizzaFactory 객체를 전달받아 초기화
    public PizzaStore(SimplePizzaFactory factory) {
        this.factory = factory;
    }

    // 피자를 주문하는 메소드
    public Pizza orderPizza(String type) {
        Pizza pizza;

        // SimplePizzaFactory를 사용해 피자 객체 생성
        pizza = factory.createPizza(type);

        // 피자 준비, 굽기, 자르기, 포장 과정 수행
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();

        return pizza;
    }
}

4. '간단한 팩토리'의 정의

간단한 팩토리(Simple Factory)는 디자인 패턴이라기 보다는 프로그래밍에서 자주 쓰이는 관용구에 가깝습니다.

public class PizzaStore {
    SimplePizzaFactory factory;

    public PizzaStore(SimplePizzaFactory factory) {
        this.factory = factory;
    }

    public Pizza orderPizza(String type) {
        Pizza pizza;

	// 피자를 만드는 코드가 PizzaStore와 직접 연결되어 있어서, 유연성이 없음(조리 방식이 일관됨)
        pizza = factory.createPizza(type);

        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();

        return pizza;
    }
}

public class SimplePizzaFactory {
    public Pizza createPizza(String type) {
        Pizza pizza = null;

        if (type.equals("cheese")) {
            pizza = new CheesePizza();
        } else if (type.equals("clam")) {
            pizza = new ClamPizza();
        }

        return pizza;
    }
}

public class CheesePizza extends Pizza {
    public CheesePizza() {
        name = "Cheese Pizza";
        dough = "Regular Crust";
        sauce = "Marinara Pizza Sauce";
    }
}

public abstract class Pizza {
    String name;
    String dough;
    String sauce;

    void prepare() {
        System.out.println("Preparing " + name);
    }

    void bake() {
        System.out.println("Baking " + name);
    }

    void cut() {
        System.out.println("Cutting " + name);
    }

    void box() {
        System.out.println("Boxing " + name);
    }

    public String getName() {
        return name;
    }
}

public class PizzaTestDrive {
    public static void main(String[] args) {
        SimplePizzaFactory factory = new SimplePizzaFactory();
        PizzaStore store = new PizzaStore(factory);

        Pizza pizza = store.orderPizza("cheese");
        System.out.println("We ordered a " + pizza.getName() + "\n");

        pizza = store.orderPizza("clam");
        System.out.println("We ordered a " + pizza.getName() + "\n");
    }
}

5. 다양한 팩토리 만들기

피자 가게가 잘되니, 다른 지점을 열고 싶어졌습니다.

각 지역의 특성을 반영항 다양한 스타일의 피자(뉴욕, 시카고, ..)를 만들어야 합니다.

SimplePizzaFactory 대신, NYPizzaFactory, ChicagoFactory, ... 등을 만듭니다.

public class PizzaTestDrive {
    public static void main(String[] args) {
        PizzaFactory nyFactory = new NYPizzaFactory();
        PizzaStore nyStore = new PizzaStore(nyFactory);

        Pizza pizza = nyStore.orderPizza("veggie");
        System.out.println("We ordered a " + pizza.getName() + "\n");

        PizzaFactory chicagoFactory = new ChicagoPizzaFactory();
        PizzaStore chicagoStore = new PizzaStore(chicagoFactory);

        pizza = chicagoStore.orderPizza("veggie");
        System.out.println("We ordered a " + pizza.getName() + "\n");
    }
}

'간단한 팩토리' 방식은 지점마다 굽는 방식이나 자르는 방식이 달라지면 문제를 일으킵니다.

따라서 유연성을 유지하면서도 피자 가게와 피자 제작 과정을 일관되게 관리할 수 있는 새로운 접근법이 필요합니다.

피자 가게에서 일관된 품질의 피자를 만들기 위해 피자 제작 과정을 하나로 묶는 프레임워크가 필요합니다.

6. 피자 가게 프레임워크 만들기

피자를 만드는 일 자체는 PizzaStore 클래스에 진행하면서도 지점의 스타일을 살릴 방법이 있습니다.

createPizza() 메소드를 추상 메소드로 선언하고, 지역별 스타일에 맞게 PizzaStore의 서브클래스를 만듭니다.

public abstract class PizzaStore {

    public Pizza orderPizza(String type) {
        Pizza pizza;

        pizza = createPizza(type);

        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();

        return pizza;
    }

    // 팩토리 메서드
    protected abstract Pizza createPizza(String type);
}

이제 각 지점에 맞는 서브클래스를 만들어야 합니다.

피자의 스타일은 각 서브클래스에서 결정합니다.

7. 서브클래스가 결정하는 것 알아보기

pizzaStore의 orderPizza() 메소드에 이미 주문 시스템이 잘 갖춰져 있습니다.

각 지점마다 달라질 수 있는 것은 피자 스타일뿐입니다.

PizzaStore의 서브클래스에서 createPizza() 메소드를 구현하겠습니다.

orderPizza() 메소드는 추상 클래스 PizzaStore 클래스에 정의되어 있습니다.

orderPizza()는 실제로 어떤 구상 클래스에서 작업이 처리되고 있는지 알 수 없습니다.

PizzaStore와 Pizza는 서로 완전히 분리되어 있습니다.

피자의 종류는 어떤 서브클래스를 선택했느냐에 따라 결정됩니다.

8. 피자 스타일 서브클래스 만들기

각 지점에는 PizzaStore의 서브클래스를 만들고 지역별 특성에 맞게 createPizza() 메소드만 구현하면 PizzaStore의 기능을 그대로 사용할 수 있습니다.

public abstract class PizzaStore {

    public Pizza orderPizza(String type) {
        Pizza pizza = createPizza(type); // 팩토리 메소드 호출
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }

    // 팩토리 메소드
    protected abstract Pizza createPizza(String type);
}

// 객체를 생성하는 코드를 캡슐화함
public class NYPizzaStore extends PizzaStore {

    @Override
    protected Pizza createPizza(String item) {
        if (item.equals("cheese")) {
            return new NYStyleCheesePizza();
        } else if (item.equals("veggie")) {
            return new NYStyleVeggiePizza();
        } else if (item.equals("clam")) {
            return new NYStyleClamPizza();
        } else if (item.equals("pepperoni")) {
            return new NYStylePepperoniPizza();
        } else {
            return null;
        }
    }
}

public abstract class Pizza {
    String name;
    String dough;
    String sauce;

    void prepare() {
        System.out.println("Preparing " + name);
    }

    void bake() {
        System.out.println("Baking " + name);
    }

    void cut() {
        System.out.println("Cutting " + name);
    }

    void box() {
        System.out.println("Boxing " + name);
    }

    public String getName() {
        return name;
    }
}

public class NYStyleCheesePizza extends Pizza {
    public NYStyleCheesePizza() {
        name = "NY Style Cheese Pizza";
        dough = "Thin Crust Dough";
        sauce = "Marinara Sauce";
    }
}

public class NYStyleVeggiePizza extends Pizza {
    public NYStyleVeggiePizza() {
        name = "NY Style Veggie Pizza";
        dough = "Thin Crust Dough";
        sauce = "Marinara Sauce";
    }
}

public class NYStyleClamPizza extends Pizza {
    public NYStyleClamPizza() {
        name = "NY Style Clam Pizza";
        dough = "Thin Crust Dough";
        sauce = "White Garlic Sauce";
    }
}

public class NYStylePepperoniPizza extends Pizza {
    public NYStylePepperoniPizza() {
        name = "NY Style Pepperoni Pizza";
        dough = "Thin Crust Dough";
        sauce = "Marinara Sauce";
    }
}

// 메인 메소드에서 피자 주문 과정 시뮬레이션
public class PizzaTestDrive {
    public static void main(String[] args) {
        PizzaStore nyPizzaStore = new NYPizzaStore();
        Pizza pizza = nyPizzaStore.orderPizza("cheese");
        System.out.println("에단이 주문한: " + pizza.getName());
    }
}

9. 팩토리 메소드 패턴 살펴보기

모든 팩토리 패턴은 객체 생성을 캡슐화합니다.

팩토리 메소드 패턴은 서브클래스에서 어떤 클래스를 만들지 결정함으로써 객체 생성을 캡슐화합니다.

구상 생산자(NYPizzaStore, ChicagoPizzaStore, ...)별로 수많은 제품을 만들 수 있습니다.

위 그림을 아래처럼 병렬 계층 구조로 볼 수 있습니다.

10. 팩토리 메소드 패턴의 정의

팩토리 메소드 패턴에서는 객체를 생성할 때 필요한 인터페이스(createPizza)를 만듭니다.

어떤 클래스의 인스턴스를 만들지는 서브클래스(NYPizzaStore, ChicagoPizzaStore, ...)에서 결정합니다.

팩토리 메소드 패턴을 사용하면 클래스 인스턴스 만드는 일을 서브클래스에게 맡기게 됩니다.

사용하는 서브클래스에 따라 생산되는 객체 인스턴스가 결정됩니다.

팩토리 장점은 우선 객체 생성 코드를 전부 한 객체 또는 메소드에 넣으면 코드에서 중복되는 내용을 제거할 수 있고, 나중에 관리할 때도 한 군데에만 신경을 쓰면 됩니다.

그리고 객체 인스턴스를 만들 때 인터페이스(createPizza)만 있으면 됩니다.

11. 객체 의존성 살펴보기

객체 인스턴스를 직접 만들면 구상 클래스에 의존해야 합니다.

아래 코드는 심하게 의존적인 PizzaStore 코드입니다.

모든 피자 객체를 팩토리에 맡겨서 만들지 않고 PizzaStore 클래스 내에서 직접 만들었습니다.

새로운 피자 종류나 스타일을 추가할 때마다 이 클래스의 조건문을 수정해야 합니다.

public class DependentPizzaStore {

    public Pizza createPizza(String style, String type) {
        Pizza pizza = null;
        
        if (style.equals("NY")) {
            if (type.equals("cheese")) {
                pizza = new NYStyleCheesePizza();
            } else if (type.equals("veggie")) {
                pizza = new NYStyleVeggiePizza();
            } else if (type.equals("clam")) {
                pizza = new NYStyleClamPizza();
            } else if (type.equals("pepperoni")) {
                pizza = new NYStylePepperoniPizza();
            }
        } else if (style.equals("Chicago")) {
            if (type.equals("cheese")) {
                pizza = new ChicagoStyleCheesePizza();
            } else if (type.equals("veggie")) {
                pizza = new ChicagoStyleVeggiePizza();
            } else if (type.equals("clam")) {
                pizza = new ChicagoStyleClamPizza();
            } else if (type.equals("pepperoni")) {
                pizza = new ChicagoStylePepperoniPizza();
            }
        } else {
            System.out.println("오류: 알 수 없는 피자 종류");
            return null;
        }

        if (pizza != null) {
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }

        return pizza;
    }
}

12. 의존성 뒤집기 원칙

구상 클래스 의존성을 줄이면 좋습니다.

그것이 바로 의존성 뒤집기 원칙(Dependency Inversion Principle) 입니다.

디자인 원칙
추상화된 것에 의존하게 만들고, 구상 클래스에 의존하지 않게 만든다.

고수준 구성 요소(PizzaStore)가 저수준 구성 요소(Pizza 클래스)에 의존하면 안되며, 항상 추상화에 의존하게 만들어야 합니다.

DependentPizzaStore의 가장 큰 문제점은 PizzaStore가 모든 종류의 피자에 의존한다는 점입니다.

orderPizza() 메소드에서 구상 형식의 인스턴스(new ~~Pizza())를 직접 만들기 때문입니다.

인스턴스 만드는 부분을 뽑아낼 생각을 해야합니다. -> 팩토리 메소드 패턴 사용

팩토리 메소드 패턴을 적용하면 고수준 구성 요소인 PizzaStore와 저수준 구성 요소인 피자 객체 모두가 추상 클래스인 Pizza에 의존하는 걸 알 수 있습니다.

의존성 뒤집기에서 '뒤집기(inversion)'라는 말이 있는 이유는 객체 지향 디자인을 할 때 일반적으로 생각하는 방법과는 반대로 뒤집어서 생각해야하기 때문입니다.

이전 다이어그램에서 의존성이 위에서 아래로 내려가기만 했지만, 현재 다이어그램에서는 반대로 뒤집어져 있습니다. 고수준 모듈과 저수준 모듈이 하나의 추상 클래스에 의존하게 됩니다.

13. 의존성 뒤집기 원칙을 지키는 방법

변수에 구상 클래스의 레퍼런스를 저장하지 맙시다. new 연산자를 사용하면 구상 클래스의 레퍼런스를 사용하게 됩니다. new 를 최대한 자제하자!
구상 클래스에서 유도된 클래스를 만들지 맙시다. 구상 클래스에서 유도된 클래스를 만들면 특정 구상 클래스에 의존하게 됩니다.

public class NYStyleCheesePizza extends CheesePizza {
  // 이런 식으로 구상 클래스(CheesePizza)에서 유도된 클래스(NYStyleCheesePizza)를 만들지 맙시다.
}

베이스 클래스에 이미 구현되어 있는 메소드를 오버라이드하지 맙시다. Pizza 클래스는 prepare, bake, cut, box 메소드를 이미 구현하고 있습니다. 이 메소드들은 오버라이드하지 말아야 피자 종류에 관계없이 동일하게 동작할 수 있습니다.

위 가이드라인을 항상 지켜야 하는 규칙은 아니고, 지향하는 바를 알려 줄 뿐입니다.

하지만 가이드라인을 습득한 상태에서 디자인한다면 원칙이 안지켜진 부분도 알 수 있고, 합리적인 이유로 불가피한 상황에서만 예외를 둘 수 있습니다.

14. 원재료 팩토리 만들기

PizzaStore은 어느 정도 모양새를 갖췄습니다.

그러나, 몇몇 지점에서 더 싼 재료를 사용해서 마진을 높이고 있습니다. 조치가 필요합니다.

어떻게 하면 지점에서 좋은 재료를 사용할 수 있도록 관리할 수 있을까요?

뉴욕 원재료 팩토리를 만들어보겠습니다.

// PizzaIngredientFactory은 추상 팩토리입니다.
public interface PizzaIngredientFactory {
    Dough createDough();
    Sauce createSauce();
    Cheese createCheese();
    Veggies[] createVeggies();
    Pepperoni createPepperoni();
    Clams createClam();
}

public class NYPizzaIngredientFactory implements PizzaIngredientFactory {

    @Override
    public Dough createDough() {
        return new ThinCrustDough();
    }

    @Override
    public Sauce createSauce() {
        return new MarinaraSauce();
    }

    @Override
    public Cheese createCheese() {
        return new ReggianoCheese();
    }

    @Override
    public Veggies[] createVeggies() {
        Veggies[] veggies = { new Garlic(), new Onion(), new Mushroom(), new RedPepper() };
        return veggies;
    }

    @Override
    public Pepperoni createPepperoni() {
        return new SlicedPepperoni();
    }

    @Override
    public Clams createClam() {
        return new FreshClams();
    }
}

15. Pizza 클래스 변경하기

공장도 다 만들었으니 이제 생산할 준비가 끝났습니다.

Pizza 클래스가 팩토리에서 생산한 원재료만 사용하도록 코드를 수정해보겠습니다. (prepare에 주목)

public abstract class Pizza {
    String name;
    Dough dough;
    Sauce sauce;
    Veggies[] veggies;
    Cheese cheese;
    Pepperoni pepperoni;
    Clams clam;

    // 재료 준비를 위한 추상 메서드
    abstract void prepare();

    // 피자를 굽는 메서드
    void bake() {
        System.out.println("175도에서 25분 간 굽기");
    }

    // 피자를 자르는 메서드
    void cut() {
        System.out.println("피자를 사선으로 자르기");
    }

    // 피자를 상자에 담는 메서드
    void box() {
        System.out.println("상자에 피자 담기");
    }

    // 피자 이름 설정 메서드
    void setName(String name) {
        this.name = name;
    }

    // 피자 이름 반환 메서드
    String getName() {
        return name;
    }

    // 피자 이름 출력 메서드
    public String toString() {
        return "피자 이름: " + name;
    }
}

Pizza 추상 클래스 준비가 끝났으니, 뉴욕 스타일 피자와 시카고 스타일 피자를 만들어보겠습니다.

피자마다 클래스를 지역별로 따로 만들 필요가 없습니다.

지역별로 다른 점은 원재료 팩토리에서 처리합니다.

public class CheesePizza extends Pizza {
    PizzaIngredientFactory ingredientFactory;

// 각 피자 클래스는 생성자로부터 팩토리를 전달받고 그 팩토리를 인스턴스 변수에 저장합니다.
    public CheesePizza(PizzaIngredientFactory ingredientFactory) {
        this.ingredientFactory = ingredientFactory;
    }

    @Override
    void prepare() {
        System.out.println("Preparing " + name);
        dough = ingredientFactory.createDough();
        sauce = ingredientFactory.createSauce();
        cheese = ingredientFactory.createCheese();
    }
}

올바른 재료 공장을 사용하는 NYPizzaStore를 보겠습니다.

public abstract class PizzaStore {
    protected abstract Pizza createPizza(String item);

    public Pizza orderPizza(String type) {
        Pizza pizza = createPizza(type);
        System.out.println("--- Making a " + pizza.getName() + " ---");
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}

public class NYPizzaStore extends PizzaStore {
    @Override
    protected Pizza createPizza(String item) {
        Pizza pizza = null;
        PizzaIngredientFactory ingredientFactory = new NYPizzaIngredientFactory();

        if (item.equals("cheese")) {
            pizza = new CheesePizza(ingredientFactory);
            pizza.setName("New York Style Cheese Pizza");
        }
        // 다른 피자 타입도 추가 가능
        return pizza;
    }
}

16. 추상 팩토리 패턴의 정의

추상 팩토리 패턴(Abstract Factory Pattern)은 구상 클래스에 의존하지 않고도 서로 연관되거나 의존적인 객체로 이루어진 제품군을 생산하는 인터페이스를 제공합니다. 구상 클래스는 서브클래스에서 만듭니다.

추상 팩토리 패턴을 사용하면 클라이언트에서 추상 인터페이스로 일련의 제품(재료)을 공급받을 수 있습니다.

이때, 실제로 어떤 제품이 생산되는지 전혀 알 필요 없습니다.

따라서 클라이언트와 팩토리에서 생성되는 제품을 분리할 수 있습니다.

17. 팩토리 메소드 패턴과 추상 팩토리 패턴

팩토리 메소드 패턴

팩토리 메소드 패턴은 객체를 생성하기 위한 인터페이스를 정의하고, 실제 객체 생성은 서브클래스에서 담당하도록 하는 패턴입니다.

이는 객체 생성의 책임을 서브클래스로 위임함으로써 상위 클래스와 하위 클래스 간의 결합도를 낮춥니다.

구조

상위 클래스 (Creator): 객체를 생성하는 팩토리 메소드를 정의합니다.
하위 클래스 (Concrete Creator): 팩토리 메소드를 구체적으로 구현하여 특정 객체를 생성합니다.

// 상위 클래스
public abstract class PizzaStore {
    protected abstract Pizza createPizza(String type);

    public Pizza orderPizza(String type) {
        Pizza pizza = createPizza(type);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}

// 하위 클래스
public class NYPizzaStore extends PizzaStore {
    @Override
    protected Pizza createPizza(String type) {
        if (type.equals("cheese")) {
            return new NYStyleCheesePizza();
        } else if (type.equals("veggie")) {
            return new NYStyleVeggiePizza();
        }
        // 추가적인 피자 타입들
        return null;
    }
}

추상 팩토리 패턴

추상 팩토리 패턴은 관련된 객체들의 군을 생성하기 위한 인터페이스를 제공하며, 구체적인 클래스는 이 인터페이스를 구현하여 객체 군을 생성합니다. 이는 객체들이 서로 관련되어 있거나 의존적인 경우에 유용합니다.

구조

추상 팩토리 (Abstract Factory): 객체 군을 생성하기 위한 인터페이스를 정의합니다.
구체 팩토리 (Concrete Factory): 이 인터페이스를 구현하여 특정 객체 군을 생성합니다.
추상 제품 (Abstract Product): 생성될 객체의 인터페이스를 정의합니다.
구체 제품 (Concrete Product): 이 인터페이스를 구현하여 구체적인 객체를 정의합니다.

// 추상 팩토리
public interface PizzaIngredientFactory {
    Dough createDough();
    Sauce createSauce();
    Cheese createCheese();
    Veggies[] createVeggies();
    Pepperoni createPepperoni();
    Clams createClam();
}

// 구체 팩토리
public class NYPizzaIngredientFactory implements PizzaIngredientFactory {
    @Override
    public Dough createDough() {
        return new ThinCrustDough();
    }

    @Override
    public Sauce createSauce() {
        return new MarinaraSauce();
    }

    @Override
    public Cheese createCheese() {
        return new ReggianoCheese();
    }

    @Override
    public Veggies[] createVeggies() {
        Veggies[] veggies = { new Garlic(), new Onion(), new Mushroom(), new RedPepper() };
        return veggies;
    }

    @Override
    public Pepperoni createPepperoni() {
        return new SlicedPepperoni();
    }

    @Override
    public Clams createClam() {
        return new FreshClams();
    }
}

// 추상 제품
public interface Dough {}
public interface Sauce {}
public interface Cheese {}
public interface Veggies {}
public interface Pepperoni {}
public interface Clams {}

// 구체 제품
public class ThinCrustDough implements Dough {}
public class MarinaraSauce implements Sauce {}
public class ReggianoCheese implements Cheese {}
public class Garlic implements Veggies {}
public class Onion implements Veggies {}
public class Mushroom implements Veggies {}
public class RedPepper implements Veggies {}
public class SlicedPepperoni implements Pepperoni {}
public class FreshClams implements Clams {}

// 피자 클래스
public abstract class Pizza {
    String name;
    Dough dough;
    Sauce sauce;
    Veggies[] veggies;
    Cheese cheese;
    Pepperoni pepperoni;
    Clams clam;

    abstract void prepare();

    void bake() {
        System.out.println("Baking " + name);
    }

    void cut() {
        System.out.println("Cutting " + name);
    }

    void box() {
        System.out.println("Boxing " + name);
    }

    void setName(String name) {
        this.name = name;
    }

    String getName() {
        return name;
    }

    public String toString() {
        return "Pizza name: " + name;
    }
}

// 구체 피자 클래스
public class CheesePizza extends Pizza {
    PizzaIngredientFactory ingredientFactory;

    public CheesePizza(PizzaIngredientFactory ingredientFactory) {
        this.ingredientFactory = ingredientFactory;
    }

    @Override
    void prepare() {
        System.out.println("Preparing " + name);
        dough = ingredientFactory.createDough();
        sauce = ingredientFactory.createSauce();
        cheese = ingredientFactory.createCheese();
    }
}

// 피자 스토어 클래스
public abstract class PizzaStore {
    protected abstract Pizza createPizza(String item);

    public Pizza orderPizza(String type) {
        Pizza pizza = createPizza(type);
        System.out.println("--- Making a " + pizza.getName() + " ---");
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}

public class NYPizzaStore extends PizzaStore {
    @Override
    protected Pizza createPizza(String item) {
        Pizza pizza = null;
        PizzaIngredientFactory ingredientFactory = new NYPizzaIngredientFactory();

        if (item.equals("cheese")) {
            pizza = new CheesePizza(ingredientFactory);
            pizza.setName("New York Style Cheese Pizza");
        }
        // 다른 피자 타입도 추가 가능
        return pizza;
    }
}

요약

팩토리 메소드 패턴: 객체 생성의 책임을 서브클래스로 위임하여, 객체 생성 로직을 캡슐화합니다. 하나의 객체를 생성하는 데 사용됩니다.
추상 팩토리 패턴: 관련된 객체들의 군을 생성하기 위한 인터페이스를 제공하여, 객체 생성의 책임을 구체 팩토리 클래스로 위임합니다. 여러 객체를 생성하는 데 사용됩니다.

두 패턴 모두 객체 생성 로직을 캡슐화하여 코드의 유연성과 확장성을 높이는 데 도움을 줍니다.

그러나 팩토리 메소드 패턴은 단일 객체 생성에, 추상 팩토리 패턴은 관련 객체들의 군을 생성하는 데 더 적합합니다.

https://www.youtube.com/watch?v=eSLrZbPHgoI

[개발서적] 헤드퍼스트 디자인 패턴 Ch3. 데코레이터(Decorator) 패턴

SWKo — Sun, 28 Jul 2024 14:47:04 +0900

1. 초대형 커피 전문점, 스타버즈

현재는 매우 많은 스타버즈 매장이 존재합니다.

하지만 워낙 빠르게 성장하다보니 다양한 음료를 모두 포괄하는 주문 시스템을 갖추지 못했습니다.

초기 주문 시스템 클래스는 아래와 같았습니다.

Beverage는 음료를 나타내는 추상 클래스이며, 모든 음료는 Beverage 클래스의 서브클래스가 됩니다.

모든 서브클래스는 가격을 리턴하는 cost() 메소드를 구현해야 합니다.

// Beverage.java
public abstract class Beverage {
    String description = "Unknown Beverage";

    public String getDescription() {
        return description;
    }

    public abstract double cost();
}

// HouseBlend.java
public class HouseBlend extends Beverage {
    public HouseBlend() {
        description = "House Blend Coffee";
    }

    public double cost() {
        return .89;
    }
}

// DarkRoast.java
public class DarkRoast extends Beverage {
    public DarkRoast() {
        description = "Dark Roast Coffee";
    }

    public double cost() {
        return .99;
    }
}

이렇게 되면, 커피에 첨가물이 추가될 때마다 새로운 Class가 필요합니다.

만약 우유 가격이 인상되면 어떨까요? 클래스를 모두 수정해줘야 합니다.

그러면, Beverage 클래스에 각 첨가물 첨가 여부를 보여주는 인스턴스 변수를 추가해보겠습니다.

// 기본 Beverage 클래스
class Beverage {
    private String description = "Unknown Beverage";
    private double baseCost = 0.0;
    private boolean hasMilk = false;
    private boolean hasSoy = false;

    // 기본 생성자
    public Beverage(String description, double baseCost) {
        this.description = description;
        this.baseCost = baseCost;
    }

    // 설명 반환
    public String getDescription() {
        return description;
    }

    // Milk 추가 여부 설정
    public void setMilk(boolean hasMilk) {
        this.hasMilk = hasMilk;
    }

    // Soy 추가 여부 설정
    public void setSoy(boolean hasSoy) {
        this.hasSoy = hasSoy;
    }

    // 총 비용 계산
    public double cost() {
        double totalCost = baseCost;
        if (hasMilk) {
            totalCost += 0.50; // Milk 추가 비용
        }
        if (hasSoy) {
            totalCost += 0.30; // Soy 추가 비용
        }
        return totalCost;
    }
}

// Espresso 클래스
class Espresso extends Beverage {
    public Espresso() {
        super("Espresso", 1.99);
    }
}

// HouseBlend 클래스
class HouseBlend extends Beverage {
    public HouseBlend() {
        super("House Blend", 0.89);
    }
}

// 메인 클래스
public class CoffeeShop {
    public static void main(String[] args) {
        // 에스프레소 주문
        Beverage beverage1 = new Espresso();
        beverage1.setMilk(true); // 밀크 추가
        System.out.println(beverage1.getDescription() + " $" + beverage1.cost());

        // 하우스 블렌드 주문
        Beverage beverage2 = new HouseBlend();
        beverage2.setSoy(true); // 소이 추가
        beverage2.setMilk(true); // 밀크 추가
        System.out.println(beverage2.getDescription() + " $" + beverage2.cost());
    }
}

클래스 수는 줄었지만 문제점이 몇가지 있습니다.

첨가물 가격이 바뀔 때마다 기존 코드를 수정해야 합니다.
첨가물의 종류가 많아지면 새로운 메소드를 추가해야 하고, 슈퍼클래스의 cost() 메소드도 수정해야 합니다.
특정 첨가물이 들어가면 안되는 음료가 출시될 수도 있습니다. 새로 출시될 아이스티 같은 경우 hasWhip() 메소드가 필요없지만 여전히 상속되는 문제가 있습니다.

2. OCP (Open-Closed Principle)

디자인 원칙
클래스는 확장에 열려 있어야 하지만, 변경에는 닫혀 있어야 한다.

https://inpa.tistory.com/entry/OOP-%F0%9F%92%A0-%EC%95%84%EC%A3%BC-%EC%89%BD%EA%B2%8C-%EC%9D%B4%ED%95%B4%ED%95%98%EB%8A%94-OCP-%EA%B0%9C%EB%B0%A9-%ED%8F%90%EC%87%84-%EC%9B%90%EC%B9%99

완벽하게 이해하는 OCP (개방 폐쇄 원칙)

개방 폐쇄 원칙 - OCP (Open Closed Principle) 개방 폐쇄의 원칙(OCP)이란 기존의 코드를 변경하지 않으면서, 기능을 추가할 수 있도록 설계가 되어야 한다는 원칙을 말한다. 보통 OCP를 확장에 대해서는

inpa.tistory.com

3. 데코레이터 패턴

상속을 사용해서 총 가격을 산출하는 방법은 좋은 방법은 아니었습니다.

특정 음료에서 시작해서 첨가물로 그 음료를 장식(decorate) 해보는 건 어떨까요?

DarkRoast 객체를 가져온다.
Mocha 객체로 장식한다.
Whip 객체로 장식한다.
cost() 메소드를 호출한다.
이때 첨가물의 가격을 계산하는 일은 해당 객체에게 위임한다.

자세히 살펴봅시다.

1. DarkRoast 객체에서 시작합니다.

2. 고객이 모카를 주문했으니 Mocha 객체를 만들고 그 객체로 DarkRoast를 감쌉니다.(장식합니다.)

Mocha 객체는 Decorator 입니다.
Mocha 에도 cost() 메소드가 있고, Mocha가 감싸고 있는 것도 Beverage 객체로 간주할 수 있습니다.(Mocha도 Beverage의 서브클래스)

3. 휘핑크림도 추가했으니 Whip 데코레이터를 만들어 Mocha를 감쌉니다.

4. 이제 가격 계산을 할 때는 Whip의 cost()를 호출하면 됩니다. 그럼 Whip은 그 객체가 장식하고 있는 객체에게 가격 계산을 위임합니다.

정리

데코레이터(Whip, Mocha)의 슈퍼클래스(Beverage)는 자신이 장식하고 있는 객체(DarkRoast)의 슈퍼클래스(Beverage)와 같습니다.
한 객체(DarkRoast)를 여러 개의 데코레이터(Whip, Mocha)로 감쌀 수 있습니다.
데코레이터는 자신이 감싸고 있는 객체와 같은 슈퍼클래스(Beverage)를 가지고 있기에 원래 객체(싸여 있는 객체)가 들어갈 자리에 데코레이터 객체를 넣어도 상관 없습니다.
데코레이터는 자신이 장식하고 있는 객체에게 어떤 행동을 위임하는 일 말고도 추가 작업을 수행할 수 있습니다. (cost() 메소드에서 로깅 등 다른 액션 가능)
객체는 언제든지 감쌀 수 있으므로 실행 중에 필요한 데코레이터를 마음대로 적용할 수 있습니다.

4. 데코레이터 패턴의 정의

데코레이터 패턴(Decorator Pattern)으로 객체에 추가 요소를 동적으로 더할 수 있습니다.

데코레이터를 사용하면 서브클래스를 만들 때보다 훨씬 유연하게 기능을 확장할 수 있습니다.

각 데코레이터 안에는 Component 객체가 들어있습니다. (데코레이터에는 구성 요소의 Reference를 포함한 인스턴스 변수가 있습니다.)

5. 데코레이터 패턴

Beverage 클래스

public abstract class Beverage {
    String description = "제목 없음";

    // 이미 구현된 메서드
    public String getDescription() {
        return description;
    }

    // 서브클래스에서 구현해야 하는 추상 메서드
    public abstract double cost();
}

첨가물(Condiment) 클래스 = 데코레이터 클래스

public abstract class CondimentDecorator extends Beverage {
    Beverage beverage;

    // 모든 첨가물 데코레이터에 getDescription() 메서드를 새로 구현하도록 하기 위해 추상 메서드로 선언
    public abstract String getDescription();
}

음료 클래스

public class Espresso extends Beverage {
    public Espresso() {
        description = "에스프레소";
    }

    public double cost() {
        return 1.99;
    }
}

첨가물 코드 구현

public class Mocha extends CondimentDecorator {
    Beverage beverage;

    // 생성자에서 감싸고자 하는 음료 객체를 전달받아 저장
    public Mocha(Beverage beverage) {
        this.beverage = beverage;
    }

    // 음료 설명에 '모카' 추가
    public String getDescription() {
        return beverage.getDescription() + ", 모카";
    }

    // 음료 가격에 모카 가격 추가
    public double cost() {
        return beverage.cost() + 0.20;
    }
}

주문용 코드

public class StarbuzzCoffee {
    public static void main(String[] args) {
        // 아무것도 넣지 않은 에스프레소를 주문하고 그 음료 설명과 가격을 출력합니다
        Beverage beverage1 = new Espresso();
        System.out.println(beverage1.getDescription() + " $" + beverage1.cost());

        // 다크 로스트 커피에 모카 두 번과 휘핑크림을 추가하여 주문하고, 설명과 가격을 출력합니다
        Beverage beverage2 = new DarkRoast();
        beverage2 = new Mocha(beverage2); // 모카샷 하나 추가
        beverage2 = new Mocha(beverage2); // 모카샷 하나 더 추가
        beverage2 = new Whip(beverage2);  // 휘핑크림 추가
        System.out.println(beverage2.getDescription() + " $" + beverage2.cost());

        // 하우스 블렌드 커피에 두유, 모카, 휘핑크림을 추가하여 주문하고, 설명과 가격을 출력합니다
        Beverage beverage3 = new HouseBlend();
        beverage3 = new Soy(beverage3);   // 두유 추가
        beverage3 = new Mocha(beverage3); // 모카 추가
        beverage3 = new Whip(beverage3);  // 휘핑크림 추가
        System.out.println(beverage3.getDescription() + " $" + beverage3.cost());
    }
}

전체 코드

// Beverage 클래스
public abstract class Beverage {
    String description = "제목 없음";

    // 이미 구현된 메서드
    public String getDescription() {
        return description;
    }

    // 서브클래스에서 구현해야 하는 추상 메서드
    public abstract double cost();
}

// CondimentDecorator 클래스
public abstract class CondimentDecorator extends Beverage {
    Beverage beverage;

    // 모든 첨가물 데코레이터에 getDescription() 메서드를 새로 구현하도록 하기 위해 추상 메서드로 선언
    public abstract String getDescription();
}

// Mocha 클래스
public class Mocha extends CondimentDecorator {
    Beverage beverage;

    public Mocha(Beverage beverage) {
        this.beverage = beverage;
    }

    public String getDescription() {
        return beverage.getDescription() + ", 모카";
    }

    public double cost() {
        return beverage.cost() + 0.20;
    }
}

// Whip 클래스
public class Whip extends CondimentDecorator {
    Beverage beverage;

    public Whip(Beverage beverage) {
        this.beverage = beverage;
    }

    public String getDescription() {
        return beverage.getDescription() + ", 휘핑크림";
    }

    public double cost() {
        return beverage.cost() + 0.30;
    }
}

// Soy 클래스
public class Soy extends CondimentDecorator {
    Beverage beverage;

    public Soy(Beverage beverage) {
        this.beverage = beverage;
    }

    public String getDescription() {
        return beverage.getDescription() + ", 두유";
    }

    public double cost() {
        return beverage.cost() + 0.15;
    }
}

// DarkRoast 클래스
public class DarkRoast extends Beverage {
    public DarkRoast() {
        description = "최고의 다크 로스트 커피";
    }

    public double cost() {
        return 1.99;
    }
}

// Espresso 클래스
public class Espresso extends Beverage {
    public Espresso() {
        description = "에스프레소";
    }

    public double cost() {
        return 1.99;
    }
}

// HouseBlend 클래스
public class HouseBlend extends Beverage {
    public HouseBlend() {
        description = "하우스 블렌드 커피";
    }

    public double cost() {
        return 0.89;
    }
}

// StarbuzzCoffee 클래스
public class StarbuzzCoffee {
    public static void main(String[] args) {
        // 아무것도 넣지 않은 에스프레소를 주문하고 그 음료 설명과 가격을 출력합니다
        Beverage beverage1 = new Espresso();
        System.out.println(beverage1.getDescription() + " $" + beverage1.cost());

        // 다크 로스트 커피에 모카 두 번과 휘핑크림을 추가하여 주문하고, 설명과 가격을 출력합니다
        Beverage beverage2 = new DarkRoast();
        beverage2 = new Mocha(beverage2); // 모카샷 하나 추가
        beverage2 = new Mocha(beverage2); // 모카샷 하나 더 추가
        beverage2 = new Whip(beverage2);  // 휘핑크림 추가
        System.out.println(beverage2.getDescription() + " $" + beverage2.cost());

        // 하우스 블렌드 커피에 두유, 모카, 휘핑크림을 추가하여 주문하고, 설명과 가격을 출력합니다
        Beverage beverage3 = new HouseBlend();
        beverage3 = new Soy(beverage3);   // 두유 추가
        beverage3 = new Mocha(beverage3); // 모카 추가
        beverage3 = new Whip(beverage3);  // 휘핑크림 추가
        System.out.println(beverage3.getDescription() + " $" + beverage3.cost());
    }
}

데코레이터 패턴은 객체의 기능을 쉽게 추가하고 변경할 수 있는 방법을 제공합니다.

이를 통해 객체 간 결합도를 낮추고 코드의 재사용성과 유지보수성을 높일 수 있는 강력한 디자인 패턴입니다.

https://medium.com/@mr.kashif.samman/flexible-and-maintainable-react-native-applications-with-the-decorator-pattern-32d84de576f6

Flexible and Maintainable React / React Native Applications with the Decorator Pattern

In the world of software development, there are many design patterns that developers can use to build better and more maintainable…

medium.com

https://www.youtube.com/watch?v=PU9sr-q8bys

고차 함수
- 예시 : debounce
고차 컴포넌트(HOC)
- 예시 : 인증 여부에 따라 조건부 렌더링을 하는 컴포넌트