Eine generische observer-pattern in Java

Den java.util.Observer und java.util.Observable sind hässlich. Sie benötigen die Art von Abgüssen, die Typ-Sicherheit-fans unangenehm auf, und man kann nicht definieren Sie eine Klasse, um ein Observer mehrerer Dinge ohne hässliche casts. In der Tat, in "Wie weiß ich, dass das generische Objekt, das der Beobachter-Klasse sendet, die in Java?", ein Beantworter sagt, dass nur eine Art von Daten verwendet werden soll in jedem observer /observable.

Ich versuche zu machen, eine generische version des observer-pattern in Java zu bekommen, um beide dieser Probleme. Es ist nicht anders als der in der zuvor genannten post, aber diese Frage wurde offensichtlich nicht behoben (der Letzte Kommentar ist eine unbeantwortete Frage aus dem OP).

Missing link in der letzten Zeile?
Ich vermute, dass dies unmöglich ist ordentlich, ohne eine Sprache-Erweiterung.

InformationsquelleAutor hcarver | 2012-11-13

Ich lieber mit einer annotation, so ein Zuhörer hören können, um verschiedene Arten von Veranstaltungen.

public class BrokerTestMain {
    public static void main(String... args) {
        Broker broker = new Broker();
        broker.add(new Component());

        broker.publish("Hello");
        broker.publish(new Date());
        broker.publish(3.1415);
    }
}

class Component {
    @Subscription
    public void onString(String s) {
        System.out.println("String - " + s);
    }

    @Subscription
    public void onDate(Date d) {
        System.out.println("Date - " + d);
    }

    @Subscription
    public void onDouble(Double d) {
        System.out.println("Double - " + d);
    }
}

Drucke

String - Hello
Date - Tue Nov 13 15:01:09 GMT 2012
Double - 3.1415

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Subscription {
}

public class Broker {
    private final Map<Class, List<SubscriberInfo>> map = new LinkedHashMap<Class, List<SubscriberInfo>>();

    public void add(Object o) {
        for (Method method : o.getClass().getMethods()) {
            Class<?>[] parameterTypes = method.getParameterTypes();
            if (method.getAnnotation(Subscription.class) == null || parameterTypes.length != 1) continue;
            Class subscribeTo = parameterTypes[0];
            List<SubscriberInfo> subscriberInfos = map.get(subscribeTo);
            if (subscriberInfos == null)
                map.put(subscribeTo, subscriberInfos = new ArrayList<SubscriberInfo>());
            subscriberInfos.add(new SubscriberInfo(method, o));
        }
    }

    public void remove(Object o) {
        for (List<SubscriberInfo> subscriberInfos : map.values()) {
            for (int i = subscriberInfos.size() - 1; i >= 0; i--)
                if (subscriberInfos.get(i).object == o)
                    subscriberInfos.remove(i);
        }
    }

    public int publish(Object o) {
        List<SubscriberInfo> subscriberInfos = map.get(o.getClass());
        if (subscriberInfos == null) return 0;
        int count = 0;
        for (SubscriberInfo subscriberInfo : subscriberInfos) {
            subscriberInfo.invoke(o);
            count++;
        }
        return count;
    }

    static class SubscriberInfo {
        final Method method;
        final Object object;

        SubscriberInfo(Method method, Object object) {
            this.method = method;
            this.object = object;
        }

        void invoke(Object o) {
            try {
                method.invoke(object, o);
            } catch (Exception e) {
                throw new AssertionError(e);
            }
        }
    }
}

Dies ist definitiv eine saubere Lösung, aber für mich das Interface-basiert, man fühlt sich wie eine bessere Beschreibung der intention des Kodex. Daran interessiert zu wissen, was Sie denken.
Ich +1 gegeben, Sie zu beantworten und ich denke es ist eine gute Lösung. Seine die Art von Muster, die ich Häufig verwenden. Es ist jedoch begrenzt auf ein broker pro message-Typ, und jeder Zuhörer kann nur einen Typ von Objekt. Es ist nicht so generisch ist, ist dass ein broker, die mit jedem Objekt-Typ und die Zuhörer, die hören können, auf mehrere Arten.
Hatte nicht gedacht, du hast Recht. Danke für die Antwort, sehr nützlich für mich, hoffentlich auf andere Menschen zu.

InformationsquelleAutor Peter Lawrey

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

Hoffentlich wird nützlich sein, um jemanden.

Warum würden Sie das tun if(!contains) { return; } then add() wenn Sie könnten nur if (contains) { add(); }. Außerdem sollten Sie einen text hinzufügen, um Ihre IllegalArgumentException
Denke mal du meinst if(contains) ersten mal und if(!contains) die zweite Runde. Da ich lieber den Stil, das ist alles. Es macht keinen Unterschied. Und, ja, ich werde Bearbeiten Sie die Antwort mit prall-text für die Ausnahme.
Hey @Alex, denken, dass Ihre ! ist immer noch an der falschen Stelle. 🙂
perfekt... boom!! Ich denke, es wäre gut, verwenden wir Set<T> anstelle von List<T> behandeln Einzigartigkeit.

InformationsquelleAutor hcarver

5

Ein modernes update: ReactiveX ist eine sehr gute API für die asynchrone Programmierung basiert auf dem Observer-Muster, und es ist vollständig generisch. Wenn Sie mit Observer/Observable zu "streamen" von Daten oder Ereignissen, die von einer Stelle in Ihrem code zu einem anderen, sollten Sie auf jeden Fall hinein.

Es basiert auf der funktionalen Programmierung, so dass es aussieht sehr elegant mit Java 8 lambda-syntax:
```
Observable.from(Arrays.asList(1, 2, 3, 4, 5))
        .reduce((x, y) -> x + y)
        .map((v) -> "DecoratedValue: " + v)
        .subscribe(System.out::println);
```
- +1 für ReactiveX, auch dies kann verwendet werden, für Android zu entwickeln 😉 (zum Beispiel via github.com/ReactiveX/RxAndroid)
InformationsquelleAutor Lynn
3

Einmal habe ich eine generische Implementierung des observer-Musters für Java mit dynamische proxies. Hier ist ein Beispiel wie es verwendet werden könnte:
```
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);
    }
}
```
Den full-source-code von AbstractObservable ist auf pastebin. Weg zurück ich darüber gebloggt, wie es funktioniert, ein bisschen mehr detail, auch unter Bezugnahme auf Verwandte Projekte.

Jaana schrieb eine interessante Zusammenfassung der verschiedenen Ansätze, auch den Kontrast zu dem dynamischen proxy-Ansatz mit anderen. Viel Dank natürlich geht zu Allain Lalonde aus, die ich die ursprüngliche Idee,. Ich habe noch nicht ausgecheckt PerfectJPattern, aber es könnte nur enthalten eine stabile Implementierung des observer-Musters; zumindest scheint es wie eine ausgereifte Bibliothek.

InformationsquelleAutor Steven Jeuris

Versuchen, Klasse EventBus von Guave.

Können Sie erklären, ein Beobachter so:

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

Neuen ein EventBus wie diese:

EventBus eventBus = new EventBus();

Und registrieren Beobachter so:

eventBus.register(new EventObserver());

Letzten Benachrichtigen Beobachter wie:

eventBus.post(message);

InformationsquelleAutor Kedron

Fand ich eine ähnliche Anfrage, aber es war eher auf codereview.
Ich denke, es ist erwähnenswert es hier.

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

Original Antwort von codereview stackexchange

InformationsquelleAutor neo7

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.