观察者模式
在现实世界中，许多对象并不是独立存在的，其中一个对象的行为发生改变可能会导致一个或者多个其他对象的行为也发生改变。例如，某种商品的物价上涨时会导致部分商家高兴，而消费者伤心；还有，当我们开车到交叉路口时，遇到红灯会停，遇到绿灯会行。这样的例子还有很多，例如，股票价格与股民、微信公众号与微信用户、气象局的天气预报与听众、小偷与警察等。
在软件世界也是这样，例如，Excel 中的数据与折线图、饼状图、柱状图之间的关系；MVC 模式中的模型与视图的关系；事件模型中的事件源与事件处理者。所有这些，如果用观察者模式来实现就非常方便。
模式的定义与特点
观察者（Observer）模式的定义：指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。
观察者模式是一种对象行为型模式，其主要优点如下。
降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。符合依赖倒置原则。
目标与观察者之间建立了一套触发机制。
事件驱动模型也就是我们常说的观察者，或者发布-订阅模型；理解它的几个关键点：
首先是一种对象间的一对多的关系；最简单的如交通信号灯，信号灯是目标（一方），行人注视着信号灯（多方）；
当目标发送改变（发布），观察者（订阅者）就可以接收到改变；
观察者如何处理（如行人如何走，是快走/慢走/不走，目标不会管的），目标无需干涉；所以就松散耦合了它们之间的关系。
它的主要缺点如下。
- 目标与观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用。
- 当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。
模式的结构与实现
实现观察者模式时要注意具体目标对象和具体观察者对象之间不能直接调用，否则将使两者之间紧密耦合起来，这违反了面向对象的设计原则。
- 模式的结构
观察者模式的主要角色如下。
抽象主题（Subject）角色：也叫抽象目标类，它提供了一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法，以及通知所有观察者的抽象方法。
具体主题（Concrete Subject）角色：也叫具体目标类，它实现抽象目标中的通知方法，当具体主题的内部状态发生改变时，通知所有注册过的观察者对象。
抽象观察者（Observer）角色：它是一个抽象类或接口，它包含了一个更新自己的抽象方法，当接到具体主题的更改通知时被调用。
具体观察者（Concrete Observer）角色：实现抽象观察者中定义的抽象方法，以便在得到目标的更改通知时更新自身的状态。
观察者模式的结构图如图 1 所示。
DubboShutdownHook中的实现
DubboShutdownHook代码如下所示：
/**
* The shutdown hook thread to do the clean up stuff.
* This is a singleton in order to ensure there is only one shutdown hook registered.
* to store the shutdown hooks.
*/
public class DubboShutdownHook extends Thread {
private static final Logger logger = LoggerFactory.getLogger(DubboShutdownHook.class);
private static final DubboShutdownHook DUBBO_SHUTDOWN_HOOK = new DubboShutdownHook("DubboShutdownHook");
// 回调类ShutdownHookCallbacks该类中使用List存放全部的需要执行回调的对象
private final ShutdownHookCallbacks callbacks = ShutdownHookCallbacks.INSTANCE;
/**
* Has it already been registered or not?
*/
private final AtomicBoolean registered = new AtomicBoolean(false);
/**
* Has it already been destroyed or not?
*/
private final AtomicBoolean destroyed = new AtomicBoolean(false);
private final EventDispatcher eventDispatcher = EventDispatcher.getDefaultExtension();
private DubboShutdownHook(String name) {
super(name);
}
public static DubboShutdownHook getDubboShutdownHook() {
return DUBBO_SHUTDOWN_HOOK;
}
@Override
public void run() {
if (logger.isInfoEnabled()) {
logger.info("Run shutdown hook now.");
}
// 执行回调逻辑
callback();
doDestroy();
}
/**
* For testing purpose
*/
void clear() {
callbacks.clear();
}
private void callback() {
// 执行真正的回调逻辑
callbacks.callback();
}
/**
* Register the ShutdownHook
*/
public void register() {
if (registered.compareAndSet(false, true)) {
destroyed.set(false);
DubboShutdownHook dubboShutdownHook = getDubboShutdownHook();
Runtime.getRuntime().addShutdownHook(dubboShutdownHook);
dispatch(new DubboShutdownHookRegisteredEvent(dubboShutdownHook));
}
}
/**
* Unregister the ShutdownHook
*/
public void unregister() {
if (registered.compareAndSet(true, false)) {
DubboShutdownHook dubboShutdownHook = getDubboShutdownHook();
Runtime.getRuntime().removeShutdownHook(dubboShutdownHook);
dispatch(new DubboShutdownHookUnregisteredEvent(dubboShutdownHook));
}
}
/**
* Destroy all the resources, including registries and protocols.
*/
public void doDestroy() {
// dispatch the DubboDestroyedEvent @since 2.7.5
dispatch(new DubboServiceDestroyedEvent(this));
if (destroyed.compareAndSet(false, true)) {
AbstractRegistryFactory.destroyAll();
destroyProtocols();
}
}
private void dispatch(Event event) {
eventDispatcher.dispatch(event);
}
public boolean getRegistered() {
return registered.get();
}
public static void destroyAll() {
getDubboShutdownHook().doDestroy();
}
/**
* Destroy all the protocols.
*/
public static void destroyProtocols() {
ExtensionLoader<Protocol> loader = ExtensionLoader.getExtensionLoader(Protocol.class);
for (String protocolName : loader.getLoadedExtensions()) {
try {
Protocol protocol = loader.getLoadedExtension(protocolName);
if (protocol != null) {
protocol.destroy();
}
} catch (Throwable t) {
logger.warn(t.getMessage(), t);
}
}
}
public static void reset() {
getDubboShutdownHook().destroyed.set(false);
getDubboShutdownHook().unregister();
}
}
ShutdownHookCallbacks中存放了所有需要回调的接口
/**
* The compose {@link ShutdownHookCallback} class to manipulate one and more {@link ShutdownHookCallback} instances
*
* @since 2.7.5
*/
public class ShutdownHookCallbacks {
public static final ShutdownHookCallbacks INSTANCE = new ShutdownHookCallbacks();
// 存放所有的回调实例
private final List<ShutdownHookCallback> callbacks = new LinkedList<>();
ShutdownHookCallbacks() {
// 通过SPI的方式自动注入回调实例
loadCallbacks();
}
public ShutdownHookCallbacks addCallback(ShutdownHookCallback callback) {
synchronized (this) {
this.callbacks.add(callback);
}
return this;
}
public Collection<ShutdownHookCallback> getCallbacks() {
synchronized (this) {
sort(this.callbacks);
return this.callbacks;
}
}
public void clear() {
synchronized (this) {
callbacks.clear();
}
}
private void loadCallbacks() {
ExtensionLoader<ShutdownHookCallback> loader =
ExtensionLoader.getExtensionLoader(ShutdownHookCallback.class);
loader.getSupportedExtensionInstances().forEach(this::addCallback);
}
public void callback() {
// 执行回调操作
getCallbacks().forEach(callback -> execute(callback::callback));
}
}
ShutdownHookCallback接口定义了回调函数：
/**
* Dubbo ShutdownHook callback interface
*
* @since 2.7.5
*/
@SPI
public interface ShutdownHookCallback extends Prioritized {
/**
* Callback execution
*
* @throws Throwable if met with some errors
*/
void callback() throws Throwable;
}