目錄
1.定義
觀察者模式（Observer Pattern）定義了對象之間一對多依賴，讓多個觀察者同時監聽一個主體對象，當主體對象發生變化時，它的所有依賴者（觀察者）都會收到通知並更新。（也叫發佈訂閱模式）
2.適用場景
- 觀察者模式主要用於在關聯行爲之間建立一套觸發機制的場景。
3.案例一：在學習平臺提問時@老師
（使用JDK提供的Observer類來實現觀察者模式）
UML類圖
代碼實現
Study 類
public class Study extends Observable {
private String name = "study學習平臺";
private static Study study = null;
private Study() {}
public static Study getInstance() {
if (null == study) {
study = new Study();
}
return study;
}
public String getName() {
return name;
}
public void publishQuestion(Question question) {
System.out.println(question.getUserName() + "在" + this.name + "上提交了一個問題。");
setChanged();
notifyObservers(question);
}
}
Teacher 類
public class Teacher implements Observer {
private String name;
public Teacher(String name) {
this.name = name;
}
@Override
public void update(Observable o, Object arg) {
Study study = (Study) o;
Question question = (Question) arg;
System.out.println("==========================================");
System.out.println(name + "老師，你好！\n" +
"您收到了一個來自“" + study.getName() + "”的提問，希望您解答，問題內容如下：\n" +
question.getContent() + "\n" +
"提問者是：" + question.getUserName());
}
}
Question 類
public class Question {
private String userName;
private String content;
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
}
測試類
public class ObserverTest {
public static void main(String[] args) {
Study study = Study.getInstance();
Teacher tom = new Teacher("Tom");
Teacher mic = new Teacher("Mic");
// 這位同學沒有@Tom老師，所以沒有收到
// 要先@老師再發布
Question question = new Question();
question.setUserName("小明");
question.setContent("觀察者設計模式適用於那些場景呢？");
study.addObserver(tom);
study.addObserver(mic);
study.publishQuestion(question);
}
}
輸出結果：
小明在study學習平臺上提交了一個問題。
==========================================
Mic老師，你好！
您收到了一個來自“study學習平臺”的提問，希望您解答，問題內容如下：
觀察者設計模式適用於那些場景呢？
提問者是：小明
==========================================
Tom老師，你好！
您收到了一個來自“study學習平臺”的提問，希望您解答，問題內容如下：
觀察者設計模式適用於那些場景呢？
提問者是：小明
4.案例二：鼠標點擊監聽時間
（自己動手寫觀察者模式）
UML類圖
代碼實現
Event 類
public class Event {
// 事件源，事件是由誰發起的保存起來
private Object source;
// 事件觸發，要通知誰
private Object target;
// 事件觸發，要做什麼動作，回調
private Method callback;
// 事件的名稱，觸發的是什麼事件
private String trigger;
// 事件觸發的時間
private long time;
public Event(Object target, Method callback) {
this.target = target;
this.callback = callback;
}
public Event setSource(Object source) {
this.source = source;
return this;
}
public Event setTime(long time) {
this.time = time;
return this;
}
public Object getSource() {
return source;
}
public Event setTrigger(String trigger) {
this.trigger = trigger;
return this;
}
public long getTime() {
return time;
}
public Object getTarget() {
return target;
}
public Method getCallback() {
return callback;
}
@Override
public String toString() {
return "Event{" + "\n" +
"\tsource=" + source.getClass() + ",\n" +
"\ttarget=" + target.getClass() + ",\n" +
"\tcallback=" + callback + ",\n" +
"\ttrigger='" + trigger + "',\n" +
"\ttime=" + time + "'\n" +
'}';
}
}
EventListener 類
public class EventLisenter {
//JDK底層的Lisenter通常也是這樣來設計的
protected Map<String,Event> events = new HashMap<String,Event>();
/**
* 事件名稱和一個目標對象來觸發事件
*/
public void addLisenter(String eventType,Object target){
try {
if (Objects.nonNull(target)) {
this.addLisenter(
eventType,
target,
target.getClass().getMethod("on" + toUpperFirstCase(eventType), Event.class));
}
}catch (Exception e){
e.printStackTrace();
}
}
public void addLisenter(String eventType, Object target, Method callback){
// 註冊事件
events.put(eventType, new Event(target, callback));
}
/**
* 觸發，只要有動作就觸發
*/
private void trigger(Event event) {
event.setSource(this);
event.setTime(System.currentTimeMillis());
try {
//發起回調
if(event.getCallback() != null){
//用反射調用它的回調函數
event.getCallback().invoke(event.getTarget(),event);
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 事件名稱觸發
*/
protected void trigger(String trigger){
if(this.events.containsKey(trigger)){
trigger(this.events.get(trigger).setTrigger(trigger));
}
}
/**
* 邏輯處理的私有方法，首字母大寫
*/
private String toUpperFirstCase(String str){
char[] chars = str.toCharArray();
chars[0] -= 32;
return String.valueOf(chars);
}
}
Mouse 類
public class Mouse extends EventLisenter {
public void click(){
System.out.println("調用單擊方法");
this.trigger(MouseEventTypeEnum.ON_CLICK.value());
}
public void blur(){
System.out.println("調用失焦方法");
this.trigger(MouseEventTypeEnum.ON_BLUR.value());
}
}
MouseEventCallback 類
public class MouseEventCallback {
public void onClick(Event e){
System.out.println("===========觸發鼠標單擊事件==========" + "\n" + e);
}
public void onBlur(Event e){
System.out.println("===========觸發鼠標失焦事件==========" + "\n" + e);
}
}
MouseEventTypeEnum 枚舉類
public enum MouseEventTypeEnum {
//單擊
ON_CLICK("click"),
//失焦
ON_BLUR("blur");
private String value;
MouseEventTypeEnum(String value) {
this.value = value;
}
public String value() {
return value;
}
}
測試類
public class MouseEventTest {
public static void main(String[] args) {
MouseEventCallback callback = new MouseEventCallback();
Mouse mouse = new Mouse();
// 提問前@誰？？ @回調方法
mouse.addLisenter(MouseEventTypeEnum.ON_CLICK.value(), callback);
mouse.addLisenter(MouseEventTypeEnum.ON_BLUR.value(), callback);
// 提問
mouse.click();
mouse.blur();
}
}
輸出結果：
調用單擊方法
===========觸發鼠標單擊事件==========
Event{
source=class com.gupaoedu.vip.pattern.observer.events.mouseevent.Mouse,
target=class com.gupaoedu.vip.pattern.observer.events.mouseevent.MouseEventCallback,
callback=public void com.gupaoedu.vip.pattern.observer.events.mouseevent.MouseEventCallback.onClick(com.gupaoedu.vip.pattern.observer.events.core.Event),
trigger='click',
time=1584795481567'
}
調用失焦方法
===========觸發鼠標失焦事件==========
Event{
source=class com.gupaoedu.vip.pattern.observer.events.mouseevent.Mouse,
target=class com.gupaoedu.vip.pattern.observer.events.mouseevent.MouseEventCallback,
callback=public void com.gupaoedu.vip.pattern.observer.events.mouseevent.MouseEventCallback.onBlur(com.gupaoedu.vip.pattern.observer.events.core.Event),
trigger='blur',
time=1584795481567'
}
5.案例三：使用Guava實現
GuavaEvent 類
public class GuavaEvent {
@Subscribe
public void subscribe(String str) {
System.out.println("執行subscribe方法，傳入的參數是：" + str);
}
}
測試類：
public class GuavaEventTest {
public static void main(String[] args) {
// 消息總線
EventBus eventBus = new EventBus();
GuavaEvent guavaEvent = new GuavaEvent();
eventBus.register(guavaEvent);
eventBus.post("Tom");
}
}
輸出結果：
執行subscribe方法，傳入的參數是：Tom
5.在源碼中的體現
Spring中的ContextLoaderListener、ApplicationContextAware等對象就是用了觀察者模式，當你看到Listener後綴的時候，一般就是在使用觀察者模式。
ContextLoaderListener
Spring 中的 ContextLoaderListener 實現了 ServletContextListener 接口，ServletContextListener 接口又繼承了 EventListener，在 JDK 中 EventListener 有非常廣泛的應用。我們可以看一下源代碼：
package org.springframework.web.context;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
public class ContextLoaderListener extends ContextLoader implements ServletContextListener {
public ContextLoaderListener() {
}
public ContextLoaderListener(WebApplicationContext context) {
super(context);
}
public void contextInitialized(ServletContextEvent event) {
this.initWebApplicationContext(event.getServletContext());
}
public void contextDestroyed(ServletContextEvent event) {
this.closeWebApplicationContext(event.getServletContext());
ContextCleanupListener.cleanupAttributes(event.getServletContext());
}
}
6.裝飾者模式的優點
- 觀察者和被觀察者之間建立了一個抽象的耦合；
- 觀察者模式支持廣播通信。
7.裝飾者模式的缺點
- 觀察者之間有過多的細節依賴、提高時間消耗及程序的複雜度；
- 使用要得當，要避免循環調用。