Obserwator (observer) - wzorzec projektowy (design pattern)

I. Wzorce kreacyjne
1. Singleton
2. Budowniczy
3. Prototyp
4. Fabryka
5. Fabryka abstrakcyjna
II. Wzorce strukturalne
1. Adapter
2. Most
3. Kompozyt
4. Dekorator
5. Fasada
6. Pyłek
7. Pełnomocnik
III. Wzorce czynnościowe
1. Łańcuch zobowiązań
2. Polecenie
3. Interpreter
4. Iterator
5. Mediator
6. Pamiątka
7. Obserwator
8. Stan
9. Strategia
10. Metoda szablonowa
11. Odwiedzający

Obserwator (observer) - wzorzec projektowy (design pattern) - java

1. Cel:
Wzorzec Obserwator (observer) to wzorzec w którym mamy przedmiot (subject),
który jest obserwowany przez jednego lub więcej obserwatorów.
Często używany w MVC gdzie widok (View) jest sterowane zdarzeniami.
2. Problem:
Chcemy mieć temat (subject) który jest oddzielony od objektu.
Jest to relacja jeden do wielu. Zaimplementowany jako obsługa zdarzeń.
Można to nazwać obsługą wydawcy (Publisher) i abonentów (Subscriber),
choć ten wzorzec jest typowo synchroniczny.

3. Rozwiązanie:
Wzorzec składa się z następujących elementów:
Temat (Subject): Zwykle jest to interfejs, który musi zostać zaimplementowany przez
klasy i powinien być obserwowany. Zarejestrowani obserwatorzy powinni być powiadomieni.
Mogą być od rejestrowani i wtedy przestają być powiadamiani.
KonkretnyTemat (ConcreteSubject): jest to klasa, która implementuje interfejs tematu (subject).
Obsługuje listę obserwatorów i informuje ich o zmianach.
Obserwator (Observer): jest to interfejs, który jest implementowany przez obiekty,
które powinny być informowane o zmianach Tematu (subject).
Każdy obserwator powinien zaimplementować metodę update, która informuje go o nowych zmianach stanu.

4. Diagram klas wzorca Obserwator (observer):

5. Implementacja:
Klasa testująca:

public class ObserverTest {
    public static void main(String[] args)
    {
        Observer sub1 = new ConcrateObserver("Sub1");
        Observer sub2 = new ConcrateObserver("Sub2");
        Observer sub3 = new ConcrateObserver("Sub3");
 
        Subject p = new ConcrateSubject();
 
        p.attach(sub1);
        p.attach(sub2);
        // Sub1 i Sub2
        p.notifyUpdate(new Message("Pierwsza wiadomość"));
 
        p.detach(sub1);
        p.attach(sub3);
        // Sub2 i Sub3 (Sub1 został usunięty)
        p.notifyUpdate(new Message("Druga wiadomość"));
    }
}

Klasa pomocnicza:

public class Message
{
    final String messageContent;
 
    public Message (String m) {
        this.messageContent = m;
    }
 
    public String getMessageContent() {
        return messageContent;
    }
}

Implementacja tematu (Subject):

public interface Subject {
    void attach(Observer o);
    void detach(Observer o);
    void notifyUpdate(Message m);
}
 
public class ConcrateSubject implements Subject {
 
    private List<Observer> observers = new ArrayList<>();
 
    @Override
    public void attach(Observer o) {
        observers.add(o);
    }
 
    @Override
    public void detach(Observer o) {
        observers.remove(o);
    }
 
    @Override
    public void notifyUpdate(Message m) {
        for(Observer o: observers) {
            o.update(m);
        }
    }
}

Implementacja obserwatora (Observer):

public interface Observer {
    void update(Message m);
}
 
public class ConcrateObserver implements Observer {
    private String name;
    public ConcrateObserver(String name) {
        this.name = name;
    }
 
    @Override
    public void update(Message m) {
        System.out.println(name + ": " + m.getMessageContent());
    }
}

Wyniki działania programu:
Sub1: Pierwsza wiadomość
Sub2: Pierwsza wiadomość
Sub2: Druga wiadomość
Sub3: Druga wiadomość

6. Zastosowanie w kodzie java:
- java.util.Observer/java.util.Observable
- java.util.EventListener - wszystkie implementacje Swing
- javax.servlet.http.HttpSessionBindingListener
- javax.servlet.http.HttpSessionAttributeListener
- javax.faces.event.PhaseListener