[디자인 패턴] 행위 패턴 - Observer Pattern (옵저버 패턴)

목차

 

📇 개요

옵저버 패턴(Observer Pattern)은 객체의 상태 변화를 관찰하는 관찰자들(옵저버들)에게 자동으로 통지하는 디자인 패턴이다. 즉, 한 객체의 상태가 변하면 그 객체에 의존하는 다른 객체들에게 자동으로 알림이 가고 자신도 업데이트되는 1:N 의존성을 정의한다.

 

특징

• 발행(Publish)-구독(Subscribe) 모델로도 알려져 있다.
• 느슨한 결합(Loose Coupling) 구조를 만들어 객체 간 의존성을 최소화한다.
• 분산 이벤트 핸들링 시스템을 구현하는 데 이상적이다.

 

👩🏻‍💻 코드로 알아보자

날씨 정보를 수집하고 다양한 디스플레이에 업데이트하는 예제를 통해 옵저버 패턴을 살펴보자.

// 1. 옵저버 인터페이스 (구독자)
interface Observer {
    void update(float temperature, float humidity, float pressure);
}

// 2. 주제(Subject) 인터페이스 (발행자)
interface Subject {
    void registerObserver(Observer o);
    void removeObserver(Observer o);
    void notifyObservers();
}

// 3. 구체적인 주제(ConcreteSubject) 클래스
class WeatherData implements Subject {
    private List<Observer> observers;
    private float temperature;
    private float humidity;
    private float pressure;
    
    public WeatherData() {
        observers = new ArrayList<>();
    }
    
    @Override
    public void registerObserver(Observer o) {
        observers.add(o);
    }
    
    @Override
    public void removeObserver(Observer o) {
        int i = observers.indexOf(o);
        if (i >= 0) {
            observers.remove(i);
        }
    }
    
    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(temperature, humidity, pressure);
        }
    }
    
    // 기상 측정값이 갱신되면 옵저버들에게 알린다
    public void measurementsChanged() {
        notifyObservers();
    }
    
    // 새로운 측정값으로 갱신
    public void setMeasurements(float temperature, float humidity, float pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
        measurementsChanged();
    }
}

// 4. 구체적인 옵저버(ConcreteObserver) 클래스들
class CurrentConditionsDisplay implements Observer {
    private float temperature;
    private float humidity;
    private Subject weatherData;
    
    public CurrentConditionsDisplay(Subject weatherData) {
        this.weatherData = weatherData;
        weatherData.registerObserver(this);
    }
    
    @Override
    public void update(float temperature, float humidity, float pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        display();
    }
    
    public void display() {
        System.out.println("현재 날씨 상태: 온도 " + temperature + "°C, 습도 " + humidity + "%");
    }
}

class StatisticsDisplay implements Observer {
    private float maxTemp = 0.0f;
    private float minTemp = 200;
    private float tempSum = 0.0f;
    private int numReadings = 0;
    private Subject weatherData;
    
    public StatisticsDisplay(Subject weatherData) {
        this.weatherData = weatherData;
        weatherData.registerObserver(this);
    }
    
    @Override
    public void update(float temperature, float humidity, float pressure) {
        tempSum += temperature;
        numReadings++;
        
        if (temperature > maxTemp) {
            maxTemp = temperature;
        }
        
        if (temperature < minTemp) {
            minTemp = temperature;
        }
        
        display();
    }
    
    public void display() {
        System.out.println("날씨 통계: 평균/최고/최저 온도 = " + (tempSum / numReadings) + "/" + maxTemp + "/" + minTemp);
    }
}

class ForecastDisplay implements Observer {
    private float currentPressure = 29.92f;
    private float lastPressure;
    private Subject weatherData;
    
    public ForecastDisplay(Subject weatherData) {
        this.weatherData = weatherData;
        weatherData.registerObserver(this);
    }
    
    @Override
    public void update(float temperature, float humidity, float pressure) {
        lastPressure = currentPressure;
        currentPressure = pressure;
        display();
    }
    
    public void display() {
        System.out.print("일기 예보: ");
        if (currentPressure > lastPressure) {
            System.out.println("날씨가 좋아지고 있습니다!");
        } else if (currentPressure == lastPressure) {
            System.out.println("지금과 비슷할 것 같습니다.");
        } else {
            System.out.println("더 시원하고 비가 올 것 같습니다.");
        }
    }
}

// 5. 클라이언트
public class ObserverPatternExample {
    public static void main(String[] args) {
        // 기상 데이터 객체 생성 (주제)
        WeatherData weatherData = new WeatherData();
        
        // 디스플레이 객체들 생성 (옵저버들)
        CurrentConditionsDisplay currentDisplay = new CurrentConditionsDisplay(weatherData);
        StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);
        ForecastDisplay forecastDisplay = new ForecastDisplay(weatherData);
        
        // 기상 데이터 설정 (이것이 옵저버들에게 자동으로 통지됨)
        System.out.println("첫 번째 기상 데이터 업데이트:");
        weatherData.setMeasurements(27, 65, 30.4f);
        
        System.out.println("\n두 번째 기상 데이터 업데이트:");
        weatherData.setMeasurements(28, 70, 29.2f);
        
        System.out.println("\n세 번째 기상 데이터 업데이트:");
        weatherData.setMeasurements(26, 90, 29.3f);
        
        // 옵저버 제거 예시
        weatherData.removeObserver(forecastDisplay);
        System.out.println("\n일기 예보 제거 후 업데이트:");
        weatherData.setMeasurements(25, 80, 30.6f);
    }
}

