Java設計模式16：經常使用設計模式之觀察者模式（行爲型模式）

1. Java之觀察者模式（Observer Pattern）

（1）概述：

　生活中咱們在使用新聞app，當咱們對某一欄比較感興趣，咱們每每會訂閱這欄新聞，好比我對軍事欄感興趣，我就會訂閱軍事欄的新聞。這樣的話，一旦有了軍事欄新聞更新，App就會自動彈出通知告知咱們。

這就是觀察者模式，她定義對象間的一種一對多的依賴關係，當一個對象（被觀察者）的狀態發生改變時, 全部依賴於它的對象（觀察者）都獲得通知並被自動更新。

（2）觀察者模式的UML類圖：

角色介紹：

1）Subject：抽象主題，也就是被觀察者（Observable）角色，抽象主題角色把全部觀察者對象的引用保存在一個集合之中，每一個主題均可以有任意數量的觀察者，抽象主題提供一個接口，能夠增長和刪除觀察者對象。

2）ConcreteSubject：具體主題，該角色將有關狀態存入具體觀察者對象，在具體主題的內部狀態發生變化時候，給全部註冊過的觀察者發出通知，具體主題角色又叫具體被觀察者（Concrete Observable）角色。

3）Observer：抽象觀察者，該角色是觀察者的抽象類，它定義了一個更新的接口，使得在獲得主題的更改通知時候更新本身。

4）ConcreteObserver：具體的觀察者，該角色實現抽象觀察者角色定義的更新接口，以便在主題的狀態發生變化的時候更新自身的狀態。

 

2. 觀察者模式代碼實現：

（1）下面是一個獵頭的典型例子。這個圖中有2個角色-獵頭和求職者。求職者先在獵頭處註冊，當有新的工做機會時獵頭就會通知求職者。

觀察者模式—獵頭和求職者的UML圖，以下：

 

（2）新建Java工程，以下：

Subject（接口）：抽象主題，被觀察者角色。

 1 package com.himi.observable;  2 
 3 import com.himi.observer.Observer;  4 
 5 public interface Subject {  6     public void registerObserver(Observer o);  7 
 8     public void removeObserver(Observer o);  9 
10     public void notifyAllObservers(); 11 }

 

HeadHunter：具體主題，具體被觀察者者角色。

 1 package com.himi.observable;  2 
 3 import java.util.ArrayList;  4 
 5 import com.himi.observer.Observer;  6 
 7 public class HeadHunter implements Subject {  8 
 9     //define a list of users, such as Mike, Bill, etc.
10     private ArrayList<Observer> userList; 11     private ArrayList<String> jobs; 12  
13     public HeadHunter(){ 14         userList = new ArrayList<Observer>(); 15         jobs = new ArrayList<String>(); 16  } 17  
18  @Override 19     public void registerObserver(Observer o) { 20  userList.add(o); 21  } 22  
23  @Override 24     public void removeObserver(Observer o) {} 25  
26  @Override 27     public void notifyAllObservers() { 28         for(Observer o: userList){ 29             o.update(this); 30  } 31  } 32  
33     public void addJob(String job) { 34         this.jobs.add(job); 35  notifyAllObservers(); 36  } 37  
38     public ArrayList<String> getJobs() { 39         return jobs; 40  } 41  
42     public String toString(){ 43         return jobs.toString(); 44  } 45 
46 }

 

 

Observer（接口）：抽象觀察者，觀察者的抽象類。

1 package com.himi.observer; 2 
3 import com.himi.observable.Subject; 4 
5 public interface Observer { 6     public void update(Subject s); 7 }

 

JobSeeker：具體的觀察者。

 1 package com.himi.observer;  2 
 3 import com.himi.observable.Subject;  4 
 5 public class JobSeeker implements Observer {  6 
 7     private String name;  8      
 9     public JobSeeker(String name){ 10         this.name = name; 11  } 12  @Override 13     public void update(Subject s) { 14         System.out.println(this.name + " got notified!"); 15         //print job list
16  System.out.println(s); 17  } 18 
19 }

 

最後咱們測試一下觀察者模式代碼以下：

 1 package com.himi.test;  2 
 3 import com.himi.observable.HeadHunter;  4 import com.himi.observer.JobSeeker;  5 
 6 public class Test {  7 
 8     public static void main(String[] args) {  9         HeadHunter hh = new HeadHunter(); 10         hh.registerObserver(new JobSeeker("Mike")); 11         hh.registerObserver(new JobSeeker("Chris")); 12         hh.registerObserver(new JobSeeker("Jeff")); 13  
14         //每次添加一個個job，全部找工做人均可以獲得通知。
15         hh.addJob("Baidu Job"); 16         hh.addJob("Alibaba Job"); 17         hh.addJob("Tecent Job"); 18  } 19 
20 }

運行程序以下：