Observer 패턴

Observer 패턴 

전시간의 싱글톤 패턴에 이어 이번에는 Observer패턴을 사용해보겠다. 

Observer 패턴은 한 클래스를 Observer들이 관찰하고 있다가 관찰받고 있는 클래스에 변화가 발생하면 Observer들을 업데이트를 진행하도록 도와주는 패턴입니다. 

 간단한 구조를 보면 

변화가 생기는 클래스(곳)이 있고 변화가 생기는 곳에 감지하는 클래스들을 등록시켜놓습니다. 변화가 발생하면 등록시켜놓은 옵저버들에게 알려주는 구조입니다.  

클래스 다이어그램을 보여드리겠습니다.

chulsu, YoungHee라는 클래스가 Observer라는 interface를 구현하고 있습니다. (변화가 있는지 관찰하는 역활)

makingChange라는 클래스에서 add라는 메소드를 통해 observer들을 등록한다 여기서는 (철수와 영희)를 등록합니다. 

 makingSon, makingDaughter이라는 변화가 발생하는 메서드가 있고 변화가 발생하면 Allnotify를 통해 철수와 영희를 업데이트해줍니다.  

이번에는 코드를 보겠습니다. 당연히 이 예제 들은 정말 간단한 것이라서 여러분이 실제 개발에서 사용할 때는 많은 연습이 필요할 것입니다.  

<Observer>관찰자 

public interface Observer {
    void update(makingChange makingChange);
}

<Chulsu & YoungHee) (구체적인 관찰자) Observer

public class chulsu implements  Observer{
    @Override //Observer의 Update를 구현하고 있다.
    public void update(makingChange makingChange) {
        System.out.println("Chulsu: mySon "+makingChange.mySon +"myDaughter "+makingChange.myDaughter);
    }
}

public class YeoungHee implements Observer{
    @Override
    public void update(makingChange makingChange) {
        System.out.println("YoungHee: mySon "+makingChange.mySon +"myDaughter "+makingChange.myDaughter);
    }
}

<MakingChange> (관찰 대상자)변화가 발생하는 곳

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

public class MakingChange {
    int mySon = 0;
    int myDaughter = 0;
    ArrayList observers = new ArrayList();

    public void add(Observer o){
        observers.add(o); //관찰자(YoungHee & Chulsu)를 등록한다.
    }

    public void makingSon(){
        this.mySon+=1;
        Allnotify();
    }

    public void makingDaughter(){
        this.myDaughter+=1;
        Allnotify();//변화가 발생했으니 알림을 준다.
    }//변화가 발생하는 메서드

    public void Allnotify(){
        Iterator it = observers.iterator(); //iterator를 통해 반복문을 돌릴 수 있게한다.
        while (it.hasNext()){
            Observer o = (Observer)it.next(); //등록된 관찰자를 반환한다. 
            o.update(this);
        }
    }

}

<Main>

public class Main {
    public static void main(String[] args){
        YeoungHee yeoungHee = new YeoungHee();
        chulsu chulsu = new chulsu();
        makingChange makingChange = new makingChange();
        makingChange.add(yeoungHee);
        makingChange.add(chulsu); //관찰자를 등록한다. 
        makingChange.makingSon(); // 변화를 만든다. 
        makingChange.makingDaughter(); // 변화를 또 만든다.
    }
}

<Result:출력>

YoungHee: mySon 1myDaughter 0

Chulsu: mySon 1myDaughter 0

YoungHee: mySon 1myDaughter 1

Chulsu: mySon 1myDaughter 1 

Python 

Observer

import abc


class Observer:
    __metaclass__ = abc.ABCMeta

    @abc.abstractmethod
    def update(self, generator):
        pass

ChulsuObserver

from Observer import Observer


class ChulsuObserver(Observer):

    def update(self, generator):
        son = generator.getSon()
        daughter = generator.getDaughter()
        print("chulsu have son: "+ son + " daughter: "+daughter)

YoungHeeObserver

from Observer import Observer


class YoungHeeObserver(Observer):

    def update(self, generator):
        son = generator.getSon()
        daughter = generator.getDaughter()
        print("YoungHee have son: " + son + " daughter: " + daughter)

Generator

import abc


class Generator:
    __metaclass__ = abc.ABCMeta

    def __init__(self):
        self.observers = []

    def add_observer(self, observer):
        self.observers.append(observer)

    def allNotify(self):
        it = iter(self.observers)
        for i in range(len(self.observers)):
            observer = next(it)
            observer.update(self)

    @abc.abstractmethod
    def execute(self):
        pass

    @abc.abstractmethod
    def getSon(self):
        pass

    @abc.abstractmethod
    def getDaughter(self):
        pass

MakingChild

from Generator import Generator
import numpy as np


class MakingChild(Generator):

    def __init__(self):
        super().__init__()
        self.son = 0
        self.daughter = 0

    def getSon(self):
        return str(self.son)

    def getDaughter(self):
        return str(self.daughter)

    def execute(self):
        standard = np.random.randint(2)
        if standard == 0:
            self.son += 1
        else:
            self.daughter += 1
        self.allNotify()

main.py

from MakingChild import MakingChild
from YoungHeeObserver import YoungHeeObserver
from ChulsuObserver import ChulsuObserver

if __name__ == "__main__":
    generator = MakingChild()
    youngHee = YoungHeeObserver()
    chulsu = ChulsuObserver()
    generator.add_observer(youngHee)
    generator.add_observer(chulsu)
    for i in range(5):
        generator.execute()

결과

YoungHee have son: 0 daughter: 1

chulsu have son: 0 daughter: 1

YoungHee have son: 1 daughter: 1

chulsu have son: 1 daughter: 1

YoungHee have son: 1 daughter: 2

chulsu have son: 1 daughter: 2

YoungHee have son: 1 daughter: 3

chulsu have son: 1 daughter: 3

YoungHee have son: 2 daughter: 3

chulsu have son: 2 daughter: 3

철수와 영희 사이에 아들과 딸은 만든 후 관찰자들을 update 시켜주었다. 

이와 같이 특정한 상태의 변화를 계속해서 지켜보고 있다가 변화를 감지하여 update시켜주는 구조를 보았다. 

이 글을 통해 Observer Pattern에 대해 간단히 알아보았다. 사실 내가 블로그에 적는 글들은 간단한 컨셉을 알아 볼 수 있는 예제로 정리 되어있습니다. 나 포함 보시는 분들도 실 개발에 사용하려면 많은 노력과 실패를 거쳐야 구글 개발자님이 말하신 대로 의도하지 않고도 자연스럽게 디자인 패턴을 이용하는 날이 올 것이다........