观察者模式是一种设计模式，用于定义对象间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并被自动更新。应用场景包括网络连接监听和生产者消费者问题。该模式通过维护一个观察者列表，在被观察对象状态变化时遍历执行观察者的方法。可以使用JDK自带的Observable类或者自定义实现。
观察者（Observer）模式
当某被观察对象发生变化时候，观察它的对象都能及时做出相应的反应
应用场景：
定义一对多的依赖关系，当其中的一发生变化的时候，其中的多能够及时做出相应的反应
场景A：如上一篇讲的，客户端的多个事件都关注着网络连接状态，当网络连接状态OK的时候，多个事件都能够及时继续执行
场景B：生产者与消费者情景 。多个消费者都要竞争一个产品。但是目前产品缺货，当产品补充的时候，消费者们能够及时的去竞价购买
实现 ： 观察者模式 ，就是在被观察对象中，保留有观察者的队列 。当被观察对象发生改变的时候 ，就遍历观察者队列 ，执行观察者的方法
应用方式： 针对场景A
方式1、不利用JDK自带Observable类，自行构建观察者和被观察对象
网络连接监听类：
package designers.observer;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketAddress;
import java.util.ArrayList;
import java.util.List;
import org.apache.log4j.Logger;
/**
* 方式一 网络连接
* @author xubo
*
*/
public class NetCheck extends Thread {
static private Logger logger = Logger.getLogger(NetCheck.class);
private static NetCheck instance;
long sleepTimes = 10 * 1000l;// 重连间隔
private int timeout = 20 * 1000; // 默认测试连接超时时间：20秒
private static List<Object> lockList = new ArrayList<Object>();
private NetCheck(Object lock) {
lockList.add(lock);
}
/**
* 开线程
*/
public static void startThread(Object lock) {
if (lock == null) {
return;
}
if (null == instance || !instance.isAlive()) { // 如果没有活动中的线程
synchronized (NetCheck.class) {
if (null == instance || !instance.isAlive()) {
instance = new NetCheck(lock);
instance.setName(NetCheck.class.getName());
instance.start();
}
}
} else {
lockList.add(lock);
}
}
/**
* 停线程
*/
public synchronized void stopThread() {
if (null != instance) {
instance.stop(); // 不要用interrupt，因为测试网络连接可能会超时情况，interrupt导致无限循环线程不会终止
instance = null;
}
}
@Override
public void run() {
Socket socket = null;
try {
SocketAddress socketAddress = new InetSocketAddress("127.0.0.1", 8080);
while (true) {
try {
socket = new Socket();
socket.connect(socketAddress, timeout);
break;// 成功就退出线程
} catch (IOException e) {
logger.error("测试连接中断失败", e);
if (socket != null) {
try {
socket.close();
} catch (IOException e1) {
logger.error("异常", e1);
}
}
Thread.sleep(sleepTimes);
}
}
//连接OK 通知所有观众继续
notifyAllLock();
} catch (InterruptedException e) {
logger.error("线程被异常中断", e);
}
}
/**
* 网络连接OK后，就执行代码
*/
private void notifyAllLock() {
Object o = null;
for (int i = lockList.size() - 1; i < lockList.size();) {
o = lockList.get(i);
synchronized (o) {
lockList.remove(i);
o.notifyAll();
}
}
}
}
事件类
package designers.observer;
/**
* 方式一 事件类
* @author xubo
*
*/
public class EventA extends Thread {
private String msg;
public EventA(String msg) {
this.msg = msg;
}
public void run() {
Object ob = new Object();
synchronized (ob) {
//省略检查网络代码 ，判定为不通
boolean isNetConnection = false;
if (!isNetConnection) {
//网络不通，就启用网络监听线程，待网络恢复就继续，没有恢复就阻断
NetCheck.startThread(ob);
try {
ob.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(msg);
}
}
}
测试Main方法
public static void main(String args[]) {
EventA e1 = new EventA("事件a在执行");
EventA e2 = new EventA("事件b在执行");
e1.start();
e2.start();
}执行结果 ：
当我们在本地启动一个监听8080端口的Socket服务之前，没有任何输出 。 当我们启动8080端口监听服务之后，会输出“事件a在执
行”与“事件b在执行” 。
注：由于线程分配CPU时间片的顺序不定 ，2句话的使出也不定
方式2：利用JDK自带的Observable类
网络连接监听类
package designers.observer;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketAddress;
import java.util.Observable;
import org.apache.log4j.Logger;
public class NetCheckB extends Observable implements Runnable {
static private Logger logger = Logger.getLogger(NetCheck.class);
private static Thread instance;
private static NetCheckB nb = new NetCheckB();
private NetCheckB() {
}
public static NetCheckB getNetCheckB() {
return nb;
}
long sleepTimes = 10 * 1000l;// 重连间隔
private int timeout = 20 * 1000; // 默认测试连接超时时间：20秒
/**
* 开线程
*/
public static void startThread() {
if (null == instance || !instance.isAlive()) { // 如果没有活动中的线程
synchronized (NetCheckB.class) {
if (null == instance || !instance.isAlive()) {
instance = new Thread(new NetCheckB());
instance.setName(NetCheckB.class.getName());
instance.start();
}
}
}
}
@Override
public void run() {
Socket socket = null;
try {
SocketAddress socketAddress = new InetSocketAddress("127.0.0.1", 8080);
while (true) {
try {
socket = new Socket();
socket.connect(socketAddress, timeout);
break;// 成功就退出线程
} catch (IOException e) {
logger.error("测试连接中断失败", e);
if (socket != null) {
try {
socket.close();
} catch (IOException e1) {
logger.error("异常", e1);
}
}
Thread.sleep(sleepTimes);
}
}
//连接OK 通知所有观众继续 (父类封装的通知方法，调用观察者中的update方法)
setChanged();
nb.notifyObservers();
} catch (InterruptedException e) {
logger.error("线程被异常中断", e);
}
}
}
事件类
package designers.observer;
import java.util.Observable;
import java.util.Observer;
/**
* 方式二 ：事件
* @author xubo
*
*/
public class EventB extends Thread implements Observer {
private String msg;
public EventB(String msg) {
this.msg = msg;
}
@Override
public void update(Observable o, Object arg) {
System.out.println(msg);
}
public void run() {
//省略检查网络代码 ，判定为不通
boolean isNetConnection = false;
if (!isNetConnection) {
//网络不通，就启用网络监听线程，待网络恢复就继续，没有恢复就阻断
NetCheckB.getNetCheckB().addObserver(this);
NetCheckB.startThread();
}
}
}
测试Main方法
public static void main(String args[]) {
EventB e1 = new EventB("事件a在执行");
EventB e2 = new EventB("事件b在执行");
e1.start();
e2.start();
}2种方式 总结 ：
1、观察者模式 ，就是在被观察对象中，保留有观察者的队列 。当被观察对象发生改变的时候 ，就遍历观察者队列 ，执行观察者的方法
2、如果观察者很明确 ，直接用JDK的封装Observer类 ，代码会更简洁
3、方式一中的观察者实际上是 ob.wait()中的ob对象，而不是事件 ，这样就巧妙的避免了多创建观察者类了。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
