java觀察者模式,我的世界java觀察者模式

本文目錄一覽：

• 1、java中常用到得設計模式有哪幾種？
• 2、java設計模式-回調、事件監聽器、觀察者模式
• 3、java設計模式的兩大主題是什麼，
• 4、Java的回調函數和觀察者模式的區別
• 5、觀察者模式解析
• 6、求 JAVA 異步觀察者模式 的源代碼（完整的），不要同步的，好的給加分

java中常用到得設計模式有哪幾種？

一共23種設計模式！

按照目的來分，設計模式可以分為創建型模式、結構型模式和行為型模式。

創建型模式用來處理對象的創建過程；結構型模式用來處理類或者對象的組合；行為型模式用來對類或對象怎樣交互和怎樣分配職責進行描述。

創建型模式用來處理對象的創建過程，主要包含以下5種設計模式：

 工廠方法模式（Factory Method Pattern）

 抽象工廠模式（Abstract Factory Pattern）

 建造者模式（Builder Pattern）

 原型模式（Prototype Pattern）

 單例模式（Singleton Pattern）

結構型模式用來處理類或者對象的組合，主要包含以下7種設計模式：

 適配器模式（Adapter Pattern）

 橋接模式（Bridge Pattern）

 組合模式（Composite Pattern）

 裝飾者模式（Decorator Pattern）

 外觀模式（Facade Pattern）

 享元模式（Flyweight Pattern）

 代理模式（Proxy Pattern）

行為型模式用來對類或對象怎樣交互和怎樣分配職責進行描述，主要包含以下11種設計模式：

 責任鏈模式（Chain of Responsibility Pattern）

 命令模式（Command Pattern）

 解釋器模式（Interpreter Pattern）

 迭代器模式（Iterator Pattern）

 中介者模式（Mediator Pattern）

 備忘錄模式（Memento Pattern）

 觀察者模式（Observer Pattern）

 狀態模式（State Pattern）

 策略模式（Strategy Pattern）

 模板方法模式（Template Method Pattern）

 訪問者模式（Visitor Pattern）

推薦你一本好書：《軟件秘笈：設計模式那點事》，裡面講解的23中設計模式例子很生動，容易理解，還有JDK中設計模式應用情況，看了收穫挺大的！百度裡面搜“設計模式”，第一條中設計模式百度百科中就有首推該圖書，瀏覽量在20幾萬以上的，不會錯的。好東西大家一起分享！

祝你早日學會設計模式！

java設計模式-回調、事件監聽器、觀察者模式

轉自( )

背景

關於設計模式，之前筆者寫過工廠模式，最近在使用gava ListenableFuture時發現事件監聽模型特別有意思，於是就把事件監聽、觀察者之間比較了一番，發現這是一個非常重要的設計模式，在很多框架里扮演關鍵的作用。

回調函數

為什麼首先會講回調函數呢？因為這個是理解監聽器、觀察者模式的關鍵。

什麼是回調函數

所謂的回調，用於回調的函數。 回調函數只是一個功能片段，由用戶按照回調函數調用約定來實現的一個函數。 有這麼一句通俗的定義：就是程序員A寫了一段程序（程序a），其中預留有回調函數接口，並封裝好了該程序。程序員B要讓a調用自己的程序b中的一個方法，於是，他通過a中的接口回調自己b中的方法。

舉個例子：

這裡有兩個實體：回調抽象接口、回調者（即程序a）

回調接口（ICallBack ）

public interface ICallBack {

public void callBack();

}

回調者（用於調用回調函數的類）

public class Caller {

}

回調測試：

