本文概览：介绍观察者模式与事件监听模式。
1 观察者模式
1.1 模式介绍
1、 定义
观察者模式定义了对象之间的一对多依赖，即，一个主题对应多个观察者。当一个主题对象改变状态时，它的所有依赖者（观察者）都会收到通知并自动更新。可以通过 “公众号发送消息”实例来理解：公众号会保存所有订阅者，有消息之后，会发送给所有订阅者。
2、观察模式和策略模式比较
观察者模式解决的是对象和对象之间的依赖关系。它解决的是多个对象依赖一个对象的关系：一个主题对象状态改变，需要通知所有观察者对象。而在策略模式中，解决的是一个对象内部的不断变化的方法。
1.2 实现
主要包含 主题和 观察者两种对象。
1、主题
在主题类中定义了一个观察者数组，，这样就实现了主题和观察者之间1对多的关系。
|
1
2
3
4
5
6
7
|
public interface Subject {
// 注册
void registerObserver(Observer observer);
// 发送通知
void sendMsg(String msg);
}
|
具体类
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public class ConSubject implements Subject {
// 观察者集合
private List<Observer> observerList = Lists.newArrayList();
public void registerObserver(Observer observer) {
observerList.add(observer);
}
// 发送通知
public void sendMsg(String msg) {
for (Observer observer : observerList) {
observer.recvMessage(msg);
}
}
}
|
2、观察者
|
1
2
3
4
|
public interface Observer {
// 接受主题的消息
void recvMessage(String msg);
}
|
一个具体观察者
|
1
2
3
4
5
6
7
8
9
10
11
12
|
public class AObserver implements Observer {
private Subject subject;
AObserver(Subject subject) {
this.subject = subject;
subject.registerObserver(this);
}
public void recvMessage(String msg) {
System.out.println(“A 接受主题消息:” + msg);
}
}
|
3、测试
|
1
2
3
4
5
6
7
8
9
10
|
public class Test {
public static void main(String[] args) {
ConSubject subject = new ConSubject();
AObserver observer = new AObserver(subject);
// 发送消息
System.out.println(“主题发送消息:–“);
subject.sendMsg(“Message Content”);
}
}
|
执行结果为
|
1
2
|
主题发送消息:—
A 接受主题消息:Message Content
|
2 事件监听模式
跟主题模式类似，事件监听模式包括一个EventLister（看成是观察者），ListenerSupport（监听器管理器，类似于主题），还有一个Event 表示事件，可以理解为 主题观察者 中消息 message。
1、Event
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
public class Event {
private String data;
private String type;
Event(String data,String type){
this.data = data;
this.type = type;
}
public String getData() {
return data;
}
public void setData(String data) {
this.data = data;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
}
|
2、监听器
|
1
2
3
|
public interface EventListener {
public void processEvent(Event event);
}
|
具体监听器
|
1
2
3
4
5
6
|
public class EventListenerA implements EventListener {
public void processEvent(Event event) {
System.out.println(“type:” + event.getType());
System.out.println(“data:” + event.getData());
}
}
|
3、事件管理器
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public class ListenerSupport {
private List<EventListener> listenerList = Lists.newArrayList();
public void registry(EventListener listener) {
listenerList.add(listener);
}
public void triggerEvent(Event event) {
for (EventListener listener : listenerList) {
listener.processEvent(event);
}
}
}
|
4、测试
|
1
2
3
4
5
6
7
8
9
10
|
public class Test {
public static void main(String[] args){
EventListenerA a =new EventListenerA();
ListenerSupport listenerSupport = new ListenerSupport();
listenerSupport.registry(a);
// 触发事件
listenerSupport.triggerEvent(new Event(“Adata”,“Atype”));
}
}
|
结果为
|
1
2
|
type:Atype
data:Adata
|
参考：
转载请注明：SuperIT » 观察者模式与事件监听模式的具体实现
