[JAVA 디자인패턴] Observer pattern(옵저버 패턴)

데이터의 변경이 발생하였고 변경을 실시간으로 통보해야할 때, OCP를 만족시키면서 데이터의 변경을 통보하는 framework이다.

Observer 패턴을 이해하기 위해, 학생의 점수를 입력하고 최대/최소값을 보여주는 클래스를 작성해보자.

 

public class ScoreRecord {
    private List<Integer> scores = new ArrayList<Integer>();
    private MinMaxView minMaxView;
 
    public void setMinMaxView(MinMaxView minMaxView) {
        this.minMaxView = minMaxView;
    }
 
    public List<Integer> getScores() {
        return scores;
    }
 
    public void addScore(int score){
        scores.add(score);
        minMaxView.update();
    }
    public void deleteScore(int idx){
        scores.remove(idx);
        minMaxView.update();
    }
}

ScoreRecord는 점수를 저장하는 클래스이다. 그리고 ScoreRecord의 addScore를 통해서 점수를 입력하면 내부에 컬렉션에 저장된다.

 

MinMaxView 클래스를 통해서 ScoreRecord의 최대 최소값을 출력해준다. 여기서 중요한 것은, 데이터가 추가/삭제 될때마다 데이터의 현황을 보여준다. 여기서 중요한 것이, 우리가 원하는 기능은 데이터가 변할 때마다 데이터의 현황을 실시간으로 보여주는 기능이다. 병원에서 대기번호를 보면서 기다리는 것을 생각해보자. 누군가 병원에 와서 자신의 이름을 간호사님께 알려드리면, 모니터에 자신의 이름이 올라온다. 그리고 진료를 마치면 이름이 삭제된다. 이렇게 실시간으로 데이터가 입력되고 삭제되는 화면을 원하는 상황이다.

 

max : 100 min : 100
max : 100 min : 80
max : 100 min : 70
max : 100 min : 60
max : 100 min : 40
max : 80 min : 40

 

데이터가 추가될 때마다 최대 최소값을 보여주고 있다. 처음 입력된 100은 컬렉션에 최초로 입력된 값이기 때문에 최대 최소가 모두 100이다. 하지만 점차 데이터가 추가면서 최소값이 변한다. 마지막에 100을 삭제했기 때문에 max가 80으로 바뀐다.

 

항상 그랬던 것처럼, 이와같은 설계가 잘못된 것이 있는지 확인해보자. 클래스가 추가되는 상황을 가정해보면 된다. 평균값을 출력하는 클래스가 추가된다고 생각해보자.

 

public class ScoreRecord {
    private List<Integer> scores = new ArrayList<Integer>();
    private MinMaxView minMaxView;
    private AverageView averageView; //추가되는 코드
 
 
    public void setMinMaxView(MinMaxView minMaxView) {
        this.minMaxView = minMaxView;
    }
 
    //추가되는 코드
    public void setAverageView(AverageView averageView) {
        this.averageView = averageView;
    }
 
    public List<Integer> getScores() {...}
 
    public void addScore(int score){
        scores.add(score);
        minMaxView.update();
        averageView.update();//추가되는 코드
    }
    public void deleteScore(int idx){
        scores.remove(idx);
        minMaxView.update();
        averageView.update(); //추가되는 코드
    }
}

public class AverageView {
    private ScoreRecord scoreRecord;
 
    public void setScoreRecord(ScoreRecord scoreRecord) {
        this.scoreRecord = scoreRecord;
    }
 
    public void update(){
        List<Integer> scores = scoreRecord.getScores();
        double ave = scores.stream().mapToInt(Integer::intValue).average().getAsDouble();
        System.out.println(ave);
 
    }
}

public class Main {
    public static void main(String[] args) {
        ScoreRecord scoreRecord = new ScoreRecord();
        MinMaxView minMaxView = new MinMaxView();
 
        scoreRecord.setMinMaxView(minMaxView);
        minMaxView.setScoreRecord(scoreRecord);
 
        AverageView averageView = new AverageView();
        scoreRecord.setAverageView(averageView);
        averageView.setScoreRecord(scoreRecord);
 
        //....add/delete
    }
}

ScoreRecord에 있는 observer와 관련된 메소드들을 Subject라는 부모 클래스로 만들었다. 그러면 다른 Record들을 만들 때 Subject 클래스를 extend해서 구현하면 된다.

 

