观察者模式

观察者模式（Observer Pattern）也叫做发布订阅模式（Publish/subscribe）。 

观察者模式的意图是：定义对象之间一对多的依赖关系，一个对象状态改变，其他相关联的对象就会得到通知并被自动更新。

观察者模式应用：

1、智能手机应用在本质上是观察者模式的一种体现，这些应用都是事件驱动机制，只要有事件发生，就会做出一系列的响应处理；在没有事件的时候，什么也不会发生。

2、TMC审批系统中审批状态的流转，当审批人A审批完，通知后边的审批人B、C、D……继续审批，直到流程结束。

 观察者模式的优点：

1. 1. 观察者和被观察者之间是抽象耦合；
   2. 建立一套触发机制。

观察者模式的缺点：

观察者模式需要考虑开发效率和运行效率的问题。

观察者模式角色如下：

抽象主题（Subject）角色：抽象主题角色提供维护一个观察者对象聚集的操作方法，对聚集的增加、删除等。

具体主题（ConcreteSubject）角色：将有关状态存入具体的观察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知。具体主题角色负责实现抽象主题中的管理方法。

抽象观察者（Observer）角色：为具体观察者提供一个更新接口。

具体观察者（ConcreteObserver）角色：存储与主题相关的自洽状态，实现抽象观察者提供的更新接口。

示例代码：

1、 抽象主题

public interface Subject {
    public void attach(Observer observer);
    
    public void detach(Observer observer);
    
    void notifyObservers();
}

2、具体主题

public class ConcreteSubject implements Subject {
    private Vector<Observer>observersVector = new Vector<Observer>();
  
    public void attach(Observer observer) {
        observersVector.addElement(observer);
    }
    
    public void detach(Observer observer) {
        observersVector.removeElement(observer);
    }
    
    public void notifyObservers() {
        Enumeration<Observer>enumeration = observers();
        while (enumeration.hasMoreElements()) {
            ((Observer) enumeration.nextElement()).update();
        }
    }
    
    public Enumeration<Observer> observers() {
        return ((Vector<Observer>) observersVector.clone()).elements();
    }
}

3、抽象观察者

public interface Observer {
    public void update();
}

4、 具体观察者

public class ConcreteObserver implements Observer{
    @Override
    public void update() {
        // 写业务逻辑
    }
}

示例：

public class ObserverPattern {
    public interface Observer {
        void update(Subject s);
    }
 
    public interface Subject {
        void registerObserver(Observer o);
 
        void removeObserver(Observer o);
 
        void notifyAllObservers();
    }
 
    public static 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();
        }
    }
 
    public static class JobSeeker implements Observer {
 
        private String name;
 
        public JobSeeker(String name) {
            this.name = name;
        }
 
        @Override
        public void update(Subject subject) {
            System.out.println(this.name + " got notified!");
            System.out.println("Jobs: " + subject + "\n");
        }
    }
 
    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("Google Job");
        hh.addJob("Yahoo Job");
    }
}

输出：
Mike got notified!
Jobs: [Google Job]
 
Chris got notified!
Jobs: [Google Job]
 
Jeff got notified!
Jobs: [Google Job]
 
Mike got notified!
Jobs: [Google Job, Yahoo Job]
 
Chris got notified!
Jobs: [Google Job, Yahoo Job]
 
Jeff got notified!
Jobs: [Google Job, Yahoo Job]