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（接口）：抽象主题，被观察者角色。

 package com.himi.observable;

 import com.himi.observer.Observer;

 public interface Subject {
     public void registerObserver(Observer o);

     public void removeObserver(Observer o);

     public void notifyAllObservers();
 }

HeadHunter：具体主题，具体被观察者者角色。

 package com.himi.observable;

 import java.util.ArrayList;

 import com.himi.observer.Observer;

 public class HeadHunter implements Subject {

     //define a list of users, such as Mike, Bill, etc.
     private ArrayList<Observer> userList;
     private ArrayList<String> jobs;

     public HeadHunter(){
         userList = new ArrayList<Observer>();
         jobs = new ArrayList<String>();
     }

     @Override
     public void registerObserver(Observer o) {
         userList.add(o);
     }

     @Override
     public void removeObserver(Observer o) {}

     @Override
     public void notifyAllObservers() {
         for(Observer o: userList){
             o.update(this);
         }
     }

     public void addJob(String job) {
         this.jobs.add(job);
         notifyAllObservers();
     }

     public ArrayList<String> getJobs() {
         return jobs;
     }

     public String toString(){
         return jobs.toString();
     }

 }

Observer（接口）：抽象观察者，观察者的抽象类。

 package com.himi.observer;

 import com.himi.observable.Subject;

 public interface Observer {
     public void update(Subject s);
 }

JobSeeker：具体的观察者。

 package com.himi.observer;

 import com.himi.observable.Subject;

 public class JobSeeker implements Observer {

     private String name;

     public JobSeeker(String name){
         this.name = name;
     }
     @Override
     public void update(Subject s) {
         System.out.println(this.name + " got notified!");
         //print job list
         System.out.println(s);
     }

 }

最后我们测试一下观察者模式代码如下：

 package com.himi.test;

 import com.himi.observable.HeadHunter;
 import com.himi.observer.JobSeeker;

 public class Test {

     public static void main(String[] args) {
         HeadHunter hh = new HeadHunter();
         hh.registerObserver(new JobSeeker("Mike"));
         hh.registerObserver(new JobSeeker("Chris"));
         hh.registerObserver(new JobSeeker("Jeff"));

         //每次添加一个个job，所有找工作人都可以得到通知。
         hh.addJob("Baidu Job");
         hh.addJob("Alibaba Job");
         hh.addJob("Tecent Job");
     }

 }

运行程序如下：