设计模式-观察者模式（Observer Model）

文 / vincentzh

原文连接：http://www.cnblogs.com/vincentzh/p/6031844.html 

　　LZ刚刚开始心热的开启了博客之路，想着记点流水账，可帝都的天都冷成狗了一样，还特么不供暖，冻的打字都感觉不到键盘在哪里。。。

目录

1. 1、概述
2. 2、原理
3. 3、结构组成
4. 4、实现
   1. 4.1 静态代理
   2. 4.2 动态代理
5. 5、总结

1、概述

　　观察者模式通俗讲就是一堆观察者对象同时观察一个对象的状态。好比一妹子后面跟了一群追求者，妹子一看，这仨还错，有才华、有相貌、有money，先允许你们三来竞争吧。姑娘口渴了，仨小伙急了，纷纷去给姑娘去买水，又是矿泉水又是饮料的。

2、原理

　　观察者模式的原理比较简单，类似于监听，定义了一种一对多的关系，让多个观察者同时监听一个主题对象，当主题角色状态发生变化时，会通知所有观察者对象，使它们去自行更新。

3、结构组成

　　观察者模式原理简单，但结构上还是稍微有点绕。其包含了4个角色：

抽象主题角色（Subject）：抽象主题角色只提供一个接口，它将所有的观察者引用保存再一个容器里，同时提供增加观察者、删除观察者、通知所有观察者的方法；

具体主题角色（ConcreteSubject）：具体主题角色提供一个容器保存所有观察者的引用，当其状态发生改变时，会通知在其容器内登记过的所有观察者；

抽象观察者角色（Observer）：抽象观察者角色为具体观察者角色定义了一个接口，它提供了具体观察者角色更新自己的方法；

具体观察者角色（ConcreteObserver）：具体观察者角色实现了抽象观察者角色定义的更新方法，以更新自己状态和主题角色状态一致，或着说相应主题角色状态的改变。

4、实现

　　观察者模式的实现在4.1这里举了个例子，有点牵强，但能说明问题；4.2是利用JDK提供的接口和类去实现的观察者模式。

4.1 场景案例

　　年关将至，镇长下乡去视察，看看下属各个村儿里今年的收入情况怎么样，群众有没有赚到钱呀，庄稼收成好不好呀，bulabula...。各村儿一听镇长要下乡，好家伙，赶紧趁这个机会好好表现表现，说不定明年镇长能多给村儿里几个低保名额。A村提前给镇长就做好了热腾腾的裤带面，B村知道领导都好面子，老早就搞起了锣鼓队给领导办欢迎仪式。

抽象观察者类：

package com.cnblogs.vincentzh.observer;
// 抽象观察者角色（村儿接口）
public interface Villages
{
    public void action(String str);
}

 

抽象主题类：

package com.cnblogs.vincentzh.observer;
// 抽象主题角色（领导接口）
public interface LeaderShip 
{     
     public boolean add(Villages village);
     public boolean delete(Villages village);
     public void notify(String str);
}

 

具体主题类：

package com.cnblogs.vincentzh.observer;

import java.util.HashSet;
// 具体主题角色（镇长）
public class Mayor implements LeaderShip
{    
    // 观察者容器
    public HashSet<Villages> villages = new HashSet<Villages>();
    
    @Override
    public boolean add(Villages village)
    {
        return villages.add(village);
    }

    @Override
    public boolean delete(Villages village)
    {
        return villages.remove(village);
    }
    
    @Override
    public void notify(String str)
    {
        for(Villages village : villages)
        {
            village.action(str);
        }
    }
}

 

具体观察者类：

package com.cnblogs.vincentzh.observer;
// 具体观察者角色（村儿）
public class Village implements Villages
{
    private String string;
    
    public Village(String string)
    {
        this.string = string;
    }
    
    @Override
    public void action(String str)
    {
        System.out.println(str);
        System.out.println(string + " for LeaderShip");
    }
}

 

环境测试类：

package com.cnblogs.vincentzh.observer;
// 环境测试类
public class Test
{
    /**
     * @param args
     */
    public static void main(String[] args)
    {
        LeaderShip mayor = new Mayor();
        
        Village village1 = new Village("village1: We cooking"); // A村做饭
        Village village2 = new Village("village2: We welcome"); // B村欢迎
        
        mayor.add(village1);
        mayor.add(village2);
        mayor.notify("Mayor is comming!");
        
        System.out.println("------------------------------");
        mayor.delete(village1);
        mayor.notify("Mayor is comming!");
    }
}

结果：

4.2 JDK实现

　　JDK内部提供了用于实现观察者模式的Observable 类和 Observer 接口，它们分别充当了抽象主题角色和抽象观察者角色，要实现观察者模式，只需要定义具体主题类并继承 Observable 类重写相应的方法，同时定义具体观察者对象实现 Observer 接口并实现其中的更新方法即可。

具体主题类：

package com.cnblogs.vincentzh.observermodel;

import java.util.HashSet;
import java.util.Observable;
import java.util.Observer;
// 具体主题角色（及被观察者）
public class Watched extends Observable
{
    // 观察者容器
    private HashSet<Observer> sets = new HashSet<Observer>();    
    
    @Override
    public synchronized void addObserver(Observer o)
    {
        sets.add(o);
    }
    
    @Override
    public synchronized void deleteObserver(Observer o)
    {
        sets.remove(o);
    }
    
    @Override
    public void notifyObservers()
    {
        for(Observer observer : sets)
        {
            observer.update(this, this);
        }
    }    
}

 

具体观察者类：

package com.cnblogs.vincentzh.observermodel;

import java.util.Observable;
import java.util.Observer;
// 观察者角色（即观察者）
public class Watcher implements Observer
{
    private String str;
    
    public Watcher(String str)
    {
        this.str = str;
    }
        
    @Override
    public void update(Observable o, Object arg)
    {
        System.out.println((String)str);
    }
}

 

环境测试类：

package com.cnblogs.vincentzh.observermodel;
// 环境测试类
public class Test
{
    public static void main(String[] args)
    {
        Watcher watcher1 = new Watcher("watched1");
        Watcher watcher2 = new Watcher("watched2");
        
        Watched watched = new Watched();
        
        watched.addObserver(watcher1);
        watched.addObserver(watcher2);
        watched.notifyObservers();
        
        System.out.println("---------------------------");
        
        watched.deleteObserver(watcher1);
        watched.notifyObservers();
    }
}

 

结果：

5、总结

 　　观察者模式对主题对象和观察者对象进行了解耦，使双方都依赖于抽象，而并不是依赖于对方的具体对象，使得双方各自的变化都不会影响到对方的具体对象。但双方并没有完全的独立，抽象主题通知时仍然依赖于抽象观察者。当其他多个对象需要根据一个对象的状态发生相应的改变或操作时（或类似发布/订阅模式），可使用观察者模式来解决。