使用观察者模式监听Map值的改变

 

观察者(Observer)角色：为所有的具体观察者定义一个接口，在得到主题的通知时更新自己，这个接口叫做更新接口。

 

具体观察者(ConcreteObserver)角色：存储与主题的状态自恰的状态。具体观察者角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态 像协调。如果需要，具体观察者角色可以保持一个指向具体主题对象的引用。如本示例中的 ProcessObserver 和 TaskbarObserver

 

被观察者(Observable)角色：内部状态被改变时通知观察者对象。

 

1. 被观察者

 

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Observable;
import java.util.Observer;

/**
 * @ClassName: MainObserver
 * @Description: 被观察者
 * @author 
 * @company 
 * @date 2013-5-2
 * @version V1.0
 */

public class MainObservable extends Observable {

    private static final MainObservable instance = new MainObservable();

    protected Map<String, Object> obs = new HashMap<String, Object>();

    private MainObservable() {}

    public static MainObservable getInstance() {
        return instance;
    }

    /**
     * @Title: doBusiness
     * @Description: 当被观察者有Changed时,通知观察者
     * @param arg
     * @author 
     * @date 2013-5-2
     */
    public void doBusiness(Object arg) {
        // 设置修改状态
        super.setChanged();
        // 通知观察者
        this.notifyObservers(arg);
    }

    /**
     * @Title: notifyObservers
     * @Description: 模仿不同的业务通知对应业务的观察者
     * @param arg
     * @see java.util.Observable#notifyObservers(java.lang.Object)
     * @author 
     */
    public void notifyObservers(Object arg) {

        String msg = arg.toString();

        String[] msgs = msg.split(":");

        if (obs.containsKey(msgs[0])) {
            Observer ob = (Observer) obs.get(msgs[0]);
            ob.update(this, msgs[1]);
        }
    }

    /**
     * @Title: addObserver
     * @Description: 添加一个观察者
     * @param name 观察者名称
     * @param o 观察者对象
     * @author 
     * @date 2013-5-2
     */
    public synchronized void addObserver(String name, Observer o) {

        System.out.println("添加一个观察者:" + name);

        obs.put(name, o);
    }

    /**
     * @Title: updateObserver
     * @Description: 修改一个观察者
     * @param name 观察者名称
     * @param o:观察者对象
     * @author 
     * @date 2013-5-2
     */
    public synchronized void updateObserver(String name, Observer o) {

        Iterator<String> it = obs.keySet().iterator();

        String key = null;

        while (it.hasNext()) {

            key = it.next();

            if (key.equals(name)) {
                System.out.println("被修改的key为:" + key);
                obs.put(key, o);
                break;
            }
        }
    }

    /**
     * @Title: deleteObserver
     * @Description: 删除观察者
     * @param o: 观察者对象
     * @see java.util.Observable#deleteObserver(java.util.Observer)
     * @author 
     */
    public synchronized void deleteObserver(Observer o) {

        if (obs.values().contains(o)) {

            Iterator<String> it = obs.keySet().iterator();

            String key = null;

            while (it.hasNext()) {

                key = it.next();

                if (obs.get(key).equals(o)) {
                    System.out.println("被删除的key为:" + key);
                    obs.remove(key);
                    break;
                }
            }
        }
    }
}

 

2. 具体观察者对象

    2.1     

 

import java.util.Observable;
import java.util.Observer;

/**
 * @ClassName: ProcessObserver
 * @Description: 观察者
 * @author 
 * @company 
 * @date 2013-5-2
 * @version V1.0
 */

public class ProcessObserver implements Observer {

    /**
     * @Title: update
     * @Description:实现观察者接口,当发现被观察者有Changed时执行该方法
     * @param o 观察者对象
     * @param arg:
     * @see java.util.Observer#update(java.util.Observable, java.lang.Object)
     * @author 
     */
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("update:" + arg);
    }

}

 

   2.2      

 

import java.util.Observable;
import java.util.Observer;

/**
 * @ClassName: TaskbarObserver
 * @Description: 观察者
 * @author 
 * @company 
 * @date 2013-5-2
 * @version V1.0
 */

public class TaskbarObserver implements Observer {

    /**
     * @Title: update
     * @Description: 实现观察者接口,当发现被观察者有Changed时执行该方法
     * @param o
     * @param arg:
     * @see java.util.Observer#update(java.util.Observable, java.lang.Object)
     * @author 
     */
    @Override
    public void update(Observable o, Object arg) {
        System.out.println(arg);
    }

}

 

3. 测试类

 

public class Test {

    /**
     * @Title: main
     * @Description: TODO
     * @param args:
     * @author 
     * @date 2013-5-2
     */
    public static void main(String[] args) {

        // 实例化一个被观察者
        MainObservable ob = MainObservable.getInstance();

        // 实例化观察者
        ProcessObserver pro = new ProcessObserver();
        TaskbarObserver task = new TaskbarObserver();

        // 添加观察者
        ob.addObserver("proc", pro);
        ob.addObserver("task", task);

        System.out.println("添加后,Map=" + ob.obs);

        // 处理业务,当关闭一个eclipse时,通知两个观察者同时也移除该任务
        System.out.println("发送一条进程信息...");
        ob.doBusiness("proc:进程启动");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("发送一条任务信息...");
        ob.doBusiness("task:我给任务器推送消息了");

        // 移除一个观察者
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        ob.doBusiness("task:删除.");
        ob.deleteObserver(pro);
        System.out.println("删除后,Map=" + ob.obs);
        System.out.println("发送一条进程信息...");

        ob.doBusiness("task:重新添加.");
        
        task = new TaskbarObserver();

        ob.addObserver("task111", task);

        System.out.println("再次添加后,Map=" + ob.obs);

        ob.doBusiness("task:修改.");
        
        // 修改
        TaskbarObserver task1 = new TaskbarObserver();
        ob.updateObserver("task111", task1);

        System.out.println("修改后,Map=" + ob.obs);
       
    }
}

 

4. 测试结果

添加一个观察者:proc
添加一个观察者:task
添加后,Map={task=designpatterns.observer.exam01.TaskbarObserver@1ce2dd4, proc=designpatterns.observer.exam01.ProcessObserver@122cdb6}
发送一条进程信息...
update:进程启动
发送一条任务信息...
我给任务器推送消息了
删除.
被删除的key为:proc
删除后,Map={task=designpatterns.observer.exam01.TaskbarObserver@1ce2dd4}
发送一条进程信息...
重新添加.
添加一个观察者:task111
再次添加后,Map={task=designpatterns.observer.exam01.TaskbarObserver@1ce2dd4, task111=designpatterns.observer.exam01.TaskbarObserver@1a52fdf}
修改.
被修改的key为:task111
修改后,Map={task=designpatterns.observer.exam01.TaskbarObserver@1ce2dd4, task111=designpatterns.observer.exam01.TaskbarObserver@dc57db}