public static void main(String[] args) {

Caller call = new Caller();

call.call(new ICallBack(){

控制台輸出：

start…

終於回調成功了！

end…

還有一種寫法

或實現這個ICallBack接口類

class CallBackC implements ICallBack{

@Override

public void callBack() {

System.out.println(“終於回調成功了！”);

}

}

有沒有發現這個模型和執行一個線程，Thread很像。 沒錯，Thread就是回調者，Runnable就是一個回調接口。

new Thread(new Runnable(){

@Override

public void run() {

System.out.println(“回調一個新線程！”);

}}).start();

Callable也是一個回調接口，原來一直在用。 接下來我們開始講事件監聽器

事件監聽模式

什麼是事件監聽器

監聽器將監聽自己感興趣的事件一旦該事件被觸發或改變，立即得到通知，做出響應。例如：android程序中的Button事件。

java的事件監聽機制可概括為3點：

java的事件監聽機制涉及到 事件源，事件監聽器，事件對象 三個組件,監聽器一般是接口，用來約定調用方式

當事件源對象上發生操作時，它將會調用事件監聽器的一個方法，並在調用該方法時傳遞事件對象過去

事件監聽器實現類,通常是由開發人員編寫，開發人員通過事件對象拿到事件源，從而對事件源上的操作進行處理

舉個例子

這裡我為了方便，直接使用jdk，EventListener 監聽器，感興趣的可以去研究下源碼，非常簡單。

監聽器接口

public interface EventListener extends java.util.EventListener {

//事件處理

public void handleEvent(EventObject event);

}

事件對象

public class EventObject extends java.util.EventObject{

private static final long serialVersionUID = 1L;

public EventObject(Object source){

super(source);

}

public void doEvent(){

System.out.println(“通知一個事件源 source :”+ this.getSource());

}

}

事件源

事件源是事件對象的入口，包含監聽器的註冊、撤銷、通知

public class EventSource {

//監聽器列表，監聽器的註冊則加入此列表

private VectorEventListener ListenerList = new VectorEventListener();

//註冊監聽器

public void addListener(EventListener eventListener){

ListenerList.add(eventListener);

}

//撤銷註冊

public void removeListener(EventListener eventListener){

ListenerList.remove(eventListener);

}

//接受外部事件

public void notifyListenerEvents(EventObject event){

for(EventListener eventListener:ListenerList){

eventListener.handleEvent(event);

}

}

}

測試執行

public static void main(String[] args) {

EventSource eventSource = new EventSource();

}

控制台顯示：

通知一個事件源 source :openWindows

通知一個事件源 source :openWindows

doOpen something…

到這裡你應該非常清楚的了解，什麼是事件監聽器模式了吧。 那麼哪裡是回調接口，哪裡是回調者，對！EventListener是一個回調接口類，handleEvent是一個回調函數接口，通過回調模型，EventSource 事件源便可回調具體監聽器動作。

有了了解後，這裡還可以做一些變動。 對特定的事件提供特定的關注方法和事件觸發

public class EventSource {

…

public void onCloseWindows(EventListener eventListener){

System.out.println(“關注關閉窗口事件”);

ListenerList.add(eventListener);

}

}

public static void main(String[] args) {

EventSource windows = new EventSource();

/**

* 另一種實現方式

*/

//關注關閉事件，實現回調接口

windows.onCloseWindows(new EventListener(){

}

這種就類似於，我們的窗口程序，Button監聽器了。我們還可以為單擊、雙擊事件定製監聽器。

觀察者模式

什麼是觀察者模式

觀察者模式其實原理和監聽器是一樣的，使用的關鍵在搞清楚什麼是觀察者、什麼是被觀察者。

觀察者(Observer)相當於事件監器。有個微博模型比較好理解，A用戶關注B用戶，則A是B的觀察者，B是一個被觀察者，一旦B發表任何言論，A便可以獲得。

被觀察者(Observable)相當於事件源和事件，執行事件源通知邏輯時，將會回調observer的回調方法update。

舉個例子

為了方便，同樣我直接使用jdk自帶的Observer。

一個觀察者

public class WatcherDemo implements Observer {

@Override

public void update(Observable o, Object arg) {

if(arg.toString().equals(“openWindows”)){

System.out.println(“已經打開窗口”);

}

}

}

被觀察者

Observable 是jdk自帶的被觀察者，具體可以自行看源碼和之前的監聽器事件源類似。

主要方法有

addObserver() 添加觀察者，與監聽器模式類似

notifyObservers() 通知所有觀察者

類Watched.java的實現描述：被觀察者，相當於事件監聽的事件源和事件對象。又理解為訂閱的對象 主要職責：註冊/撤銷觀察者（監聽器），接收主題對象（事件對象）傳遞給觀察者（監聽器），具體由感興趣的觀察者（監聽器）執行

/**

}

測試執行

public static void main(String[] args) {

Watched watched = new Watched();

WatcherDemo watcherDemo = new WatcherDemo();

watched.addObserver(watcherDemo);

watched.addObserver(new Observer(){

@Override

public void update(Observable o, Object arg) {

if(arg.toString().equals(“closeWindows”)){

System.out.println(“已經關閉窗口”);

}

}

});

//觸發打開窗口事件，通知觀察者

watched.notifyObservers(“openWindows”);

//觸發關閉窗口事件，通知觀察者

watched.notifyObservers(“closeWindows”);

控制台輸出：

已經打開窗口

已經關閉窗口

總結

從整個實現和調用過程來看，觀察者和監聽器模式基本一樣。

有興趣的你可以基於這個模型，實現一個簡單微博加關注和取消的功能。 說到底，就是事件驅動模型，將調用者和被調用者通過一個鏈表、回調函數來解耦掉，相互獨立。

“你別來找我，有了我會找你”。

整個設計模式的初衷也就是要做到低耦合，低依賴。

再延伸下，消息中間件是什麼一個模型？ 將生產者+服務中心（事件源）和消費者（監聽器）通過消息隊列解耦掉. 消息這相當於具體的事件對象，只是存儲在一個隊列里（有消峰填谷的作用），服務中心回調消費者接口通過拉或取的模型響應。 想必基於這個模型，實現一個簡單的消息中間件也是可以的。

還比如gava ListenableFuture，採用監聽器模式就解決了future.get()一直阻塞等待返回結果的問題。

有興趣的同學，可以再思考下觀察者和責任鏈之間的關係， 我是這樣看的。

同樣會存在一個鏈表，被觀察者會通知所有觀察者，觀察者自行處理，觀察者之間互不影響。 而責任鏈，講究的是擊鼓傳花，也就是每一個節點只需記錄繼任節點，由當前節點決定是否往下傳。 常用於工作流，過濾器web filter。

java設計模式的兩大主題是什麼，

設計模式的兩大主題是系統復用與系統擴展。Java具有簡單性、面向對象、分布式、健壯性、安全性、平台獨立與可移植性、多線程、動態性等特點。Java可以編寫桌面應用程序、Web應用程序、分布式系統和嵌入式系統應用程序等。

擴展資料

由四方面組成：

（1）Java編程語言

（2）Java類文件格式

（3）Java虛擬機

（4）Java應用程序接口

當編輯並運行一個Java程序時，需要同時涉及到這四種方面。使用文字編輯軟件（例如記事本、寫字板、UltraEdit等）或集成開發環境（Eclipse、MyEclipse等）在Java源文件中定義不同的類 ，通過調用類（這些類實現了Java API）中的方法來訪問資源系統，把源文件編譯生成一種二進制中間碼，。

存儲在class文件中，然後再通過運行與操作系統平台環境相對應的Java虛擬機來運行class文件，執行編譯產生的字節碼，調用class文件中實現的方法來滿足程序的Java API調用。

Java的回調函數和觀察者模式的區別

java的回調 叫listener 模式。

無論是listener模式，還是C++裡面的callback模式，本質是一樣的

他們都是觀察者模式的具體實現。

觀察者模式是設計模式中定義的一種思想，而具體到不同的語言環境，使用不同的語法表現出來就會有java的listener objc的 delegate，或者C++的 callback。

觀察者模式解析

定義 ：對象間的一種一對多的依賴關係，使得當每一個對象改變狀態，則所有依賴於他的對象都會得到通知，並自動更新。

交互對象之間松耦合

1）觀察者定義了對象之間一對多的關係

2）被觀察者用一個共同的接口來更新觀察者

3）觀察者和被觀察者用松耦合方式結合，被觀察者不知道觀察者的細節，只知道觀察者實現了觀察者接口

優點：

1）觀察者與被觀察者抽象耦合，容易擴展；

2）建立了一套觸發機制。

缺點：

1）循環依賴會導致系統崩潰；

2）觀察者太多會浪費時間。

1）定義對象之間的一對多依賴關係而不使對象緊密耦合。

2）確保當一個對象改變狀態時，自動更新開放數量的從屬對象。

3）一個對象應該可以通知開放式數量的其他對象。

觀察者模式 vs 發布-訂閱模式

觀察者模式（Observer）

如何使用 Java8 實現觀察者模式？（上）

如何使用 Java8 實現觀察者模式？（下）

求 JAVA 異步觀察者模式 的源代碼（完整的），不要同步的，好的給加分

package TestObserver;

import java.util.Iterator;

import java.util.Vector;

/**

*

* @author Seastar

*/

interface Observed {

public void addObserver(Observer o);

public void removeObserver(Observer o);

public void update();

}

interface Observer {

public void takeAction();

}

class Invoker {

private Observer o;

Handler handler;

public Invoker(Observer o) {

new Handler();

this.o = o;

}

private class Handler extends Thread {

public Handler() {

handler = this;

}

@Override

public void run() {

o.takeAction();

}

}

public boolean TestSameObserver(Observer o) {

return o == this.o;

}

public void invoke() {

handler.start();

}

}

class ObservedObject implements Observed {

private VectorInvoker observerList = new VectorInvoker();

public void addObserver(Observer o) {

observerList.add(new Invoker(o));

}

public void removeObserver(Observer o) {

IteratorInvoker it = observerList.iterator();

while (it.hasNext()) {

Invoker i = it.next();

if (i.TestSameObserver(o)) {

observerList.remove(i);

break;

}

}

}

public void update() {

for (Invoker i : observerList) {

i.invoke();

}

}

}

class ObserverA implements Observer {

public void takeAction() {

System.out.println(“I am Observer A ,state changed ,so i have to do something”);

}

}

class ObserverB implements Observer {

public void takeAction() {

System.out.println(“I am Observer B ,i was told to do something”);

}

}

class ObserverC implements Observer {

public void takeAction() {

System.out.println(“I am Observer C ,I just look ,and do nothing”);

}

}

public class Main {

/**

* @param args the command line arguments

*/

public static void main(String[] args) {

ObserverA a = new ObserverA();

ObserverB b = new ObserverB();

ObserverC c = new ObserverC();

ObservedObject oo = new ObservedObject();

oo.addObserver(a);

oo.addObserver(b);

oo.addObserver(c);

for (int i = 0; i 5; ++i) {

oo.addObserver(new Observer() {

public void takeAction() {

System.out.println(“我是山寨觀察者”+”，誰敢攔我”);

}

});

}

//sometime oo changed ,so it calls update and informs all observer

oo.update();

}

}

觀察者模式的精髓在於註冊一個觀察者觀測可能隨時變化的對象，對象變化時就會自動通知觀察者，

這樣在被觀測對象影響範圍廣，可能引起多個類的行為改變時很好用，因為無需修改被觀測對象的代碼就可以增加被觀測對象影響的類，這樣的設計模式使得代碼易於管理和維護，並且減少了出錯幾率

至於異步機制實際是個噱頭，可以有觀測對象來實現異步，也可以有觀察者自身實現，這個程序實際是觀測對象實現了異步機制，方法是在觀察者類外包裝了一層invoker類