Witam.

Mam taki dylemat z zadeklarowaniem obserwatorów klasy RegistrationUserModel

[PHP] pobierz, plaintext 
 
class RegistrationUserModel implements Observable {
 
    private $observers = array();
    private $status = array();
 
 
    public function attach(Observer $observer) {
 
        $this->observers[ ] = $observer;
 
    }
 
    public function detach(Observer $observer) {
 
        $newobservers = array();
 
        foreach ($this->observers as $obs) {
            if (($obs !== $observer)) :
 
                $newobservers[ ] = $obs;
            endif;
 
            $this->observers = $newobservers;
        }
    }
 
    public function notify() {
 
        foreach ($this->observers as $obs) :
            $obs->update($this);
        endforeach;
    }
 
    private function setStatus($name, $status) {
 
        $this->status[$name][ ] = $status;
    }
 
    public function getStatus($name) {
 
        if (isset($this->status[$name])) :
 
            return $this->status[$name];
 
        endif;
    }
 
/////////////////////////// jakaś logika klasy //////////////////////////////////////
                               /////////////
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
class RegistrationObserver implements Observer {
 
    public function update(Observable $observable) {
 
        $warningMessage = $observable->getStatus('Warning'); // pobiera tablice z zdarzeniem
 
        Registry::register('Warning')->setWarning($warningMessage);  //przekazuje klasie Warning zdarzenie
 
    }
 
}
[PHP] pobierz, plaintext 

Wywołanie metody attach() w konstruktorze klasy centralnej(podmiotu obserwacji) - jest dobrą praktyką?. Czy może lepiej zadeklarować obserwatorów w kontrolerze aplikacji?

Uważam, że taka praktyka jest... niecodzienna. ; )

Metoda attach() powinno być "zwykłą" metodą klasy podmiotu wywoływaną tylko wtedy, gdy nowy obserwator chce się zarejestrować na listę "paCZających" - i ta metoda powinna go zarejestrować.

Szkoda, że nie napisałeś czegoś więcej o swoim projekcie, bo ciężko cokolwiek więcej powiedzieć - no, mogę dodać, że RegistrationObserver wygląda intrygująco [wygląda mi to na high coupling - skąd obserwator pobiera dane? I czy posiada jakieś dane o sobie? Obserwator powinien być całkowicie niezależnym obiektem, który aktualizuje dane (od podmiotu) na których mu zależy]. Ciekawi mnie to, jak rozumiesz wzorzec obserwatora i jak chcesz go zaimplementować do swojej aplikacji.

Gdybyś napisał kilka słów o obserwatorach, wtedy łatwiej byłoby ten temat dalej pociągnąć. Napisz może jakich obserwatorów chciałbyś stworzyć i jak ogólnie widzisz działanie swojej aplikacji ze wzorcem obserwatora.

Mój projekt to prosta niekomercyjna strona firmowa z możliwością rejestracji na własnym MVC.

Tak sobie wymyśliłem, że warto, by było odprężyć model zajmującą się rejestracją nowych użytkowników. RegistrationUserModel to typowy model, "sprawdź, czy istnieje użytkownik w bazie jak nie, to użyj zarejestrowanego obserwatora ->attach()". W wymienionym przykładzie tą operacją jest przesłanie message do użytkownika o zaistniałym "faux pas".

Mój obserwator jest uzależniony od klasy Warning( Registry::register('Warning') - singleton), która zajmuję się przesyłaniem ostrzeżeń klientom, od klas aplikacji. Wiem, że klasa(Warning) mogła, by działać bezpośrednio w klasie RegistrationUserModel, ale chcę poeksperymentować .

W przyszłości zamierzam dodać kilka innych obserwatorów np: statystyki,logi itp.

Załóżmy, że obserwator w moim przykładzie ma własną logikę i jest niezależnym komponentem systemu, gdzie w takim razie powinna odbywać się rejestracja obserwatorów klasy RegistrationUserModel - jak pisałem wyżyj jest to aplikacja oparta na wzorcu MVC.

Hmm, wydaje mnie się, przyjacielu, że chyba sobie troszkę eksperymentujesz z wzorcami. ; )

Wydaje mnie się także, że spoglądasz na wzorzec obserwatora przez pryzmat wzorca MVC. Jeśli chodzi o wzorzec obserwatora, to:

