观察者模式

实例场景：

1、爱美之心人皆有之，一个美女在街上走，引起人们所关注，在这个场景中，美女是被观察者，而观察她的人属于观察者，当美女发现有很多观察她的人，然后大声叫了一句：今天真开心，这就会通知观察她的人，人们听到后就感觉到美女被自己关注感到很开心。

2、在java基础的awt或者swing中，常常有按钮点击事件，当我们给按钮注册一个事件监听器，注册的监听器类实现一个Listener接口，我们没有调用Listener中的方法，那么为什么方法会得到调用呢？难道是自己得到调用？在这个里面就使用了我们的设计模式：观察者模式

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，这个主题对象在状态上发生改变的时候，会通知所有的观察者对象，让他们能够自动去更新自己，就像场景1

观察者模式的组成：

抽象主题角色：把所有对观察者对象的引用保存在一个集合中，每个抽象主题角色都可以有任意数量的观察者。抽象主题提供一个接口，可以增加和删除观察者角色。一般用一个抽象类或接口来实现。

抽象观察者角色：为所有具体的观察者定义一个接口，在得到主题的通知时更新自己。

具体主题角色：在具体主题内部状态改变时，给所有登记过的观察者发出通知。具体主题角色通常用一个子类实现。

具体观察者角色：该角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。如果需要，具体观察者角色可以保存一个指向具体主题角色的引用。通常用一个子类实现。

代码实现模拟：

定义一个抽象的主题角色：

package cn.com.observer;
//定义一个抽象的主题，该主题是一个被观察者
public interface Watched {
//增加一个观察者
public void addWatcher(Watcher w);
//移除一个观察者
public void removeWatcher(Watcher w);
//发出一个通知给观察者
public void notifyWatcher(String str);
}

定义一个抽象的观察者角色：

package cn.com.observer;
//定义一个抽象的观察者
public interface Watcher {
//观察者得到通知后更新
public void update(String str);
}

定义一个具体的主题角色：

//具体的被观察者，相当与一个美女
public class ConcreteWatched implements Watched {
//每个主题可以有很多观察者，就像关注一个美女可以有很多人
List<Watcher> list=new ArrayList<Watcher>();

@Override
public void addWatcher(Watcher w) {
list.add(w);
}

@Override
public void removeWatcher(Watcher w) {
list.remove(w);

}

//当主题发出通知的时候，任何观察者都可以收到通知
@Override
public void notifyWatcher(String str) {
for(Watcher watcher:list){
watcher.update(str);
}
}
}

定义一个具体的观察者角色：

package cn.com.observer;

//定义一个具体的观察者，当得到主题通知的时候，自己更新
public class ConcreteWatcher implements Watcher {

@Override
public void update(String str) {
System.out.println(str);
}
}

测试类：

//测试类
public class Test {
public static void main(String[] args) {
//定义一个美女，主题、被观察者
Watched girl=new ConcreteWatched();
//定义多个观察者
Watcher boy1=new ConcreteWatcher();
Watcher boy2=new ConcreteWatcher();
Watcher boy3=new ConcreteWatcher();

//观察者关注美女
girl.addWatcher(boy1);
girl.addWatcher(boy2);
girl.addWatcher(boy3);
//美女看到有这么多人观察她，大叫一声：今天真高兴
girl.notifyWatcher("今天真高兴");
//有一个观察者走了
girl.removeWatcher(boy2);
//通知剩下的观察者
girl.notifyWatcher("唉，少了一个");

}

}

结果会输出：今天真高兴

今天真高兴

今天真高兴

唉，少了一个

唉，少了一个

到了这里，大家应该知道了吧，实际上具体观察者不是自己调用自己了，二是被主题所封装调用了，类比我们awt或者swing等那些Listener，一个按钮Button相当与一个主题，也就是我们这里的美女，而我们自定义的实现那些Listener接口的Listener就是观察者，当按钮被点击的时候，按钮会发出通知给相应的Listener，在Button类部执行定义的Listener的方法，所以这里的那些方法是在我们的按钮Button里面被调用了，而不是Listener自己调用。这就是一种观察者模式。

