Design patterns
Beobachter

Bemerkungen

Observer / Java

Mit dem Observer-Muster können Benutzer einer Klasse Ereignisse abonnieren, die auftreten, wenn diese Klasse Daten usw. verarbeitet, und benachrichtigt werden, wenn diese Ereignisse auftreten. Im folgenden Beispiel erstellen wir eine Verarbeitungsklasse und eine Beobachterklasse, die bei der Verarbeitung einer Phrase benachrichtigt wird, wenn Wörter gefunden werden, die länger als 5 Buchstaben sind.

Die LongWordsObserver Schnittstelle definiert den Beobachter. Implementieren Sie diese Schnittstelle, um einen Beobachter für Ereignisse zu registrieren.

// an observe that can be registered and receive notifications
public interface LongWordsObserver {
    void notify(WordEvent event);
}

Die WordEvent Klasse ist das Ereignis, das an die Observer-Klassen gesendet wird, wenn bestimmte Ereignisse eintreten (in diesem Fall wurden lange Wörter gefunden).

// An event class which contains the long word that was found
public class WordEvent {

    private String word;

    public WordEvent(String word) {
        this.word = word;
    }

    public String getWord() {
        return word;
    }
}

Die PhraseProcessor Klasse ist die Klasse, die die angegebene Phrase verarbeitet. Damit können Beobachter mit der addObserver Methode registriert werden. Sobald lange Wörter gefunden werden, werden diese Beobachter mit einer Instanz der WordEvent Klasse WordEvent .

import java.util.ArrayList;
import java.util.List;

public class PhraseProcessor {

    // the list of observers
    private List<LongWordsObserver> observers = new ArrayList<>();

    // register an observer
    public void addObserver(LongWordsObserver observer) {
        observers.add(observer);
    }

    // inform all the observers that a long word was found
    private void informObservers(String word) {
        observers.forEach(o -> o.notify(new WordEvent(word)));
    }

    // the main method - process a phrase and look for long words. If such are found,
    // notify all the observers
    public void process(String phrase) {
        for (String word : phrase.split(" ")) {
            if (word.length() > 5) {
                informObservers(word);
            }
        }
    }
}

Die LongWordsExample Klasse zeigt, wie Sie Beobachter registrieren, die process aufrufen und Warnungen empfangen, wenn lange Wörter gefunden wurden.

import java.util.ArrayList;
import java.util.List;

public class LongWordsExample {

    public static void main(String[] args) {

        // create a list of words to be filled when long words were found
        List<String> longWords = new ArrayList<>();

        // create the PhraseProcessor class
        PhraseProcessor processor = new PhraseProcessor();

        // register an observer and specify what it should do when it receives events,
        // namely to append long words in the longwords list
        processor.addObserver(event -> longWords.add(event.getWord()));

        // call the process method 
        processor.process("Lorem ipsum dolor sit amet, consectetuer adipiscing elit");

        // show the list of long words after the processing is done
        System.out.println(String.join(", ", longWords));
        // consectetuer, adipiscing
    }
}

Observer mit IObservable und IObserver (C #)

IObserver<T> und IObservable<T> -Schnittstellen können verwendet werden, um Observer-Pattern in .NET zu implementieren

• IObservable<T> -Schnittstelle stellt die Klasse dar, die Benachrichtigungen sendet
• IObserver<T> -Schnittstelle steht für die Klasse, die sie empfängt

public class Stock {
  private string Symbol { get; set; }
  private decimal Price { get; set; }
}

public class Investor : IObserver<Stock> {
  public IDisposable unsubscriber;
  public virtual void Subscribe(IObservable<Stock> provider) {
    if(provider != null) {
      unsubscriber = provider.Subscribe(this);
    }
  }
  public virtual void OnCompleted() {
    unsubscriber.Dispose();
  }
  public virtual void OnError(Exception e) {
  }
  public virtual void OnNext(Stock stock) {
  }
}

public class StockTrader : IObservable<Stock> {
  public StockTrader() {
    observers = new List<IObserver<Stock>>();
  }
  private IList<IObserver<Stock>> observers;
  public IDisposable Subscribe(IObserver<Stock> observer) {
    if(!observers.Contains(observer)) {
      observers.Add(observer);
    }
    return new Unsubscriber(observers, observer);
  }
  public class Unsubscriber : IDisposable {
    private IList<IObserver<Stock>> _observers;
    private IObserver<Stock> _observer;

    public Unsubscriber(IList<IObserver<Stock>> observers, IObserver<Stock> observer) {
      _observers = observers;
      _observer = observer;
    }

    public void Dispose() {
      Dispose(true);
    }
    private bool _disposed = false;
    protected virtual void Dispose(bool disposing) {
      if(_disposed) {
        return;
      }
      if(disposing) {
        if(_observer != null && _observers.Contains(_observer)) {
          _observers.Remove(_observer);
        }
      }
      _disposed = true;
    }
  }
  public void Trade(Stock stock) {
    foreach(var observer in observers) {
      if(stock== null) {
        observer.OnError(new ArgumentNullException());
      }
      observer.OnNext(stock);
    }
  }
  public void End() {
    foreach(var observer in observers.ToArray()) {
      observer.OnCompleted();
    }
    observers.Clear();
  }
}

Verwendungszweck

...
var provider = new StockTrader();
var i1 = new Investor();
i1.Subscribe(provider);
var i2 = new Investor();
i2.Subscribe(provider);

provider.Trade(new Stock());
provider.Trade(new Stock());
provider.Trade(null);
provider.End();
...

REF: Entwurfsmuster und -praktiken in .NET: das Observer-Muster