1. W podmiocie powinny znaleźć się:
- metody rejestracji oraz usuwania obserwatorów,
- metody odpowiedzialne za informowanie obserwatorów o tym, że coś się zmieniło (to na czym zależy obserwatorom, to co obserwują).
2. W podmiocie powinny znaleźć się cenne informacje (np. public variables, które są aktualizowane w jakiś sposó dla obserwatorów - w końcu to nimi są zainteresowani.
3. Podmiot obserwacji oraz obserwatorzy powinni być całkowicie niezależni od siebie, tj. podmiot posiada cenne info dla obserwatorów i informuje ich o tym, ze je ma i że następuje jakiś update danych itp, a obserwatorzy po otrzymaniu "cynku" robią aktualizację danych (np. zastępują swoje wartości wartościami podmiotu) i to za pomocą swoich metod.

Musisz się zastanowić, czy w ogóle będzie Ci tutaj potrzebny wzorzec obserwatora. W tym wzorcu obserwatorzy są tak naprawdę oddzielnymi bytami, które są zainteresowane informacjami od podmiotu. Obserwator to obiekt, który podchodzi do podmiotu i mówi mu: "Ej, Zią, słuchaj, jak będziesz wiedział coś o XYZ, to daj mi znać.". Podmiot mówi: "Okay."

Powiedzmy, że Podmiot ma jakąś informację, niech to będzie informacja na temat liczby zarejestrowanych użytkowników. Obserwatorzy są tym zainteresowani i czekają na "cynk". Gdy pojawia się nowy obserwator, wtedy wysyła info do Podmiotu o tym, że jest zainteresowany jego informacjami i żeby Podmiot wpisał go na listę, czyli Podmiot wywołuje metodę rejestracji i zapisuje Obserwatora na swoją listę. Załóżmy, że nagle zarejestruje się nowy użytkownik, wtedy skrypt automatycznie zmienia dane Podmiotu o rejestracji, dodaje +1 do infa o zarejestrowanych użytkownikach, a gdy zmienia się wartość, wtedy Podmiot automatycznie wysyła obserwatorom "cynk" o tym, że liczba się zmieniła - podmiot NIE mówi nawet o tym, o ile się zmieniła ta liczba, tylko po prostu daje cynk: "Ej, coś się zmieniło, zajrzyj do mnie". Wtedy Obserwatorzy zaczynają działać ze swoją logiką. Sami za pomocą swoich metod sprawdzają info o zarejestrowanych użytkownikach i aktualizują te dane.

Tylko pamiętaj, że podmiot ma różne dane, a każdy obserwator może być zainteresowany czymś innym, także warto jest informować o zmianach danych tylko tych obserwatorów, którzy są zainteresowani takimi danymi.

Co do implementacji tego wzorca w Twojej aplikacji - nie znam szczegółów Twojego systemu (logiki działania), także ciężko mi cokolwiek powiedzieć. Głupi nie jesteś, także jak troszkę pogłówkujesz, to z pewnością coś wymyślisz. ; )

Ewentualnie jakbyś chciał powiedzieć coś więcej na temat logiki swojej apki, wtedy moglibyśmy pomyśleć co można tutaj zrobić.

Napisz mi o co chodzi z tą rejestracją? Jakimi informacjami o rejestracji są zainteresowani obserwatorzy? Jakie informacje przekazuje im Podmiot? Najlepiej byłoby, gdybyś napisał jak chciałeś zaimplementować ten wzorzec - chodzi oczywiście o komunikację pomiędzy podmiotem i obserwatorami. Jak to widziałeś?

Nie zawsze interpretacja własnych myśli jest zrozumiała, a więc kod z systemu wzięty.

[PHP] pobierz, plaintext 
interface Observable {
 
    function attach(Observer $observer);
    function detach(Observer $observer);
    function notify();
}
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
 
class RegistrationUserModel implements Observable {
 
    private $observers = array(); // tablica z aktywnymi obserwatorami klasy.
    private $status = array(); // rejestr zachodzących wydarzeń w klasie - na podstawie tej zmiennej obserwatorzy pobierają informacje na temat zdarzenia.
    private $POST;
    private $db;
 
    public function __construct() {
 
        $this->POST = Registry::register('Router')->getParams();
        $this->db = Registry::register('db');
    }
 
    public function attach(Observer $observer) { // w kontrolerze została zadeklarowany obserwator RegistrationUserModel-> attach(new WarningObserver)
 
        $this->observers[] = $observer;
    }
 
    public function detach(Observer $observer) { // nie wiem gdzie to wywoływać
 
        $newobservers = array();
 
        foreach ($this->observers as $obs) {
 
            if (($obs !== $observer)) :
 
                $newobservers[] = $obs;
            endif;
 
            $this->observers = $newobservers;
        }
    }
 
    public function notify() { // informator obserwatorów o zajściu
 
        foreach ($this->observers as $obs) :
            $obs->update($this);
        endforeach;
    }
 
