Sök…


Anmärkningar

ange bildbeskrivning här

Vad är avsikten?

  • Anta principen om separering av oro.
  • Skapa en åtskillnad mellan motivet och observatören.
  • Låt flera observatörer reagera för att ändra ett enda ämne.

Vad är strukturen?

  • Ämnet ger ett sätt att registrera, avregistrera, meddela.
  • Observer ger ett sätt att uppdatera.

Observatör / Java

Observatörsmönstret låter användare av en klass prenumerera på händelser som händer när den här klassen bearbetar data etc. och meddelas när dessa händelser inträffar. I följande exempel skapar vi en behandlingsklass och en observatörsklass som kommer att meddelas vid bearbetning av en fras - om den hittar ord som är längre än 5 bokstäver.

LongWordsObserver gränssnittet definierar observatören. Implementera detta gränssnitt för att registrera en observatör till händelser.

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

WordEvent klassen är händelsen som kommer att skickas till observatörsklasserna när vissa händelser inträffar (i det här fallet hittades långa ord)

// 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;
    }
}

PhraseProcessor klassen är den klass som behandlar den givna frasen. Det gör att observatörer kan registreras med metoden addObserver . När långa ord har hittats kommer dessa observatörer att kallas med en instans av WordEvent klassen.

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);
            }
        }
    }
}

LongWordsExample visar hur man registrerar observatörer, ringer process och tar emot varningar när långa ord hittades.

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
    }
}

Observatör som använder IObservable och IObserver (C #)

IObserver<T> och IObservable<T> gränssnitt kan användas för att implementera observatörsmönster i .NET

  • IObservable<T> -gränssnittet representerar klassen som skickar aviseringar
  • IObserver<T> gränssnitt representerar klassen som tar emot dem
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();
  }
}

Användande

...
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: Design mönster och praxis i .NET: Observer-mönstret



Modified text is an extract of the original Stack Overflow Documentation
Licensierat under CC BY-SA 3.0
Inte anslutet till Stack Overflow