设计模式之二 观察者模式

 

   

• 观察者（Observer）模式

1) 例子：报纸和杂志的订阅

1. 报社的业务就是出版报纸
2. 向某家报社订阅报纸，只要他们有新报纸出版，就会给你送来。只要你是他们的订户，你就会一直收到新报纸。、
3. 当你不想看到报纸的时候，取消订阅，他们就不会再送新报纸来。
4. 只要报社还在运营，就一直会有人（或单位）向他们订阅或取消订阅报纸。

出版者(Subject) + 订阅者(Observer) = 观察者模式

2) 定义：

观察者模式定义了对象之间的一对多依赖，这样一来，当一个对象(Subject)改变状态时，它的所有依赖者(Observer)都会收到通知并自动更新。

3) 观察者模式具体实现

1. 定义一个抽象主题(被观察者)接口

package com.kwin.observer;
/***
 * 抽象被观察者接口
 * 声明了添加、删除、通知观察者方法
 * @author kwin
 *
 */
public interface Observerable {
             
    public void registerObserver(Observer o);
    public void removeObserver(Observer o);
    public void notifyObserver(); 
}

2. 定义一个抽象观察者接口 

package com.kwin.observer; 
/***
 * 抽象观察者 
 * 定义了一个update()方法，当被观察者调用notifyObservers()方法时，观察者的update()方法会被回调。
 * @author kwin
 *
 */
public interface Observer {
    public void update(String message);
}

3. 定义主题(被观察者)，实现了Observerable 接口，对接口的三个方法进行了具体实现，其中用一个List集合保存注册的观察者。

package com.kwin.observer;
import java.util.ArrayList;
import java.util.List;
               
/**
 * 主题(被观察者)，也就是微信公众号服务
 * 实现了Observerable接口，对Observerable接口的三个方法进行了具体实现
 * @author kwin
 *
 */
public class WechatServer implements Observerable {
             
    //注意到这个List集合的泛型参数为Observer接口，设计原则：面向接口编程而不是面向实现编程
    private List<Observer> list;
    private String message;
             
    public WechatServer() {
        list = new ArrayList<Observer>();
    }
             
    @Override
    public void registerObserver(Observer o) { 
        list.add(o);
    }
                 
    @Override
    public void removeObserver(Observer o) {
        if(!list.isEmpty())
            list.remove(o);
    }
            
    //遍历
    @Override
    public void notifyObserver() {
        for(int i = 0; i < list.size(); i++) {
            Observer oserver = list.get(i);
                oserver.update(message);
        }
    }
             
    public void setInfomation(String s) {
        this.message = s;
        System.out.println("微信服务更新消息： " + s);
        //消息更新，通知所有观察者
        notifyObserver();
    }
}

4. 定义具体观察者，微信公众号的具体观察者为用户User

package com.kwin.observer;

/**
 * 观察者
 * 实现了update方法
 * @author kwin
 *
 */
public class User implements Observer {
    
    private String name;
    private String message;

    public User(String name) {
        this.name = name;
    }
    
    @Override
    public void update(String message) {
        this.message = message;
        read();
    }
    
    public void read() {
        System.out.println(name + " 收到推送消息： " + message);
    }
}

 

5. 编写一个测试类

首先注册了三个用户，ZhangSan、LiSi、WangWu。公众号发布了一条消息"PHP是世界上最好用的语言！"，三个用户都收到了消息。

用户ZhangSan看到消息后颇为震惊，果断取消订阅，这时公众号又推送了一条消息，此时用户ZhangSan已经收不到消息，其他用户

还是正常能收到推送消息。

package com.kwin.observer;

public class Test {
    
    public static void main(String[] args) {
        WechatServer server = new WechatServer();
                   
        Observer userZhang = new User("ZhangSan");
        Observer userLi = new User("LiSi");
        Observer userWang = new User("WangWu");
                  
        server.registerObserver(userZhang);
        server.registerObserver(userLi);
        server.registerObserver(userWang);
        server.setInfomation("PHP是世界上最好用的语言！");
                  
        System.out.println("----------------------------------------------");
        server.removeObserver(userZhang);
        server.setInfomation("JAVA是世界上最好用的语言！");
                  
    }
}

4) 设计原则

找出应用中可能需要变化之处，把他们独立出来，不要和那些不需要变化的代码混在一起。

针对接口编程，而非针对实现编程。

多用组合，少用继承

为了交互对象之间的松耦合设计而努力

 

5) 小结

这个模式是松耦合的。改变主题或观察者中的一方，另一方不会受到影像。

JDK中也有自带的观察者模式。但是被观察者是一个类而不是接口，限制了它的复用能力。

在JavaBean和Swing中也可以看到观察者模式的影子。

为控件绑定监听方法，是常用的观察者模式。