    private function setStatus($nameObserver, $nameStatus, $status) { //rejestruje zdarzenia zachodząca w klasie.
 
        $this->status[$nameObserver][$nameStatus] = $status;
    }
 
    public function getStatus($nameObserver) {
 
        if (isset($this->status[$nameObserver])) :
 
            return $this->status[$nameObserver];
 
        endif;
    }
 
 private function PasswordRepeatedCorrect($password,$password2) {
 
        if ($password === $password2) {
        }
        else {
             $this->setStatus('WarningObserver', __FUNCTION__, 'Hasło nie zgadza się z powtórzonym.');
            return false;
        }
 
        return true;
    }
 
 ////////////////////// reszta metod ////////////////////////
 
 public function saveNewUser() {
 
        if (isset($this->POST['POST']) && $this->isNotEmpty($this->POST['POST']) && (count($this->POST['POST'])) == 12) {
 
            if ($this->isExistsUser($this->POST['POST']['email'], $this->POST['POST']['nick']) && $this->PasswordRepeatedCorrect($this->POST['POST']['password'],$this->POST['POST']['password2'])) {
///// w przypadku zwrócenia false przez metode - jest rejestrowane zdarzenie w tablicy $status.
 
 
  ///////////////////////////////// zapis do bazy ////////////////////////////////////////
            } else {
 
                $this->notify(); 
              // powiadomienie aktywnie zadeklarowanych obserwatorów o zajściu i wykonaniu przez nie metody update()
 
                $this->redirection();
            }
        } else {
 
            $this->setStatus('WarningObserver', __FUNCTION__, 'Proszę wypełnić wszystkie pola formularza.');
            $this->notify();
 
            $this->redirection();
        }
    }
 
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
interface Observer {
 
    function update(Observable $observable);
}
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
class WarningObserver implements Observer {
 
    public function update(Observable $observable) {
 
        $warningMessage = $observable->getStatus('WarningObserver'');
 // pobiera status wydarzeń(tablica z ostrzeżeniami) z podmiotu obserwacji 
 
        Registry::register('Warning')->setWarning($warningMessage);
 // konkretyzacja obiektu Warning i zapis tablicy z ostrzeżeniami.
    }
 
}
[PHP] pobierz, plaintext 

Powinieneś dopieścić obserwatora - on powinien być niezależny, tj. powinien posiadać dane o swoim stanie (podczas tworzenia obiektu obserwatora Podmiot powinien automatycznie nadać jakiś stan obserwatorowi) i aktualizować je od Podmiotu. Oprócz interfejsu Observer powinieneś także stworzyć interfejs szczególny dla danego obserwatora - obserwator powinien tak naprawdę implementować co najmniej dwa interfejsy, tj.

- Interfejs Observer ma zajmować się aktualizacją danych i niczym więcej.
- Dodatkowy interfejs lub interfejsy powinny wykonywać wszelkie wymagane dodatkowe akcje (np. wyświetlać dane, przetwarzać je, czy przekazywać gdzieś dalej).
Adnotacja: Jeśli obserwator nie ma żadnych dodatkowych funkcji, wtedy oczywiście można pominąć dodatkowe interfejsy - jednak jaki jest wtedy sens bytu takiego obserwatora? Obserwator powinien coś zwracać. ; )

Zapoznaj się dobrze z wzorcem obserwatora i zastanów się dwa razy, czy aby na pewno to jest to, czego potrzebujesz w swojej aplikacji. *wink*

Wiadome, że w moim przykładzie observer jest bezsensu, ale dobrze jest czasami zrobić coś w kierunku edukacyjnym .

Jeszcze znalazłem lepszy sposób rejestracji obserwatorów w klasie podmiotu obserwacji.

[PHP] pobierz, plaintext 
 
abstract class RegistrationObserver implements Observer {
 
    private $registration;
 
    public function __construct(RegistrationUserModel $registration) {
 
        $this ->registration = $registration;
        $registration -> attach($this); 
        // Tu zachodzi rejestracja observatora w klasie RegistrationUserModel
 
    }
    abstract public function update (RegistrationUserModel $registration);
}
 
class SecurityMonitor extends RegistrationObserver 
class Statistic extends RegistrationObserver 
class Logs extends RegistrationObserver 
 
new SecurityMonitor ($registration);
new Statistic ($registration);
new Logs ($registration);
 
[PHP] pobierz, plaintext 

Powyższy przykład wydaje mi się bardziej przejrzystszy.

Zawsze można iść na łatwiznę i użyć biblioteki SPL

Ja obiekty obserwatorów tworze dopiero wtedy gdy potrzeba, czyli np. gdy pojawi sie obiekt obserwowany i rzuca konkretnym eventem.
http://nospor.pl/wzorzec-obserwator.html