클래스 다이어그램의 연관관계가 바뀌었다. 기존에는 ScoreRecord가 Observer를 멤버로 가져야 했다. 왜냐하면 옵저버에게 score정보가 수정되었다는 것을 notify해줘야 하기 때문이다. 하지만, Observer를 관리하는 모든 메소드들을 Subject 클래스로 만들었기 때문에 Observer를 멤버로 가지는 클래스를 Subject 클래스로 바꿔주면 된다.그래서, Observer와 ScoreRecord의 양방향 관계가 단방향 관계로 바뀌었다. 기존에 있던 ScoreRecord에서 Observer의 방향은 Subject를 통해서 간접적으로 표현된다.

 

이 문제를 SRP의 관점에서도 생각해볼만하다. ScoreRecord는 Score를 관리하는 클래스이다. 그런데 해당 클래스에 Observer를 관리하는 메소드들이 추가로 있으면 여러 기능(책임)을 담당하게 된다. ScoreRecord는 점수를 관리하는 클래스로 설계했는데 다른 기능이 있어버린다. 그래서 Subject 클래스를 만들어서 Observer의 기능을 담당하도록 만든다. 그러면 Record 클래스는 Subject 클래스를 extends해서 구현하면 된다.

 

여담이지만, 여기서 한 가지 헷갈릴 수 있는 부분이 있다. Subject 클래스를 extends해서 ScoreRecord를 구현한다고 하자. 그러면 ScoreRecord는 attach, detach, notify에 접근할 수 있다. 그런데 접근할 수 있으면 해당 기능은 ScoreRecord가 가진게 아닌가라고 생각 할수도 있다. 이것은 잘못되었다. 3가지 Observer와 관련된 메서드들이 public으로 선언해서 자식클래스가 부모클래스의 기능에 접근 할 수 있는 것이다. 순수 자식 클래스의 기능이 아니다. 접근의 권한이 있을 뿐이다.

 

두번 째로 생각해봐야하는 문제가 있다. Observer와 ScoreRecord의 연관관계이다. 이를 해결하기 위해서, 프레임워크의 입장에서 생각해보자. 프레임워크는 기본적인 뼈대만을 제공하면 된다. 구체적인 코드를 작성하게 되면 결합도가 증가하게 된다. 하지만 위의 클래스 다이어그램과 같이, Observer 프레임 워크에 특정 애플리케이션 개발자가 작성한 ScoreRecord가 있는 건 말이 안된다. 이러한 설계는 프레임워크 관점에서 말도 안되는 설계이다. 다시 말하지만, 프레임워크는 기본이 되는 뼈대만 제공하면 된다.

 

 

(Subject와 Observer는 프레임워크의 단위로 보아야한다)

애플리케이션 개발자가 Observer 패턴을 구현해야 하는 상황을 생각해보자. 애플리케이션 개발자는 Subject를 부모 클래스로 두어서 Record를 구현하면 되고, Observer 인터페이스를 구현해서 MinMaxView와 같은 View 방식들을 구현하면 된다. Observer 인터페이스와 Subject 클래스는 프레임워크 개발자가 구현한 것이다.

 

다시 말하지만, Observer는 프레임워크이기 때문에 구체적인 코드가 있어서는 안된다. 그래서 Observer 인터페이스를 구현한 클래스(AverageView, MinMaxView)가 관심대상인 Record를 멤버로 가지게 하면 된다.

 

public class ScoreRecord extends Subject {
    private List<Integer> scores = new ArrayList<Integer>();
 
    public List<Integer> getScores() {
        return scores;
    }
 
    public void addScore(int score){
        scores.add(score);
        notifyObservers();
    }
    public void deleteScore(int idx){
        scores.remove(idx);
        notifyObservers();
    }
}
 

public class Subject {
    private List<Observer> observers = new ArrayList<Observer>();
 
    public void attach(Observer observer){
        observers.add(observer);
    }
 
    public void detach(Observer observer){
        observers.remove(observer);
    }
 
    public void notifyObservers(){
        observers.forEach(Observer::update);
    }
}

public interface Observer {
    void update();
}

 

참고문헌

[JAVA 객체지향 디자인 패턴, 정인상]