java.util.Observerとはjava.util.Observable醜いです。タイプセーフのファンを不快にするようなキャストが必要であり、Observer醜いキャストなしではクラスを複数のものとして定義することはできません。実際、「Observer クラスが Java で送信する汎用オブジェクトをどのように知ることができますか?」では、回答者は、各オブザーバー/オブザーバブルで 1 種類のデータのみを使用する必要があると述べています。
これらの問題を回避するために、Java でオブザーバー パターンの汎用バージョンを作成しようとしています。前述の投稿のものと同じですが、その質問は明らかに解決されていません (最後のコメントは OP からの未回答の質問です)。
オブザーバー.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);
}
}
}
うまくいけば、これは誰かに役立つでしょう。
リスナーがさまざまなタイプのイベントをリッスンできるように、アノテーションを使用することを好みます。
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);
}
}
}
}
最新の更新: 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);
Guava のクラス EventBus を使用してみてください。
Observer は次のように宣言できます。
public class EventObserver {
@Subscribe
public void onMessage(Message message) {
...
}
}
次のような EventBus を新規作成します。
EventBus eventBus = new EventBus();
Observer を次のように登録します。
eventBus.register(new EventObserver());
最後にオブザーバーに次のように通知します。
eventBus.post(message);
私は以前、動的プロキシーを使用して Java のオブザーバー・パターンの一般的な実装を作成しました。使用方法のサンプルを次に示します。
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 は、さまざまなアプローチの興味深い要約を書き、動的プロキシ アプローチを他のアプローチと対比させています。もちろん、私が最初のアイデアを得たアラン・ラロンドに感謝します。私はまだPerfectJPatternをチェックアウトしていませんが、observer pattern の安定した実装が含まれているだけかもしれません。少なくとも成熟したライブラリのようです。
同様のリクエストを見つけましたが、むしろコードレビューに関するものでした。ここで言及する価値があると思います。
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);
}
}
}