(一)设计模式复习之观察者模式

这次做一个设计模式的回顾笔记，通过周刊订阅来描述观察者模式。

首先提出个疑问什么是观察者模式？

通俗来讲平时在编写程序中用到的点击回调事件，其实就是观察者模式，所以观察者模式对于开发者来说一点都不陌生。

既然这样我们为什么还要讲观察这模式呢？

下面就通过周刊订阅来讲述一下 《观察者模式》，周刊想必很多人都有订阅过或者自己去买过，对这种行为的整个流程也是相当熟悉的。

首先当不去订阅的是时候，每次有新的周刊发版的时候都需要自己去书店里面询问购买，而且我们不知道具体什么时候有周刊发版，所以

有些时候就会白跑了一趟，或者可以选择晚一点去购买，那么虽然可以买到这期的周刊，但是却没有不能达到第一时间阅读周刊的实效性。

首先这是一个书店类：

public class BookShop {

private Random random = new Random();

public String getBook() {
int i = random.nextInt(2);
//0表示没有周刊，1表示有周刊
if (i == 0) {
return "";
} else {
return "读者";
}
}

}

接着分别是两个购买周刊的人，如下：

第一个购买者：

public class PurchaserOne {

BookShop bShop = new BookShop();

public void readBook(){
System.out.println(bShop.getBook());
}

}

第二个购买者：

public class PurchaserTwo {
BookShop bShop = new BookShop();

public void readBook() {
System.out.println(bShop.getBook());
}
}

通过上面这个例子，很明了的就可以知道，当自己主动去书店购买周刊有时候不一定有用周刊发版，这种情况其实生活中我们也是经常会遇到的，

当你想要去买某样东西的时候，就去商场里面去找结果没有找到，那就白跑了。那么为什么不通过订购的方式，让买家在有货源的时候主动通知自己呢？

下面就通过代码实现，让买家在有货源的时候主动通知我们，如下：

public class BookShop {

private Random random = new Random();

private PurchaserOne one = new PurchaserOne();
private PurchaserTwo two = new PurchaserTwo();

public void readBook() {
int i = random.nextInt(2);
if (i == 1) {
one.readBook();
two.readBook();
}
}

public String getBook() {
return "读者";
}

}
这么一来就可以不用每次都去跑去店铺询问有么有周刊了，当天有周刊的时候就会直接通知我们，或者送来给我们。
虽然这样子可以不去询问，当用新发版的周刊会得到通知，但是有没有发现这么做的耦合性很高，每加多一个新的
购买者，就需要在书店类里面多实例化一个购买者。
如果这个书店就仅仅供应给那么的几个人，那没问题耦合度高也没什么大问题，毕竟就是固定供应给那么几个人，
但是在实际情况那会是一成不变的供应给这几个人，做生意不嫌多，买的也会货比三家，这么一来就出现了，一个
店铺面对这购买者流动的问题。上面这么做事肯定行不通，那要怎么做，这时候就是《观察者模式》登场的时候了。
下面给出一个简单的《观察者模式》实例，如下：
首先定义两个接口一个是 ShopInter 和 PurchaseObserver
public interface ShopInter {
//注册监听者
public void registerPurchaseObserver(PurchaseObserver observer);
//注销监听者
public void unregisterPurchaseObserver(PurchaseObserver observer);
//通知监听者
public void ontifyPurchaseObserver();

}

public interface PurchaseObserver {
public void readBook(String book);
}

然后BookShop实现ShopInter，代码如下：

public class BookShop implements ShopInter {

private List<PurchaseObserver> poList;

private Random random = new Random();

private String book = "";

public BookShop() {
poList = new ArrayList<PurchaseObserver>();
}

@Override
public void registerPurchaseObserver(PurchaseObserver observer) {
if (observer != null)
poList.add(observer);
}

@Override
public void unregisterPurchaseObserver(PurchaseObserver observer) {
int i = poList.indexOf(observer);
if (i > 0)
poList.remove(observer);
}

@Override
public void ontifyPurchaseObserver() {
int i = random.nextInt(2);
if (i == 1) {
for (PurchaseObserver observer : poList) {
observer.readBook(book);
}
}
}

public void stockNewBook(String book){
this.book = book;
ontifyPurchaseObserver();
}

}

购物者实现PurchaseObserver，代码如下：

public class PurchaserOne implements PurchaseObserver{

private ShopInter mShopInter;

public PurchaserOne(ShopInter si) {
mShopInter = si;
mShopInter.registerPurchaseObserver(this);
}

@Override
public void readBook(String book) {
System.out.println(book);
}

}

然后在主控制类里面，完成：注册监听者——入货通知监听者——注销监听者，这个步骤，如下：

public class MainControl {
public static void main(String[] arg0){
BookShop shop = new BookShop();

PurchaseObserver objserver = new PurchaserOne(shop);

shop.stockNewBook("读者");

shop.unregisterPurchaseObserver(objserver);

shop.stockNewBook("格林");
}
}

这么一来同样的实现了，当有新版的时候通知读者。同时还增加类程序的灵活性，降低里程序的耦合性。之前虽然可以

实现同样的功能但是不灵获，现在不管有多少的读者想要来订阅，只要注册监听事件就可以了，而且当我不想在订阅的

时候，还可以通过注销监听事件的方式来达到这种效果。

那么下面就做一下观察者模式的总结：

.观察者模式的定义：

观察者定义了一系列对象之间的一对多的关系，当一个对象发生改变时，它所有的依赖者都会 收到通知并主动更新。

设计的原则：

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

下面是本次例子的类图：



最后讲一下Java sdk中的监听者模式：Observable（可观察者）和Observer（观察者）：使用方式如下：

public class MyObservable extends Observable {

private String book = "";

public void stockBook(String book){
this.book = book;
this.setChanged();
this.notifyObservers();
}

public String getBook(){
return book;
}

public void stockBook(){
this.setChanged();
this.notifyObservers("格林");
}

}

public class MyObserver implements Observer {

private Observable ob;

public MyObserver(Observable ob){
this.ob = ob;
ob.addObserver(this);
}

@Override
public void update(Observable o, Object arg) {
if(arg != null){
System.out.println(arg.toString());
} else{
MyObservable mo = (MyObservable) o;
System.out.println(mo.getBook());
}

}

}

要记得一点就是在调用notifyObservers()之前要先调用setChanged()
其中Observer是一个接口结构也很简单只有一个 update(...)方法。

Observable是一个具体的类，所以在需要继承其他基类的情况下就要考虑清楚，毕竟Java不支持多继承，一下是它的方法：

public synchronized void addObserver(Observer o)

public synchronized void deleteObserver(Observer o)

public void notifyObservers()

public void notifyObservers(Object arg)

public synchronized void deleteObservers()

protected synchronized void setChanged()

protected synchronized void clearChanged()

public synchronized boolean hasChanged()

public synchronized int countObservers()

其实Java中的观察这模式还有很多，比如点击事件就是观察者模式。其他就不一一罗列。

本次关于观察者模式的总结就到这里，希望其他看了这片文章的人可以多给一点意见，大家一起学习。