1、观察者模式概述：
观察者模式（Observer Pattern）：定义对象之间的一种一对多依赖关系，使得每当一个对象状态发生改变时，其相关依赖对象皆得到通知并自动更新。观察者模式的别名包括发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式。观察者模式是一种对象行为型模式《设计模式的艺术》
使用场景：
观察者模式是使用频率最高的设计模式之一，主要用于建立对象之间的一种一对多的依赖关系。通过发布订阅的方式，实现对象之间的解耦合。主要用于当一个对象状态改变时，另外一个对象会随之变化的场景。一个目标可以对于多个观察者，各个观察者之间互不联系，只关注目标状态的改变。
2、代理模式UML类图：
Subject(抽象目标类)：目标又称之为主题，它是指被观察的对象。在抽象目标类中会定义一个抽象观察者的集合，并定义增加和删除、通知观察者的相关接口。
ConcreteSubject(具体目标)：作为抽象目标类的子类，实现抽象目标类定义的接口。当具体目标状态发生变化时，通过观察者。
Observer(抽象观察者)：所谓所有观察者的公共父类，定义观察者的共同行为接口。
ConcreteObserver(具体观察者)：作为抽象观察者的子类，实现相关接口，当收到具体目标状态改变的通知，执行具体业务逻辑。
3、EventBus源码分析：
EventBus是Android平台下用于应用内各组件或者模块间通信的一个类库，其主要实现思想为观察者模式。
//以下代码为观察者注册和监听的相关代码
class TestActivity: Activity(){
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
//注册该Activity为观察者
EventBus.getDefault().register(this)
}
override fun onDestroy() {
super.onDestroy()
//注销注册
EventBus.getDefault().unregister(this)
}
//接收通知方法
@Subscribe(threadMode = ThreadMode.MAIN)
fun receiveEvent(message: String?) {
Log.i("TestActivity", "receive a message is $message")
}
}
class MainActivity : BaseActivity(){
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
requestWindowFeature(Window.FEATURE_NO_TITLE)
setContentView(R.layout.activity_main)
//发送消息
EventBus.getDefault().post("send message")
}
} //Eventbus源码，观察者注册过程
public void register(Object subscriber) {
Class<?> subscriberClass = subscriber.getClass();
//寻找类中的订阅方法（通过Subscribe注解）
List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
synchronized (this) {
for (SubscriberMethod subscriberMethod : subscriberMethods) {
//拿到类中带有Subscribe注解的方法后，将该类注册为观察者
subscribe(subscriber, subscriberMethod);
}
}
}
List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
if (subscriberMethods != null) {
return subscriberMethods;
}
if (ignoreGeneratedIndex) {
//通过反射方法拿到类中方法的注解信息
subscriberMethods = findUsingReflection(subscriberClass);
} else {
subscriberMethods = findUsingInfo(subscriberClass);
}
if (subscriberMethods.isEmpty()) {
throw new EventBusException("Subscriber " + subscriberClass
+ " and its super classes have no public methods with the @Subscribe annotation");
} else {
METHOD_CACHE.put(subscriberClass, subscriberMethods);
return subscriberMethods;
}
}
//下述subscribribe方法才是真正的注册观察者方法
// Must be called in synchronized block
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
Class<?> eventType = subscriberMethod.eventType;
Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
if (subscriptions == null) {
subscriptions = new CopyOnWriteArrayList<>();
subscriptionsByEventType.put(eventType, subscriptions);
} else {
if (subscriptions.contains(newSubscription)) {
throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event "
+ eventType);
}
}
int size = subscriptions.size();
for (int i = 0; i <= size; i++) {
if (i == size || subscriberMethod.priority > subscriptions.get(i).subscriberMethod.priority) {
//将该类对应的subscription对象加入到监听站集合中
subscriptions.add(i, newSubscription);
break;
}
}
List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
if (subscribedEvents == null) {
subscribedEvents = new ArrayList<>();
typesBySubscriber.put(subscriber, subscribedEvents);
}
subscribedEvents.add(eventType);
if (subscriberMethod.sticky) {
if (eventInheritance) {
// Existing sticky events of all subclasses of eventType have to be considered.
// Note: Iterating over all events may be inefficient with lots of sticky events,
// thus data structure should be changed to allow a more efficient lookup
// (e.g. an additional map storing sub classes of super classes: Class -> List<Class>).
Set<Map.Entry<Class<?>, Object>> entries = stickyEvents.entrySet();
for (Map.Entry<Class<?>, Object> entry : entries) {
Class<?> candidateEventType = entry.getKey();
if (eventType.isAssignableFrom(candidateEventType)) {
Object stickyEvent = entry.getValue();
checkPostStickyEventToSubscription(newSubscription, stickyEvent);
}
}
} else {
Object stickyEvent = stickyEvents.get(eventType);
checkPostStickyEventToSubscription(newSubscription, stickyEvent);
}
}
}
/** Posts the given event to the event bus. */
public void post(Object event) {
//先将该时间加入到队列
PostingThreadState postingState = currentPostingThreadState.get();
List<Object> eventQueue = postingState.eventQueue;
eventQueue.add(event);
if (!postingState.isPosting) {
postingState.isMainThread = isMainThread();
postingState.isPosting = true;
if (postingState.canceled) {
throw new EventBusException("Internal error. Abort state was not reset");
}
try {
while (!eventQueue.isEmpty()) {
postSingleEvent(eventQueue.remove(0), postingState);
}
} finally {
postingState.isPosting = false;
postingState.isMainThread = false;
}
}
}
private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
Class<?> eventClass = event.getClass();
boolean subscriptionFound = false;
if (eventInheritance) {
List<Class<?>> eventTypes = lookupAllEventTypes(eventClass);
int countTypes = eventTypes.size();
for (int h = 0; h < countTypes; h++) {
Class<?> clazz = eventTypes.get(h);
subscriptionFound |= postSingleEventForEventType(event, postingState, clazz);
}
} else {
subscriptionFound = postSingleEventForEventType(event, postingState, eventClass);
}
if (!subscriptionFound) {
if (logNoSubscriberMessages) {
logger.log(Level.FINE, "No subscribers registered for event " + eventClass);
}
if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
eventClass != SubscriberExceptionEvent.class) {
post(new NoSubscriberEvent(this, event));
}
}
}
//最终调用的方法
void invokeSubscriber(Subscription subscription, Object event) {
try {
//通过反射调用监听者的方法
subscription.subscriberMethod.method.invoke(subscription.subscriber, event);
} catch (InvocationTargetException e) {
handleSubscriberException(subscription, event, e.getCause());
} catch (IllegalAccessException e) {
throw new IllegalStateException("Unexpected exception", e);
}
}EventBus的设计充分体现观察者模式的思想，消息发布者与订阅者之间充分解耦合。接口实现灵活度高，EventBus类作为整个库的核心，完成订阅与发布的功能，使得目标与观察者能够很好的通信。此外，观察者模式应用于MVC架构上，实现表示出与数据逻辑层的分离。
4、优缺点分析：
优点：
1）在观察者和目标之间解耦合；
2）支持广播通信，简化一对多系统设计；
3）符合开闭原则，扩展性好；
缺点：
1）目标状态改变时，会将变化通知到所有观察者，时间消耗较大；
结束语
观察者模式作为一种很常用和实用的设计模式，常在广播实现、MVC等架构上应用。对于降低系统耦合下，提高系统的扩展性很有用。一对多关系的模型较适合使用。