觀察者模式在實際項目中使用的也是非常頻繁的，它最常用的地方是GUI系統、訂閱——發布系統等。因為這個模式的一個重要作用就是解耦，使得它們之間的依賴性更小，甚至做到毫無依賴。以GUI系統來說，應用的UI具有易變性，尤其是前期隨著業務的改變或者產品的需求修改，應用界面也經常性變化，但是業務邏輯基本變化不大，此時，GUI系統需要一套機制來應對這種情況，使得UI層與具體的業務邏輯解耦，觀察者模式此時就派上用場了。
概述
觀察者模式又被稱作發布/訂閱模式，觀察者模式定義了一種一對多的依賴關系，讓多個觀察者對象同時監聽某一個主題對象。這個主題對象在狀態發生變化時，會通知所有觀察者對象，使它們能夠自動更新自己。
模式中的角色
抽象主題（Subject）：它把所有觀察者對象的引用保存到一個聚集里，每個主題都可以有任何數量的觀察者。抽象主題提供一個接口，可以增加和刪除觀察者對象。
具體主題（ConcreteSubject）：將有關狀態存入具體觀察者對象；在具體主題內部狀態改變時，給所有登記過的觀察者發出通知。
抽象觀察者（Observer）：為所有的具體觀察者定義一個接口，在得到主題通知時更新自己。
具體觀察者（ConcreteObserver）：實現抽象觀察者角色所要求的更新接口，以便使本身的狀態與主題狀態協調。
1.Subject 和 Observer 是一個一對多的關系，也就是說觀察者只要實現 Observer 接口并把自己注冊到 Subject 中就能夠接收到消息事件；
2.Java API有內置的觀察者模式類：java.util.Observable 類和 java.util.Observer 接口，這分別對應著 Subject 和 Observer 的角色；
3.使用 Java API 的觀察者模式類，需要注意的是被觀察者在調用 notifyObservers() 函數通知觀察者之前一定要調用 setChanged() 函數，要不然觀察者無法接到通知；
4.使用 Java API 的缺點也很明顯，由于 Observable 是一個類，java 只允許單繼承的缺點就導致你如果同時想要獲取另一個父類的屬性時，你只能選擇適配器模式或者是內部類的方式，而且由于 setChanged() 函數為 protected 屬性，所以你除非繼承 Observable 類，否則你根本無法使用該類的屬性，這也違背了設計模式的原則：多用組合，少用繼承。
觀察者模式示例
例如：MyPerson是被觀察者
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
public class MyPerson extends Observable { private String name; private int age; private String sex; public String getName() { return name; } public void setName(String name) { this.name = name; setChanged(); notifyObservers(); } public int getAge() { return age; } public void setAge(int age) { this.age = age; setChanged(); notifyObservers(); } public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; setChanged(); notifyObservers(); } @Override public String toString() { return "MyPerson [name=" + name + ", age=" + age + ", sex=" + sex + "]"; }} |
setChanged();告知數據改變，通過notifyObservers();發送信號通知觀察者。
MyObserver是觀察者
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
public class MyObserver implements Observer { private int id; private MyPerson myPerson; public MyObserver(int id) { System.out.println("我是觀察者---->" + id); this.id = id; } public int getId() { return id; } public void setId(int id) { this.id = id; } public MyPerson getMyPerson() { return myPerson; } public void setMyPerson(MyPerson myPerson) { this.myPerson = myPerson; } @Override public void update(Observable observable, Object data) { System.out.println("觀察者---->" + id + "得到更新"); this.myPerson = (MyPerson) observable; System.out.println(((MyPerson) observable).toString()); }} |
觀察者接受到通知后，調用update方法進行更新操作。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
|
public class MainActivity extends Activity { private Button btnAddObserver; private Button btnChangeData; private MyPerson observable; private MyObserver myObserver; private List<MyObserver> myObservers; private ListView listview; private int i; private Handler handler = new Handler() { public void handleMessage(android.os.Message msg) { MyListAdapter myListAdapter = new MyListAdapter(MainActivity.this, myObservers); listview.setAdapter(myListAdapter); }; }; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); btnAddObserver = (Button) findViewById(R.id.btn_add_observer); btnChangeData = (Button) findViewById(R.id.btn_change_data); listview = getListView(); observable = new MyPerson(); myObservers = new ArrayList<MyObserver>(); btnAddObserver.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { myObserver = new MyObserver(i); i++; observable.addObserver(myObserver); myObservers.add(myObserver); handler.sendEmptyMessage(0); } }); btnChangeData.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { observable.setName("a" + i); observable.setAge(10 + i); observable.setSex("男" + i); handler.sendEmptyMessage(0); } }); } @Override protected void onDestroy() { // TODO Auto-generated method stub super.onDestroy(); observable.deleteObserver(myObserver); }} |
Android源碼中的模式實現
在以前，我們最常用到的控件就是ListView了，而ListView最重要的一個點就是Adapter，在我們往ListView添加數據后，我們都會調用一個方法: notifyDataSetChanged(), 這個方法就是用到了我們所說的觀察者模式。
跟進這個方法notifyDataSetChanged方法，這個方法定義在BaseAdapter中，代碼如下:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
public abstract class BaseAdapter implements ListAdapter, SpinnerAdapter { // 數據集觀察者 private final DataSetObservable mDataSetObservable = new DataSetObservable(); // 代碼省略 public void registerDataSetObserver(DataSetObserver observer) { mDataSetObservable.registerObserver(observer); } public void unregisterDataSetObserver(DataSetObserver observer) { mDataSetObservable.unregisterObserver(observer); } /** * Notifies the attached observers that the underlying data has been changed * and any View reflecting the data set should refresh itself. * 當數據集用變化時通知所有觀察者 */ public void notifyDataSetChanged() { mDataSetObservable.notifyChanged(); }} |
可以發現，當數據發生變化時候，notifyDataSetChanged中會調用mDataSetObservable.notifyChanged()方法
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public class DataSetObservable extends Observable<DataSetObserver> { /** * Invokes onChanged on each observer. Called when the data set being observed has * changed, and which when read contains the new state of the data. */ public void notifyChanged() { synchronized(mObservers) { // 調用所有觀察者的onChanged方式 for (int i = mObservers.size() - 1; i >= 0; i--) { mObservers.get(i).onChanged(); } } }} |
mDataSetObservable.notifyChanged()中遍歷所有觀察者，并且調用它們的onChanged方法。
那么這些觀察者是從哪里來的呢？首先ListView通過setAdapter方法來設置Adapter
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
@Override public void setAdapter(ListAdapter adapter) { // 如果已經有了一個adapter,那么先注銷該Adapter對應的觀察者 if (mAdapter != null && mDataSetObserver != null) { mAdapter.unregisterDataSetObserver(mDataSetObserver); } // 代碼省略 super.setAdapter(adapter); if (mAdapter != null) { mAreAllItemsSelectable = mAdapter.areAllItemsEnabled(); mOldItemCount = mItemCount; // 獲取數據的數量 mItemCount = mAdapter.getCount(); checkFocus(); // 注意這里 : 創建一個一個數據集觀察者 mDataSetObserver = new AdapterDataSetObserver(); // 將這個觀察者注冊到Adapter中，實際上是注冊到DataSetObservable中 mAdapter.registerDataSetObserver(mDataSetObserver); // 代碼省略 } else { // 代碼省略 } requestLayout(); } |
在設置Adapter時會構建一個AdapterDataSetObserver，最后將這個觀察者注冊到adapter中，這樣我們的被觀察者、觀察者都有了。
AdapterDataSetObserver定義在ListView的父類AbsListView中，代碼如下 :
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
class AdapterDataSetObserver extends AdapterView<ListAdapter>.AdapterDataSetObserver { @Override public void onChanged() { super.onChanged(); if (mFastScroll != null) { mFastScroll.onSectionsChanged(); } } @Override public void onInvalidated() { super.onInvalidated(); if (mFastScroll != null) { mFastScroll.onSectionsChanged(); } } } |
它由繼承自AbsListView的父類AdapterView的AdapterDataSetObserver, 代碼如下 :
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
class AdapterDataSetObserver extends DataSetObserver { private Parcelable mInstanceState = null; // 調用Adapter的notifyDataSetChanged的時候會調用所有觀察者的onChanged方法,核心實現就在這里 @Override public void onChanged() { mDataChanged = true; mOldItemCount = mItemCount; // 獲取Adapter中數據的數量 mItemCount = getAdapter().getCount(); // Detect the case where a cursor that was previously invalidated has // been repopulated with new data. if (AdapterView.this.getAdapter().hasStableIds() && mInstanceState != null && mOldItemCount == 0 && mItemCount > 0) { AdapterView.this.onRestoreInstanceState(mInstanceState); mInstanceState = null; } else { rememberSyncState(); } checkFocus(); // 重新布局ListView、GridView等AdapterView組件 requestLayout(); } // 代碼省略 public void clearSavedState() { mInstanceState = null; } } |
當ListView的數據發生變化時，調用Adapter的notifyDataSetChanged函數，這個函數又會調用DataSetObservable的notifyChanged函數，這個函數會調用所有觀察者 (AdapterDataSetObserver) 的onChanged方法。這就是一個觀察者模式！
總結：AdapterView中有一個內部類AdapterDataSetObserver,在ListView設置Adapter時會構建一個AdapterDataSetObserver，并且注冊到Adapter中，這個就是一個觀察者。而Adapter中包含一個數據集可觀察者DataSetObservable，在數據數量發生變更時開發者手動調用AdapternotifyDataSetChanged，而notifyDataSetChanged實際上會調用DataSetObservable的notifyChanged函數，該函數會遍歷所有觀察者的onChanged函數。在AdapterDataSetObserver的onChanged函數中會獲取Adapter中數據集的新數量，然后調用ListView的requestLayout()方法重新進行布局，更新用戶界面。
比較知名的使用觀察者模式的開源框架有
模式總結
優點
觀察者模式解除了主題和具體觀察者的耦合，讓耦合的雙方都依賴于抽象，而不是依賴具體。從而使得各自的變化都不會影響另一邊的變化。
缺點
依賴關系并未完全解除，抽象通知者依舊依賴抽象的觀察者。
適用場景
當一個對象的改變需要給變其它對象時，而且它不知道具體有多少個對象有待改變時。
一個抽象某型有兩個方面，當其中一個方面依賴于另一個方面，這時用觀察者模式可以將這兩者封裝在獨立的對象中使它們各自獨立地改變和復用。
以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持服務器之家。
原文鏈接：https://blog.csdn.net/u012124438/article/details/55294914/
