java 设计模式 观察者模式 新闻消息推送

观察者模式，字面意思有个观察者，那么就应该有一个被观察者。两个定义：

观察者：Observer （比如新闻客户端，你自己的微信号）

被观察者：Observable（新闻推送端，你关注的微信公众号）

1.观察者可以同时订阅多个被观察者。

2.被观察者可以同时被多个观察者订阅。

3.被观察者发生改变时会影响到所有的观察者。



对于每个用户都存在这三条线路。

Java中已经帮我们实现了观察者模式，借助于java.util.Observable和java.util.Observer。

接下来代码时间。

需求：新闻推送端News，需要向某个客户ClientX端推送消息，客户端可以选择去打开或者关闭推送功能。

新闻推送端News代码

package test;

import java.util.Observable;

public class News extends Observable{

private String news;

public String getNews() {
return news;
}

public void setNews(String news) {
this.news = news;
//发生改变
setChanged();
//推送消息到客户端
notifyObservers();
}
}

新闻客户端代码

package test;

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

public class ClientX implements Observer {

/**
* 打开推送功能
* @param observable  被观察者对象（这里是新闻推送端）
*/
public void openPushMsg(Observable observable)
{
//添加到观察者列表
observable.addObserver(this);
}
/**
* 实现接口重新的方法
* 有新消息推送来时，会被调用
*/
public void update(Observable observable, Object arg) {
if(observable instanceof News){//判断是否来自新闻推送端
News news=(News) observable;
System.out.println("现在最新消息："+news.getNews());
}

}
/**
* 关闭推送功能
* @param observable  被观察者对象（这里是新闻推送端）
*/
public void closePushMsg(Observable observable){
//从观察者列表移除
observable.deleteObserver(this);
}

}

测试

package test;

public class Test
{
public static void main(String[] args)
{
News news=new News();
ClientX bObserver1=new ClientX();
//客户端打开推送功能
bObserver1.openPushMsg(news);
news.setNews("世界末日了");
//客户端关闭推送功能
bObserver1.closePushMsg(news);
news.setNews("发现新大陆");

}
}

执行结果：

现在最新消息：世界末日了

从执行结果上来看，只执行了打开推送功能时的消息推送。

java.util.Observable和java.util.Observer，的源码解析

先看一下观察者Observer接口的源码：

/*
* Copyright (c) 1994, 1998, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

*/
package java.util;

/**
* A class can implement the <code>Observer</code> interface when it
* wants to be informed of changes in observable objects.
*
* @author  Chris Warth
* @see     java.util.Observable
* @since   JDK1.0
*/
public interface Observer {
/**
* This method is called whenever the observed object is changed. An
* application calls an <tt>Observable</tt> object's
* <code>notifyObservers</code> method to have all the object's
* observers notified of the change.
*
* @param   o     the observable object.
* @param   arg   an argument passed to the <code>notifyObservers</code>
*                 method.
*/
void update(Observable o, Object arg);
}

打开之后就一个update（）的方法。每当被观察者改变的时候，这个方法会得到执行。而且通过方法我们可以得到被观察者对象和传递的一个Object对象。

Observable的源码

代码虽然不多，也就不到一百行吧，但是注释太多，先看结构图吧：



一个boolean changed变量用来判断，被观察者是否改变。

一个Vector< Observer > obs集合对象，用来保存注册的观察者。

addObserver

/**
* Adds an observer to the set of observers for this object, provided
* that it is not the same as some observer already in the set.
* The order in which notifications will be delivered to multiple
* observers is not specified. See the class comment.
*
* @param   o   an observer to be added.
* @throws NullPointerException   if the parameter o is null.
*/
public synchronized void addObserver(Observer o) {
if (o == null)
throw new NullPointerException();
if (!obs.contains(o)) {
obs.addElement(o);
}
}

如果传递进来的观察者对象不为空，就添加进集合中

deleteObserver

/**
* Deletes an observer from the set of observers of this object.
* Passing <CODE>null</CODE> to this method will have no effect.
* @param   o   the observer to be deleted.
*/
public synchronized void deleteObserver(Observer o) {
obs.removeElement(o);
}

有添加就有移除，移除观察者对象。

notifyObservers无参

public void notifyObservers() {
notifyObservers(null);
}

无参的唤醒方法会调用有参的唤醒方法。

列表内容

public void notifyObservers(Object arg) {
Object[] arrLocal;

synchronized (this) {

if (!changed)
return;
arrLocal = obs.toArray();
clearChanged();
}

for (int i = arrLocal.length-1; i>=0; i--)
((Observer)arrLocal[i]).update(this, arg);
}

如果被观察者发生改变，就会把集合变成数组，然后遍历数组，调用每个观察者的update方法。

几个主要的方法就这么多，所有的被观察者的注册、取消注册和唤醒观察者的方法都是一样的。java封装成一个类就完成了方法的重复利用。如果采用面向接口的设计模式，那么不同的被观察者就必须去实现这些方法，而这些方法的逻辑是一样的，就不能重复利用代码了。