一、定义：
观察者模式（Observer）又叫做发布-订阅模式（Publish/Subscribe）,定义了一种一对多的依赖模式，让多个观察者对象同时监听某一个主题对象，这个主题对象在状态发生变化时，会通知所有观察者对象，使他们能够自动更新自己。
二、示例代码:
package com.pattern.observer;
import java.util.LinkedHashSet;
/*通知类*/
public class Notified {
/*用linkedHashSet防止有重复的订阅者*/
LinkedHashSet<SubscrSuper> list = new LinkedHashSet();
String message;
public void addSubscription(SubscrSuper subscriber) {
list.add(subscriber);
}
public void removeSubscription(SubscrSuper subscriber) {
list.remove(subscriber);
}
public void setMessage(String s) {
this.message = s;
}
public void notif() {
for (SubscrSuper subscriber : list
) {
subscriber.update();
}
}
}
package com.pattern.observer;
/*抽象观察类*/
public abstract class SubscrSuper {
protected String name;
protected Notified notified;
public SubscrSuper(String name,Notified notified) {
this.name = name;
this.notified=notified;
}
abstract void update();
}
package com.pattern.observer;
public class Subscriber extends SubscrSuper {
public Subscriber(String name, Notified notified) {
super(name,notified);
}
@Override
void update() {
System.out.println(notified.message+" "+name+" turn down");
}
}
package com.pattern.observer;
public class Subscrier2 extends SubscrSuper{
public Subscrier2(String name,Notified notified) {
super(name,notified);
}
@Override
public void update() {
System.out.println( notified.message+" "+name+" play basketball");
}
}
package com.pattern.observer;
public class Client {
public static void main(String[] args) {
/*通知类*/
Notified notified = new Notified();
/*订阅类*/
SubscrSuper subscriber =new Subscriber("Stoner",notified);
SubscrSuper subscriber2 = new Subscrier2("Vienna",notified);
/* 设置通知消息*/
notified.setMessage("notify boos come ");
/*给通知类添加订阅者*/
notified.addSubscription(subscriber);
notified.addSubscription(subscriber2);
/* 发出通知*/
notified.notif();
}
}
三、利用委托类实现
上述例子的问题在于。通知类依赖于抽象观察类，但是当观察类所用的方法不一样，提取不出一个通用抽象的观察类。
package com.pattern.observer;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/*事件类*/
public class Event {
/*调用的对象*/
private Object object;
/*方法名*/
private String methodName;
/*方法的参数*/
private Object[] params;
/*方法的参数类型*/
private Class[] paramTypes;
public Event(Object object, String methodName, Object... objects ) {
this.object = object;
this.methodName = methodName;
this.params = objects ;
initParamTypes(this.params);
}
/*初始化参数类型*/
private void initParamTypes(Object[] params) {
if (params==null){
return;
}
this.paramTypes = new Class[params.length];
for (int i = 0; i < params.length; i++) {
this.paramTypes[i] = params[i].getClass();
}
}
/*利用反射调用对象*/
public void invoke() {
try {
Method method = object.getClass().getMethod(methodName, paramTypes);
if (method == null) {
return;
}
else {
method.invoke(object, params);
}
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
package com.pattern.observer;
import java.util.ArrayList;
import java.util.List;
/*事件管理类*/
public class EventHandler {
/*事件列表*/
public List<Event> objects;
public EventHandler() {
this.objects = new ArrayList<Event>();
}
/*添加事件*/
public void addEvent(Object object, String methodName, Object... args) {
objects.add(new Event(object, methodName, args));
}
/*通知*/
public void notifyx(){
for (Event event:objects){
event.invoke();
}
}
}
package com.pattern.observer;
/*抽象通知者*/
public abstract class Notifier {
private EventHandler eventHandler = new EventHandler();
public EventHandler getEventHandler() {
return eventHandler;
}
/*增加观察者*/
public void addListener(Object object, String methodName, Object... args){
eventHandler.addEvent(object, methodName, args);
}
/*发出通知*/
public abstract void notifyx();
}
package com.pattern.observer;
/*具体通知者*/
public class ConcreteNotifier extends Notifier {
@Override
public void notifyx() {
System.out.println("开始发出通知");
this.getEventHandler().notifyx();
}
}
package com.pattern.observer;
/*具体的观察类*/
import java.util.Date;
public class PlayingListener {
public void PlayingListener() {
System.out.println("playing games");
}
public void shutDownGames(Date date) {
System.out.println("shut down games" + date);
}
}
package com.pattern.observer;
/*具体的观察类*/
import java.util.Date;
public class WatchingListener {
public void WatchingListener() {
System.out.println("watching tv");
}
public void stopWatchingTV(Date date) {
System.out.println("stopWatching tv"+date);
}
}
package com.pattern.observer;
import java.util.Date;
public class Client {
public static void main(String[] args) {
/*通知类*/
Notifier notifier = new ConcreteNotifier();
WatchingListener watchingListener = new WatchingListener();
PlayingListener playingListener = new PlayingListener();
notifier.addListener(watchingListener,"stopWatchingTV",new Date());
notifier.addListener(playingListener,"shutDownGames",new Date());
notifier.notifyx();
}
}