下面我们来模仿awt中的Button，写出我们自己的Button以及事件处理：

定义一个抽象的观察者角色:

/**
* 定义一个抽象的观察者，由客户端实现其actionPerformed方法
* 做自己的业务逻辑处理
* @author dell
*
*/
public interface ActionListener {
public void actionPerformed(ActionEvent e);
}

定义一个抽象主题角色 :

/**
* 定义一个抽象主题角色
* @author dell
*
*/
public interface IButton {
//添加观察者、监听器
public void addActionListener(ActionListener actionLister);
//删除观察者、监听器
public void removeActionListener(ActionListener actionLister);
//执行的方法，相当于我们的单击Button事件，其中的这个方法由系统调用
public void processActionEvent(ActionEvent e);
}

定义一个具体的主题，就是我们的Button：

/**
* 定义一个具体的主题、事件源，用户观察者对象集合
* @author dell
*
*/
public class Button implements IButton{
List<ActionListener> listeners=new ArrayList<ActionListener>();
@Override
public void addActionListener(ActionListener actionLister) {
listeners.add(actionLister);
}

@Override
public void removeActionListener(ActionListener actionLister) {
listeners.remove(actionLister);
}

//主题发出通知给各个观察者后，观察者做出自己的响应
@Override
public void processActionEvent(ActionEvent e) {
for(ActionListener listener:listeners){
listener.actionPerformed(e);
}
}
}

客户端进行测试:

public class Client {
public static void main(String[] args) {
//定义一个主题、事件源
IButton button=new Button();
ActionEvent e=new ActionEvent();
//给主题添加观察者，让观察者自己去处理主题发出通知后的事情
button.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println("点击按钮，用户登录...");
}
});
button.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println("点击按钮，用户注册...");
}
});
//点击按钮,主题发出通知给观察者,在awt或者swing中由用户用鼠标进行点击,由系统调用该方法
button.processActionEvent(e);
}
}

如上所示，如果我们系统的主题变了，不是button了，而是TextField了，我们也有processActionEvent事件，那么我们的系统就很容易进行拓展了，而不需要修改很多的源代码，类与类之间的耦合度降低了，符合我们面向对象的开闭原则和依赖倒转原则，下面为了不混淆概念，我们把抽象主题的类改个名称为：IComponent

/**
* 定义一个抽象主题角色
* @author dell
*
*/
public interface IComponent {
//添加观察者、监听器
public void addActionListener(ActionListener actionLister);
//删除观察者、监听器
public void removeActionListener(ActionListener actionLister);
//执行的方法，相当于我们的单击Button事件，其中的这个方法由系统调用
public void processActionEvent(ActionEvent e);
}

然后我们的TextField也有像Button一样的监听者，我们只需要继承IComponent即可：

/**
* 定义一个具体的主题、事件源，用户观察者对象集合
* @author dell
*
*/
public class TextField implements IComponent{
List<ActionListener> listeners=new ArrayList<ActionListener>();
@Override
public void addActionListener(ActionListener actionLister) {
listeners.add(actionLister);
}

@Override
public void removeActionListener(ActionListener actionLister) {
listeners.remove(actionLister);
}

//主题发出通知给各个观察者后，观察者做出自己的响应
@Override
public void processActionEvent(ActionEvent e) {
for(ActionListener listener:listeners){
listener.actionPerformed(e);
}
}
}

测试：

//修改事件源为TextField
IComponent textField=new TextField();
textField.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println("点击文本框，用户输入姓名...");
}
});
textField.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println("点击文本框，用户输入密码...");
}
});
//点击文本框
textField.processActionEvent(e);

是不是觉得设计模式很是强大呢，呵呵....大家尝试一下吧!!