观察者（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;}}@Overridepublic 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();}}}}@Overridepublic 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;}@Overridepublic 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对象，而不是事件 ，这样就巧妙的避免了多创建观察者类了。