定义：
定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并且执行对应的逻辑。
角色：
1、主题：也可以称为被观察者，在一对多的关系中，扮演的是一，一个主题可以有多个观察者。举个例子：约上几个朋友到河南烩面馆去吃烩面，由于人多，需要排队，每人发一个号；这个河南烩面馆就可以理解成一个主题，有自己的状态变化：烩面是否做好。
2、观察者：在一对多的关系中，扮演的是多。上面那个例子中，我和几个朋友都可以看作这家面馆的观者者，一旦我们的饭做好了，我们都会收到对应的通知，服务员会把对应的烩面端过来或者我们自己去拿。
实现原理：
一个主题是有状态的，也就是真正有数据的人，这些状态或者数据在某些场景下都有可能发生变化，当发生变化的时候，如果希望需要响应这些变化的观察者收到通知和数据，那就需要把这些观者者注册到这个主题上面。也就是要在他们之间架起一座桥梁，这两个角色肯定要有某种联系，不管这种联系是怎么实现的，反正要有，不然的话，凭什么你主题一变化，观察者就能知道并且收到对应的变化数据。这个里面采取的方式是在主题类里面保存一个观察者列表，当主题内部状态发生变化的时候，会遍历这个列表，调用观察者的方法。
类图
应用场景：
这个模式还是挺实用的，在jdk或者很多开源框架里面都会有这种思想体现或者是这种思想的延伸。像消息队列的发布订阅，其实就是运用的这种模式。spring的event事件通知，也是这种模式，下面会以源码的形式介绍。其他的只要有类似有一个有状态的核心的点，然后其他点的业务变化需要依赖这个核心点的状态变化，都可以借鉴这个模式。
- spring的event通知：
spring框架提供的事件处理功能，其实就是通过继承ApplicationEvent和实现ApplicationListener接口来实现的。ApplicationListener接口的实现者其实就是一个观察者，而ApplicationContext就可以理解成主题，每一次当Event被发布到spring上下文的时候，对应event的Listener Bean都会被通知、调用。
spring提供了很多种event，每一种event都有对应的使用场景，例如：ContextRefreshedEvent是在调用ConfigurableApplicationContext的refresh方法中finishRefresh方法中发布的：
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
onRefresh();
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();
}
protected void finishRefresh() {
// Clear context-level resource caches (such as ASM metadata from scanning).
clearResourceCaches();
// Initialize lifecycle processor for this context.
initLifecycleProcessor();
// Propagate refresh to lifecycle processor first.
getLifecycleProcessor().onRefresh();
// Publish the final event.
publishEvent(new ContextRefreshedEvent(this));
// Participate in LiveBeansView MBean, if active.
LiveBeansView.registerApplicationContext(this);
}
也就是上面的publishEvent方法实现的。
像ContextStartedEvent和ContextStoppedEvent分别是在调用AbstractApplicationContext的start和stop方法触发发布的，代码如下：
@Override
public void start() {
getLifecycleProcessor().start();
publishEvent(new ContextStartedEvent(this));
}
@Override
public void stop() {
getLifecycleProcessor().stop();
publishEvent(new ContextStoppedEvent(this));
}
publishEvent最终会调用SimpleApplicationEventMulticaster类的multicastEvent方法，详细代码如下：
@Override
public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
Executor executor = getTaskExecutor();
for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
if (executor != null) {
executor.execute(() -> invokeListener(listener, event));
}
else {
invokeListener(listener, event);
}
}
}
查询和当前event关联的listener（观察者），然后提交给线程池执行，调用onApplicationEvent方法，执行定义的业务逻辑。
- Tomcat的Lifecycle：
Tomcat中控制各个组件的生命周期的Lifecycle用的也是这种模式；
比如：StandardServer Server组件
Lifecycle接口：抽象主题
StandardServer类：具体的主题
LifecycleListener接口：抽象观察者
NamingContextListener类：具体的观察者
StandardServer类继承了LifecycleBase抽象类、实现了Server接口。LifecycleBase统一封装了新增、删除Listener（观察者）的方法，还有start()、stop()、destroy()方法的实现；startInternal()这个方法在子类里面实现，里面包含触发Listener执行逻辑的方法，代码如下：
@Override
protected void startInternal() throws LifecycleException {
fireLifecycleEvent(CONFIGURE_START_EVENT, null);
setState(LifecycleState.STARTING);
globalNamingResources.start();
// Start our defined Services
synchronized (servicesLock) {
for (Service service : services) {
service.start();
}
}
if (periodicEventDelay > 0) {
monitorFuture = getUtilityExecutor().scheduleWithFixedDelay(
new Runnable() {
@Override
public void run() {
startPeriodicLifecycleEvent();
}
}, 0, 60, TimeUnit.SECONDS);
}
}
然后执行LifecycleListener中的lifecycleEvent()方法，本例指的是NamingContextListener类中的lifecycleEvent方法，里面有很多逻辑。其实这个NamingContextListener的关联是在StandardServer的构造方法里面，如下图：
StandardServer的类图：
总结：
感觉java里面的很多模式和写代码思想都可以在现实生活中找到原型，如果碰到一些难懂的思想，可以结合一下生活中是否有对应的场景，结合着去思考，会更好想明白一点。有些东西看着很高深，一旦你决定想深入进去，并且去做了，其实他们的内部实现没那么复杂的，所以要多深入进去学习，多实践，验证。
