guava学习(一)：观察者模式

public class MyObserver implements Observer {
    public void update(Observable o, Object arg) {        if (o instanceof MyObservable){            System.out.println(arg);        }
    }}

public class MyObservable extends Observable {
    @Override    public void notifyObservers(Object message){        super.setChanged();        super.notifyObservers(message);    }
}

public class Subject {
    private Observable observable = new MyObservable();
    public void registerObserver(MyObserver observer) {        observable.addObserver(observer);    }
    public void removeObserver(MyObserver observer) {        observable.deleteObserver(observer);    }
    public void notifyObservers(String message) {        observable.notifyObservers(message);    }}

public static void main(String[] args) {        Subject subject = new Subject();        MyObserver observer = new MyObserver();        subject.registerObserver(observer);        subject.notifyObservers("hi, I am subject Observable");}

public class AObserver {
    Logger logger = LoggerFactory.getLogger(getClass());
    @Subscribe    public void handleMessage(String msg){        logger.info("a obsesrver receive message:{}", msg);    }}
public class BObserver {
    Logger logger = LoggerFactory.getLogger(getClass());
    @Subscribe    public void handleMessage(String msg){        logger.info("b obsesrver receive message:{}", msg);    }}

public class EventBusUtil {
    public static EventBus getEventBus(){        return EventBusFactory.getAsyncInstance();    }
    public static class EventBusFactory{        private static EventBus asyncEventBus = new AsyncEventBus(LocalThreadPoolExecutor.getExecutor());        private static EventBus syncEventBus = new AsyncEventBus(MoreExecutors.directExecutor());
        public static EventBus getAsyncInstance(){            return asyncEventBus;        }
        public static EventBus getyncInstance(){            return syncEventBus;        }
    }}

public static void main(String[] args){        EventBus eventBus = EventBusUtil.getEventBus();        eventBus.register(new AObserver());        eventBus.register(new BObserver());
        for (int j = 0; j < 2; j ++){            eventBus.post("hi, observer" + j);        }    }

/**   * Registers all subscriber methods on {@code object} to receive events.   *   * @param object object whose subscriber methods should be registered.   */  public void register(Object object) {    subscribers.register(object);  }

  /** Registers all subscriber methods on the given listener object. */  void register(Object listener) {  //获取所有加了@Subscribe注解的方法    Multimap<Class<?>, Subscriber> listenerMethods = findAllSubscribers(listener);
    for (Entry<Class<?>, Collection<Subscriber>> entry : listenerMethods.asMap().entrySet()) {      Class<?> eventType = entry.getKey();      Collection<Subscriber> eventMethodsInListener = entry.getValue();
      CopyOnWriteArraySet<Subscriber> eventSubscribers = subscribers.get(eventType);
      if (eventSubscribers == null) {//还没有注册        CopyOnWriteArraySet<Subscriber> newSet = new CopyOnWriteArraySet<>();        eventSubscribers =            MoreObjects.firstNonNull(subscribers.putIfAbsent(eventType, newSet), newSet);      }
      eventSubscribers.addAll(eventMethodsInListener);    }  }

/**   * Posts an event to all registered subscribers. This method will return successfully after the   * event has been posted to all subscribers, and regardless of any exceptions thrown by   * subscribers.   *   * <p>If no subscribers have been subscribed for {@code event}'s class, and {@code event} is not   * already a {@link DeadEvent}, it will be wrapped in a DeadEvent and reposted.   *   * @param event event to post.   */  public void post(Object event) {    Iterator<Subscriber> eventSubscribers = subscribers.getSubscribers(event);    if (eventSubscribers.hasNext()) {      dispatcher.dispatch(event, eventSubscribers);    } else if (!(event instanceof DeadEvent)) {      // the event had no subscribers and was not itself a DeadEvent      post(new DeadEvent(this, event));    }  }

/** Global event queue. */    private final ConcurrentLinkedQueue<EventWithSubscriber> queue =        Queues.newConcurrentLinkedQueue();
    @Override    void dispatch(Object event, Iterator<Subscriber> subscribers) {      checkNotNull(event);      while (subscribers.hasNext()) {        queue.add(new EventWithSubscriber(event, subscribers.next()));      }
      EventWithSubscriber e;      while ((e = queue.poll()) != null) {        e.subscriber.dispatchEvent(e.event);      }    }

/** Dispatches {@code event} to this subscriber using the proper executor. */  final void dispatchEvent(final Object event) {    executor.execute(        new Runnable() {          @Override          public void run() {            try {              invokeSubscriberMethod(event);            } catch (InvocationTargetException e) {              bus.handleSubscriberException(e.getCause(), context(event));            }          }        });  }

@VisibleForTesting  void invokeSubscriberMethod(Object event) throws InvocationTargetException {    try {      method.invoke(target, checkNotNull(event));    } catch (IllegalArgumentException e) {      throw new Error("Method rejected target/argument: " + event, e);    } catch (IllegalAccessException e) {      throw new Error("Method became inaccessible: " + event, e);    } catch (InvocationTargetException e) {      if (e.getCause() instanceof Error) {        throw (Error) e.getCause();      }      throw e;    }  }