设计模式-观察者模式与事件委托

一. 观察者模式

1.定义观察者

/** * 观察者接口 * @author ck */ abstract class Observer{ /** 观察者名称 */ private String name; /** 构造函数，初始化观察者名称 */ public Observer(String name) { this.name = name; } public String getName() { return name; } /** * 观察者更新状态 * @param subject 通知者 * @param event 事件信息 */ public abstract void update(Subject subject, Object event); } /** * 具体观察者：打游戏的观察者 * @author ck */ class GamingObserver extends Observer{ /** 构造函数，初始化打游戏的观察者 */ public GamingObserver(String name) { super(name); } /** 更新状态 */ @Override public void update(Subject subject, Object event) { System.out.println(subject.getName()+":"+this.getName()+","+event+"别玩游戏了"); } } /** * 具体的观察者：睡觉的观察者 * @author ck */ class SleepObserver extends Observer{ /** 构造函数，初始化睡觉的观察者名称 */ public SleepObserver(String name) { super(name); } /** 更新状态 */ @Override public void update(Subject subject, Object event) { System.out.println(subject.getName()+":"+this.getName()+","+event+",别睡觉了"); } }

2.定义通知者

/** * 通知者接口 * @author ck */ abstract class Subject{ /** 通知者名称 */ private String name; /** 构造函数，初始化通知者名称 */ public Subject(String name) { this.name = name; } /** * 添加观察者 * @param observer 观察者 */ public abstract void addObserver(Observer observer); /** * 移除观察者 * @param observer 观察者 */ public abstract void removeObserver(Observer observer); /** * 通知所有观察者 * @param event 事件信息 */ public abstract void notifyAll(Object event); /** * 通知某一个观察者 * @param event 事件信息 * @param observer 观察者 */ public abstract void notify(Object event, Observer observer); public String getName() { return name; } public void setName(String name) { this.name = name; } } /** * 具体通知者 * @author ck */ class ConcreteSubject extends Subject{ /** 构造函数，初始化通知者名称 */ public ConcreteSubject(String name) { super(name); } /** 观察者列表 */ private List<Observer> observerList = new ArrayList<Observer>(); /** 添加观察者 */ @Override public void addObserver(Observer observer) { if(observer==null) new NullPointerException("添加的观察者不能为空！"); if(!observerList.contains(observer)) observerList.add(observer); } /** 移除观察者 */ @Override public void removeObserver(Observer observer) { observerList.remove(observer); } /** 通知所有观察者 */ @Override public void notifyAll(Object event) { for (Observer observer : observerList) { observer.update(this, event); } } /** 通知某一个观察者 */ @Override public void notify(Object event, Observer observer) { if(observer!=null) observer.update(this, event); } }

3.运行测试

/** * 观察者模式 * @author ck */ public class AbserverPattern { public static void main(String[] args) { //通知者 ConcreteSubject concreteSubject = new ConcreteSubject("前台mm"); //添加观察者 concreteSubject.addObserver(new GamingObserver("小明")); concreteSubject.addObserver(new SleepObserver("大鹏")); concreteSubject.notifyAll("老板来了"); } }

4.运行结果

前台mm:小明,老板来了别玩游戏了 前台mm:大鹏,老板来了,别睡觉了

二. 事件委托 1.定义通知者

/** * 通知者 * @author ck */ abstract class Notifier { /** 事件处理器 */ private EventHandler eventHandler = new EventHandler(); public EventHandler getEventHandler() { return eventHandler; } /** * 添加事件监听 * @param object 执行的对象 * @param methodName 执行方法的方法名 * @param args 执行方法的参数 */ public abstract void addListener(Object object, String methodName, Object... args); /** * 通知所有观察者 */ public abstract void notifyX(); /** * 通知某一个观察者 * @param object */ public abstract void notifySomeone(Object object); } /** * 具体的通知者 * @author ck */ class GoodNotifier extends Notifier{ @Override public void addListener(Object object, String methodName, Object... args) { EventHandler eventHandler = this.getEventHandler(); eventHandler.addEvent(object, methodName, args); } @Override public void notifyX() { this.getEventHandler().notifyX(); } @Override public void notifySomeone(Object object) { this.getEventHandler().notifySomeone(object); } }

2.事件处理器

/** * 事件处理器 * @author ck */ class EventHandler{ /** 事件列表 */ private List<Event> events; /** 构造函数，初始化事件处理器 */ public EventHandler() { events = new ArrayList<Event>(); } /** * 添加事件 * @param object 观察者 * @param methodName 观察者的更新方法 * @param args 观察者更新方法的参数 */ public void addEvent(Object object, String methodName, Object... args){ events.add(new Event(object, methodName, args)); } /** * 通知所有观察者 */ public void notifyX(){ for (Event event : events) { event.invoke(); } } /** * 通知某一观察者 * @param object */ public void notifySomeone(Object object){ for (Event event : events) { Object obj = event.getObject(); if(obj.equals(object)){ event.invoke(); } } } } /** * 事件 * @author ck */ class Event{ /** 观察者 */ private Object object; /** 观察者的更新方法 */ private String methodName; /** 观察者更新方法的参数 */ private Object[] params; /** 观察者更新方法的参数类型 */ private Class[] paramTypes; public Event(){ } /** 构造函数 */ public Event(Object object,String methodName,Object...args){ this.object=object; this.methodName=methodName; this.params=args; contractParamTypes(this.params); } /** 根据参数数组生成参数类型数组 */ private void contractParamTypes(Object[] params){ if(params!=null && params.length>0){ 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) method.invoke(object, params); } catch (Exception e) { e.printStackTrace(); } } /** 获取观察者 */ public Object getObject() { return object; } }

3.定义观察者

/** * 打游戏的观察者 * @author ck */ class GamingListener{ public void stopGaming(){ System.out.println("关闭游戏，开始工作"); } } /** * 睡觉的观察者 * @author ck */ class SleepListener{ public void wakeup(){ System.out.println("醒过来，上个厕所，继续工作"); } }

4.运行测试

/** * 事件委托 * @author ck */ public class EventNotifier { public static void main(String[] args) { //创建通知者 GoodNotifier goodNotifier = new GoodNotifier(); //创建观察者 GamingListener gamingListener = new GamingListener(); SleepListener sleepListener = new SleepListener(); //指定观察者更新方法 goodNotifier.addListener(gamingListener, "stopGaming"); goodNotifier.addListener(sleepListener, "wakeup"); //通知 goodNotifier.notifySomeone(gamingListener); goodNotifier.notifySomeone(sleepListener); // goodNotifier.notifyX(); } }

5.运行结果

关闭游戏，开始工作 醒过来，上个厕所，继续工作

三.总结 未完待续…