观察者模式是对象的行为模式，又叫发布-订阅(Publish/Subscribe)模式、模型-视图(Model/View)模式、源-监听器(Source/Listener)模式或从属者(Dependents)模式。
观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使它们能够自动更新自己。
1. JDK提供的观察者模式
在JAVA语言的java.util库里面，提供了一个Observable类以及一个Observer接口，构成JAVA语言对观察者模式的支持。
事件对象：
@Data
public class NameEvent {
private String name;
//信息
private String message;
}
发布者（被观察者）：
import java.util.Observable;
import java.util.Observer;
public class BusService {
//发布者对象
private NameWatched observable = new NameWatched();
public void addObservers(Observer... observers) {
//支持动态新增观察者
for (Observer observer : observers) {
observable.addObserver(observer);
}
}
/**
* 业务方法
*/
public void bus(String name) {
//当名字为tom时，触发事件
if ("tom".equals(name)) {
NameEvent event = new NameEvent();
event.setName("tom");
event.setMessage("触发事件啦！");
observable.sendNameEvent(event);
}
}
/**
* 发布者对象（观察者）
*/
public static class NameWatched extends Observable{
public void sendNameEvent(NameEvent nameEvent){
//发送变化了
setChanged();
//推送消息
notifyObservers(nameEvent);
}
}
}
订阅者（观察者）：
@Slf4j
public class NameWatcher implements Observer {
@Override
public void update(Observable o, Object arg) {
//获取到业务参数
log.info("监听者-打印数据{}", JSON.toJSONString(arg));
}
}
测试代码：
public class Testlucene {
public static void main(String[] args) {
//线程1，执行业务逻辑
new Thread(()->{
BusService busService=new BusService();
busService.addObservers(new NameWatcher());
busService.bus("tom");
}).start();
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
结果：
21:15:29.258 [Thread-0] INFO com.tellme.test.NameWatcher - 监听者-打印数据{"message":"触发事件啦！","name":"tom"}
缺点：
- 传递参数的方式在notifyObservers加了sync(this)关键字，会严重影响性能，但作用仅仅就是同步获取增删的订阅者。
- 传递this对象，不能声明全局的Observable对象。
- 多个订阅者和发布者时同一个线程。会影响发布者性能！
2. Google Guava的EventBus提供的观察者模式
使用方式：
JAVA进阶篇(10)—Guava实现的EventBus（观察者模式）
缺点：
- EventBus需要注意：发布者和订阅者使用同一个线程，可能会影响发布者的性能。但可以保证单线程中事件的发布顺序和调度顺序保持一致。
- AsyncEventBus需要注意的是：发布者和订阅者可以使用不同的线程处理；发布事件时维护了一个LinkedQueue，若订阅者消费速度慢，可能会造成内存溢出；采用全局队列维护事件顺序性，但不能完全保证调度和发布的顺序；性能不如直接分发好；
- guava的EventBus虽然通过注解的方式更加灵活，但是没有接口的语法层面的依赖关系，代码维护性、可读性不是特别好。
3. 自定义实现
public class SealObservable {
/**
* 线程安全，且适合读多写少的场景
*/
private List<SealObserver> sealObservers = new CopyOnWriteArrayList<>();
private Executor executor;
public SealObservable() {
executor = DirectExecutor.INSTANCE;
}
/**
* @param sync true：使用同一个线程处理消息。false：开启异步线程处理消息
*/
public SealObservable(boolean sync) {
if (sync) {
executor = DirectExecutor.INSTANCE;
} else {
executor = new ThreadPoolExecutor(4,
8, 60, TimeUnit.SECONDS,
new ArrayBlockingQueue<>(10), new ThreadPoolExecutor.DiscardPolicy());
}
}
public SealObservable(Executor executor) {
this.executor = executor;
}
public void addObserver(SealObserver o) {
if (o == null)
throw new NullPointerException();
if (!sealObservers.contains(o)) {
sealObservers.add(o);
}
}
public void deleteObserver(SealObserver o) {
sealObservers.remove(o);
}
/**
* 通知消息
*/
public void notifyObservers(Object arg) {
//没有监听者，快速失败
if (sealObservers.size() == 0) {
return;
}
//开启线程配置
for (SealObserver sealObserver : sealObservers) {
executor.execute(() -> {
sealObserver.notice(arg);
});
}
}
}
直接线程池：
/**
* 直接线程池。
*/
public enum DirectExecutor implements Executor {
INSTANCE;
@Override
public void execute(Runnable command) {
command.run();
}
@Override
public String toString() {
return "SealExecutors.directExecutor()";
}
}
观察者对象：
public interface SealObserver {
/**
* 触发事件调用的方法
*
* @param arg 事件对象
*/
void notice(Object arg);
}
