web-dev-qa-db-ja.com

Javaの一般的なオブザーバーパターン

Java.util.ObserverおよびJava.util.Observable醜いです。それらは型安全ファンを不快にするようなキャストを必要とし、醜いキャストなしにクラスを複数のもののObserverとして定義することはできません。実際、 " ObserverクラスがJavaで送信する汎用オブジェクトを知るにはどうすればよいですか？ "、 回答者によると それぞれで1種類のデータのみを使用する必要がありますオブザーバー/オブザーバブル。

Javaでオブザーバーパターンの汎用バージョンを作成して、これらの両方の問題を回避しようとしています。前述の投稿の問題と同じですが、その質問は明らかに解決されていません（最後のコメントはOPからの未回答の質問です）。

javagenericsobserver-pattern
23
hcarver

リスナーがさまざまな種類のイベントを聞くことができるように、注釈を使用することを好みます。

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

プリント

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

うまくいけば、これは誰かに役立つでしょう。

15
hcarver

最新のアップデート：ReactiveX は、Observerパターンに基づく非同期プログラミング用の非常に優れたAPIであり、完全に汎用的です。 Observer/Observableを使用して、コード内のある場所から別の場所にデータまたはイベントを「ストリーミング」している場合は、必ず調べてください。

関数型プログラミングに基づいているため、Java 8のラムダ構文：

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

私はかつて、Java using dynamic proxies のオブザーバーパターンの一般的な実装を作成しました。これを使用する方法のサンプルを次に示します。

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

AbstractObservableの完全なソースコードはPastebinで入手できます 。さかのぼって それがどのように機能するかについてもう少し詳しくブログに書いています 、関連するプロジェクトも参照しています。

Jaanaはさまざまなアプローチの興味深い要約を書きました また、動的プロキシアプローチを他のアプローチと対比しています。もちろん、大いに感謝します 私が最初のアイデアを得たAllain Lalondeに 。私はまだチェックアウトしていません PerfectJPattern 、しかしそれはただ含まれているかもしれません オブザーバーパターンの安定した実装 ;少なくともそれは成熟した図書館のようです。

3
Steven Jeuris

GuavaのクラスEventBusを使用してみてください。

次のようにオブザーバーを宣言できます。

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

このような新しいEventBus：

EventBus eventBus = new EventBus();

そして、次のようにオブザーバーを登録します。

eventBus.register(new EventObserver());

次のようにオブザーバーに最後に通知します。

eventBus.post(message);
3
Kedron

私は同様のリクエストを見つけましたが、それはむしろコードレビューにありました。ここで言及する価値があると思います。

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

codereview stackexchangeからの元の回答

0
neo7