java和Spring中觀察者模式的應用詳解

Posted on by

一、觀察者模式基本概況

1.概念

觀察者模式(Observer Design Pattern)也被稱為發佈訂閱模式(Publish-Subcribe Design Pattern)。定義如下

Define a one-to-many dependency between objects so that when one object changes state，all its dependents are notified and update automatically。

觀察者模式定義瞭一種一對多的依賴關系，讓多個觀察者對象同時監聽某一個主題對象。這個主題對象在狀態變化時，會通知所有觀察者對象，使它們能夠自動更新自己。

2.作用

參考設計模式之美的一段總結

回到本質，設計模式要幹的事情就是解耦。創建型模式是將創建對象和使用對象解耦，結構型模式是將不同功能代碼解耦，行為型模式是將不同的行為代碼解耦，具體到觀察者模式，是將觀察者和被觀察者代碼解耦。

3.實現方式

觀察者模式在不同的場景有不同的實現方式，自然也有不同的名字。如Publisher-Subscriber、Producer-Consumer、Dispatcher-Listener，等等。

有哪些不同實現方式呢？同步阻塞方式，異步非阻塞方式；進程內實現方式，跨進程實現方式。

同步阻塞方式是經典的實現方式，是說在主題通知觀察者和觀察者執行自己的邏輯是由同一個線程完成的，比如下面要說的java中Observer接口和Observable類，後有UML圖

public void notifyObservers(Object arg) {
    for (int i = arrLocal.length-1; i>=0; i--){
    	//使用瞭for循環同步通知觀察者
    	((Observer)arrLocal[i]).update(this, arg);
    } 
}

異步非阻塞方式是在通知觀察者和觀察者執行自己邏輯不是同一個線程，如下代碼

public void notifyObservers(Object arg) {
    for (int i = arrLocal.length-1; i>=0; i--){
    	//使用瞭開啟新線程方式異步通知觀察者
    	new Thread(()->{
    		((Observer)arrLocal[i]).update(this, arg);
		}).start();
    } 
}

上面都是在同一個進程中，還有跨進程的實現方式就是常用的MQ，消息隊列

二、java實現兩種觀察者模式

1.Observer接口和Observable類

下面我們使用JDK提供的接口和類實現項目中使用觀察者模式

在這裡插入圖片描述

先說下Observer接口和Observable類

Observable類，被觀察者。有三個組成部分，用Vector管理註冊的觀察者(Observer)，並提供瞭增刪、統計方法。一旦狀態(changed)改變就通知(notifyObservers)觀察者。notifyObservers方法會調用觀察者(Observer)的update方法。

Observer接口就是一個觀察者的標準，實現該接口並重寫update方法就可以實現一個觀察者。

具體的源碼大傢可以自己看下，比較簡單，在java.util包下。

實現一個需求

當自定義被觀察者data值=1時通知各個觀察者執行update方法，應該如何做？

UML圖已經畫出來瞭，剩下就是寫代碼瞭。

代碼如下

//自定義被觀察者
public class MyObservable extends Observable {
    private int data;
    public void setData(int data) {
        this.data = data;
    }
    public void notifyObserver(){
    	//當data等於1時通知觀察者
        if (data==1){
            this.setChanged();
            super.notifyObservers();
        }
    }
}
//自定義觀察者
public class MyObserver implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("自定義觀察者執行瞭.....");
    }
}
//測試類
public class PubSubTest {
    public static void main(String[] args) {
        MyObservable observable = new MyObservable();
        observable.addObserver(new MyObserver());
        observable.setData(1);
        observable.notifyObserver();
    }
}

2.EventObject和EventListener

JDK提供瞭EventObject類和EventListener接口定義瞭實現觀察者模式的第二個標準，隻是定義瞭標準沒有提供默認實現，但是其他框架如Spring實現該方式，這個下面再說。

先看EventObject類

該類實現的功能就是定義一個事件，其中有一個最重要的屬性source，叫事件源。含義是哪個類發出的事件。自定義事件時需要繼承該類

public class EventObject implements java.io.Serializable {
    protected transient Object  source;
    public EventObject(Object source) {
        if (source == null)
            throw new IllegalArgumentException("null source");
        this.source = source;
    }
    public Object getSource() {
        return source;
    }
}

EventListener接口是一個空接口，自定義監聽器需要繼承該接口。

註意此時事件就是一個被觀察者，監視器就是觀察者。

三、Spring事件監聽實戰及原理

1.Spring如何使用EventObject和EventListener實現觀察者？

在Spring中為自定義事件和自定義監聽者，分別提供一個類和一個接口。

ApplicationEvent類繼承瞭EventObject，用於在Spring環境下自定義事件

public abstract class ApplicationEvent extends EventObject {
	/**
	 * Create a new {@code ApplicationEvent}.
	 * @param source the object on which the event initially occurred or with
	 * which the event is associated (never {@code null})
	 */
	public ApplicationEvent(Object source) {
		super(source);
		this.timestamp = System.currentTimeMillis();
	}
}

