Un modèle d'observateur Générique En Java

Observateur.java

package util;

public interface Observer<ObservedType> {
    public void update(Observable<ObservedType> object, ObservedType data);
}

Observable.java

package util;

import java.util.LinkedList;
import java.util.List;

public class Observable<ObservedType> {

    private List<Observer<ObservedType>> _observers = 
      new LinkedList<Observer<ObservedType>>();

    public void addObserver(Observer<ObservedType> obs) {
        if (obs == null) {
            throw new IllegalArgumentException("Tried
                      to add a null observer");
        }
        if (_observers.contains(obs)) {
            return;
        }
        _observers.add(obs);
    }

    public void notifyObservers(ObservedType data) {
        for (Observer<ObservedType> obs : _observers) {
            obs.update(this, data);
        }
    }
}

espérons que cela sera utile à quelqu'un.

Une mise à jour moderne: ReactiveX est une très bonne API pour la programmation asynchrone basé sur le pattern observer, et c'est totalement générique. Si vous utilisez Observer/Observable pour "streamer" des données ou des événements d'un endroit dans votre code à un autre, vous devriez certainement regarder dedans.

il est basé sur la programmation fonctionnelle, il semble donc très élégant avec la syntaxe lambda de Java 8:

Observable.from(Arrays.asList(1, 2, 3, 4, 5))
        .reduce((x, y) -> x + y)
        .map((v) -> "DecoratedValue: " + v)
        .subscribe(System.out::println);

j'ai écrit une fois une implémentation générique du pattern observer pour Java en utilisant dynamic proxies . Voici un exemple de la façon dont il pourrait être utilisé:

Gru gru = new Gru();
Minion fred = new Minion();
fred.addObserver(gru);
fred.moo();

public interface IMinionListener
{
    public void laughing(Minion minion);
}

public class Minion extends AbstractObservable<IMinionListener>
{
    public void moo()
    {
        getEventDispatcher().laughing(this);
    }
}

public class Gru implements IMinionListener
{
    public void punch(Minion minion) { ... }

    public void laughing(Minion minion)
    {
        punch(minion);
    }
}

le code source complet D'AbstractObservable est disponible sur pastebin . Je blogué sur la façon dont il fonctionne dans un peu plus de détails , se référant également à des projets connexes.

Jaana a écrit un intéressant résumé des différentes approches , contrastant également l'approche par procuration dynamique avec d'autres. Un grand merci bien sûr va à Allain Lalonde dont j'ai eu l'idée originale . Je n'ai toujours pas vérifié PerfectJPattern , mais il pourrait juste contenir une implémentation stable du pattern d'observateur ; au moins il semble comme une bibliothèque mature.

essayez d'utiliser la classe EventBus De Goyave.

vous pouvez déclarer un observateur comme ceci:

    public class EventObserver {
        @Subscribe 
        public void onMessage(Message message) {
            ...
        }
    }

de Nouvelles un EventBus comme ceci:

EventBus eventBus = new EventBus();

et enregistrer observateur comme ceci:

eventBus.register(new EventObserver());

dernière notification de L'observateur comme:

eventBus.post(message);

j'ai trouvé une demande similaire mais c'était plutôt sur codereview. Je pense qu'il vaut la peine de le mentionner ici.

import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Supplier;

/**
 * like java.util.Observable, But uses generics to avoid need for a cast.
 *
 * For any un-documented variable, parameter or method, see java.util.Observable
 */
public class Observable<T> {

    public interface Observer<U> {
        public void update(Observable<? extends U> observer, U arg);
    }

    private boolean changed = false;
    private final Collection<Observer<? super T>> observers;

    public Observable() {
        this(ArrayList::new);
    }

    public Observable(Supplier<Collection<Observer<? super T>>> supplier) {
        observers = supplier.get();
    }

    public void addObserver(final Observer<? super T> observer) {
        synchronized (observers) {
            if (!observers.contains(observer)) {
                observers.add(observer);
            }
        }
    }

    public void removeObserver(final Observer<? super T> observer) {
        synchronized (observers) {
            observers.remove(observer);
        }
    }

    public void clearObservers() {
        synchronized (observers) {
            this.observers.clear();
        }
    }

    public void setChanged() {
        synchronized (observers) {
            this.changed = true;
        }
    }

    public void clearChanged() {
        synchronized (observers) {
            this.changed = false;
        }
    }

    public boolean hasChanged() {
        synchronized (observers) {
            return this.changed;
        }
    }

    public int countObservers() {
        synchronized (observers) {
            return observers.size();
        }
    }

    public void notifyObservers() {
        notifyObservers(null);
    }

    public void notifyObservers(final T value) {
        ArrayList<Observer<? super T>> toNotify = null;
        synchronized(observers) {
            if (!changed) {
                return;
            }
            toNotify = new ArrayList<>(observers);
            changed = false;
        }
        for (Observer<? super T> observer : toNotify) {
            observer.update(this, value);
        }
    }
}

réponse originale de coderview stackexchange