• Observer 인터페이스는 모든 옵저버가 구현해야 하는 update() 메서드를 정의한다.
• Subject 인터페이스는 옵저버의 등록, 제거, 통지 메서드를 정의한다.
• WeatherData 클래스는 Subject를 구현하고 기상 데이터가 변경될 때 등록된 모든 옵저버에게 알린다.
• CurrentConditionsDisplay, StatisticsDisplay, ForecastDisplay 클래스는 Observer를 구현하여 날씨 데이터가 업데이트될 때마다 각자의 방식으로 정보를 표시한다.

 

☘️ 장/단점

✅ 장점

1. 느슨한 결합(Loose Coupling)
   • 주제(Subject)는 옵저버(Observer)에 대한 구체적인 클래스를 알 필요가 없다.
   • 옵저버들이 어떤 클래스인지, 무엇을 하는지 몰라도 된다는 것이 핵심이다.
   • 이로 인해 시스템의 유연성과 재사용성이 향상된다.
2. 개방/폐쇄 원칙(OCP) 준수
   • 기존 코드를 수정하지 않고도 새로운 옵저버 클래스를 추가할 수 있다.
   • 예: 새로운 모바일 앱 디스플레이를 추가하더라도 WeatherData 클래스는 변경할 필요가 없다.
3. 런타임에 객체 간 관계 변경 가능
   • 옵저버는 언제든지 동적으로 추가하거나 제거할 수 있다.
   • 이는 실행 중인 시스템의 동작을 유연하게 바꿀 수 있게 해준다.
4. 1:N 의존성 처리에 적합
   • 한 객체의 변경이 다른 여러 객체에 영향을 미칠 때 유용하다.
   • MVC(Model-View-Controller) 아키텍처에서 Model과 View의 관계를 구현할 때 자주 사용된다.

❌ 단점

1. 예측하기 어려운 업데이트 순서
   • 등록된 순서에 따라 옵저버가 업데이트되므로, 특정 순서에 의존하면 문제가 발생할 수 있다.
   • 옵저버 간에 의존성이 있을 경우 예상치 못한 동작이 발생할 수 있다.
2. 메모리 누수 가능성
   • 옵저버 등록 후 명시적으로 제거하지 않으면 메모리 누수가 발생할 수 있다.
   • 특히 자바와 같은 언어에서 옵저버가 더 이상 필요하지 않을 때 참조를 해제해야 한다.
3. 불필요한 업데이트
   • 모든 옵저버에게 항상 통지하므로 일부 옵저버에게는 필요하지 않은 업데이트가 전달될 수 있다.
   • 이는 성능 저하를 초래할 수 있다.
4. 복잡한 디버깅
   • 비동기 방식으로 옵저버를 업데이트하면 디버깅이 어려워질 수 있다.
   • 여러 옵저버가 서로 다른 스레드에서 실행되면 동시성 문제가 발생할 수 있다.

 

📌 정리

옵저버 패턴은 객체 간의 일대다 의존 관계를 정의하여 한 객체의 상태가 변경되면 의존하는 모든 객체에게 자동으로 통지되고 업데이트되는 패턴이다.

이 패턴은 느슨한 결합을 통해 유연성을 높이고, 런타임에 객체 간의 관계를 동적으로 바꿀 수 있게 해준다. 하지만 업데이트 순서 예측의 어려움, 메모리 누수 가능성, 불필요한 업데이트, 디버깅의 복잡성 등의 단점이 있다.

✅ 언제 사용하면 좋을까?

• 한 객체의 변화가 다른 여러 객체에 영향을 미칠 때
• 객체 간의 느슨한 결합이 필요할 때
• 어떤 이벤트가 발생했을 때 다양한 객체들이 다른 방식으로 반응해야 할 때
• 실시간 데이터 전송이 필요한 분산 시스템에서
• MVC 아키텍처에서 모델과 뷰의 관계를 구현할 때

❌ 언제 피해야 할까?

• 옵저버 간에 복잡한 의존성이 있을 때
• 업데이트 순서가 중요할 때
• 불필요한 알림이 성능 문제를 일으킬 수 있을 때
• 메모리 사용량이 중요한 제한된 환경에서

 

💡 자바의 내장 옵저버 패턴

Java에서는 java.util.Observable 클래스와 java.util.Observer 인터페이스를 통해 옵저버 패턴을 지원했으나, Java 9부터 Deprecated되었다. 대신 다음과 같은 대안을 사용할 수 있다:

1. PropertyChangeListener
   • java.beans 패키지의 PropertyChangeSupport와 PropertyChangeListener를 사용
   • 속성 값의 변경을 감지하고 알림을 보내는 데 유용
2. Flow API (Java 9+)
   • java.util.concurrent.Flow에서 리액티브 프로그래밍을 지원
   • Publisher, Subscriber, Subscription 인터페이스를 제공
3. Event Listener
   • Swing, JavaFX 등 GUI 프레임워크에서 사용되는 이벤트 리스너
   • 사용자 인터페이스 이벤트 처리에 적합

 

📚 실제 사용 사례

• GUI 시스템: 버튼 클릭, 키보드 입력과 같은 사용자 이벤트 처리
• 이벤트 관리 시스템: 이벤트 발생 시 여러 핸들러에게 통지
• 뉴스 발행-구독 서비스: 새 뉴스 발행 시 구독자에게 알림
• 소셜 미디어 알림 시스템: 새 활동 발생 시 사용자에게 알림
• 실시간 모니터링 시스템: 시스템 상태 변화를 여러 모니터링 도구에 전달

 

📋 참고

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