ApplicationListener接口繼承JDK的EventListener，用於在Spring環境下自定義監聽者

@FunctionalInterface
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
	/**
	 * Handle an application event.
	 * @param event the event to respond to
	 */
	void onApplicationEvent(E event);
}

onApplicationEvent方法就是根據傳過來的事件參數，監聽是否是自己感興趣的事件，然後執行方法體。

介紹完類和接口剩下的就是如何在Spring中如何自定義事件、如何發佈事件、如何使用自定義監聽器監聽事件，下面舉個例子

2.先實戰—要先會用

實現一個需求：當調用一個類的方法完成時，該類發佈事件，事件監聽器監聽該類的事件並執行的自己的方法邏輯

假設這個類是Request、發佈的事件是ReuqestEvent、事件監聽者是ReuqestListener。當調用Request的doRequest方法時，發佈事件。模擬的代碼如下

public class SpringEventTest {
    public static void main(String[] args) {
        ApplicationContext context=new AnnotationConfigApplicationContext("com.thinkcoder.parttern.behavioral.pubsub.spring");
        Request request = (Request) context.getBean("request");
        //調用方法，發佈事件
        request.doRequest();
    }
}
//定義事件
class RequestEvent extends ApplicationEvent {
    public RequestEvent(Request source) {
        super(source);
    }
}
//發佈事件
@Component
class Request{
    @Autowired
    private ApplicationContext applicationContext;
    public void doRequest(){
        System.out.println("調用Request類的doRequest方法發送一個請求");
        applicationContext.publishEvent(new RequestEvent(this));
    }
}
//監聽事件
@Component
class RequestListener implements ApplicationListener<RequestEvent> {
    @Override
    public void onApplicationEvent(RequestEvent event) {
        System.out.println("監聽到RequestEvent事件,執行方法");
    }
}
//打印的日志
調用Request類的doRequest方法發送一個請求
監聽到RequestEvent事件,執行方法

上面我們依靠spring實現瞭事件—監聽機制，使用的步驟有如下幾步

  • 定義事件：繼承ApplicationEvent類，實現方法傳入事件源。由事件源產生事件
  • 發佈事件：使用Spring的IOC容器ApplicationContext的publishEvent方法發佈事件
  • 監聽事件：實現ApplictionListener接口重寫方法即可實現自定義監聽器

3.會原理—搞清楚為什麼會這樣

先將上述過程畫成一幅圖，然後展開來解釋各個步驟，相信我你能看懂

在這裡插入圖片描述

通過上面的流程圖，回答下面幾個問題

1.監聽器什麼時候註冊到IOC容器中？

註冊的開始邏輯是在AbstractApplicationContext類的refresh方法，該方法包含瞭整個IOC容器初始化所有方法。其中有一個registerListeners()方法就是註冊系統監聽者(spring自帶的)和自定義監聽器的。

看registerListeners的關鍵方法體，其中的兩個方法addApplicationListener和addApplicationListenerBean，從方法可以看出是添加監聽者。

for (ApplicationListener<?> listener : getApplicationListeners()) {
	getApplicationEventMulticaster().addApplicationListener(listener);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let post-processors apply to them!
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
	getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}

那麼最後將監聽者放到哪裡瞭呢？就是ApplicationEventMulticaster接口的子類

在這裡插入圖片描述

該接口主要兩個職責，維護ApplicationListener相關類和發佈事件。

實現是在默認實現類AbstractApplicationEventMulticaster，最後將Listener放到瞭內部類ListenerRetriever兩個set集合中

private class ListenerRetriever {
	public final Set<ApplicationListener<?>> applicationListeners = new LinkedHashSet<>();
	public final Set<String> applicationListenerBeans = new LinkedHashSet<>();

ListenerRetriever又被稱為監聽器註冊表。

2.Spring如何發佈的事件並通知的監聽者？

該問題開始是在ApplicationContext.publishEvent的方法，該方法調用路線

AbstractApplicationContext.publishEvent→SimpleApplicaitonEventMulticaster.multicastEvent→SimpleApplicaitonEventMulticaster.invokeListener→SimpleApplicaitonEventMulticaster.doInvokeListener→調用系統及自定義listener的onApplicationEvent方法，這個就是發佈事件並通知的調用路線。

這個註意的有兩個方法

multicastEvent方法，該方法有兩種方式調用invokeListener，通過線程池和直接調用，進一步說就是通過異步和同步兩種方式調用

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);
		}
	}
}

最後看doInvokeListener方法

private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
	try {
		//直接調用瞭listener接口的onApplicationEvent方法
		listener.onApplicationEvent(event);
	}
}

四、最後一張圖總結

在這裡插入圖片描述

上圖包含瞭在Spring如何自定義事件、監聽器以及發佈事件和通知監聽者的原理，大傢可以自己梳理下。

推薦閱讀：