研究了一下java Event机制 和observer设计模式,发现两者都者不多,一样的原因
java Event机制不过是observer设计模式的一个特例。
一 、observer设计模式
Data类:
package event;
public class MyData {
public MyData(String name, int age) {
this.username = name;
this.age = age;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
private String username;
private int age;
}
EventSource:
package event;
public class MyListener {
public void onMyEvent(MyEvent event) {
System.out.println(" event data . name is : "+ event.getSource().getUsername());
}
}
Event:
package event;
public class MyEvent{
private MyData source;
public MyEvent(MyData source) {
this.setSource(source);
}
public MyData getSource() {
return source;
}
public void setSource(MyData source) {
this.source = source;
}
/**
*
*/
private static final long serialVersionUID = 1L;
}
Listener:
package event;
public class MyListener {
public void onMyEvent(MyEvent event) {
System.out.println(" event data . name is : "+ event.getSource().getUsername());
}
}
Test类:
package event;
public class TestEvent {
/**
* @param args
*/
public static void main(String[] args) {
EventSource es = new EventSource();
MyData customData = new MyData("Robert",27);
MyEvent eo = new MyEvent(customData);
MyListener cl = new MyListener();
es.addEventListener(cl);
es.changeSource(eo);
}
}
总结:
对于observer设计模式,我们大致要建立4个类:
MyData类用来存放数据
MyEvent类用来表示事件
EventSource类用来表示事件源
MyListener类用来表示事件监听器
EventSource相对复杂一点,其他类都是很简单的。当然,我们也可以把逻辑处理搬到其他地方去,不过那样的花,这个恐怕就不是observer设计模式了吧!
理解之后发现原理十分简单,只是一个小小track而已!
二 、java提供的Event机制
如果是java的事件机制,原理也差不多,但是,jdk就已经提供了一些类了:
EventObject 事件对象,包含事件对应的数据,需要自定义类继承拓展它
EventListener事件监听器,需要自定义类继承拓展它
—— 不,这只是sun的建议,其实我们完全可以不考虑EventObject、EventListener。EventListener只是一个标记接口。EventObject 也只是维护了一个source的变量,提供 getSource方法。几乎没什么用
Observer
Observeable
—— 这两个类才是重要的 Observeable提供一系列很用的方法、Observer也有一个重要的update方法
(当然,其他类还是需要自己编写)
——所以不用这么多的自定义类了——虽然方便,但是可能不是那么灵活...
参考了几篇blog,发现:
http://smurfs.iteye.com/blog/1171962写的啰嗦,甚至可以说是一种错误的写法;
http://rokily.iteye.com/blog/775395也稍显复杂。
我自己写了个简单实现:
1
package com.test.observer;
/**
* 可以看做业务po,业务逻辑的处理应该在此类中完成
* 需要继承Observable是因为我们用到了java提供的功能
*/
public class EventObserveable extends java.util.Observable{
public void action(Object arg) {
super.setChanged();// setChanged 是protected方法,必须由本来来调用。。。
super.notifyObservers(arg);
}
public void logicHandler(String name) {
// ... logic handle here , like :
System.out.println("Object arg is :" + name);
}
}
2
package com.test.observer;
import java.util.Observable;
import java.util.Observer;
/**
* 观察者, 此update方法自动由Observer类调用,
*
* 而 update方法主要是调用 业务方法, 当然,我们也可以在这个方法中直接的业务逻辑处理, 而不用调来调去
*
* 需要继承Observer是因为 它是和Observable配套使用的
*/
public class EventObserver implements Observer {
@Override
public void update(Observable o, Object arg) {
((EventObserveable)o).logicHandler(arg.toString());
//System.out.println("Object arg is :" + arg);
}
}
3
package com.test.observer;
import java.util.Observer;
/**
* 此类可以 看做 事件源, 因为notifyEvent 就是发送事件的源头 EXACTLY! 专供外部调用, 同时 notifyEvent 也是事件处理回调函数
* 此类中,我们需要保持一个Observeable的对象,它来代替我们一部分工作
* 当然,首先要 完成 监听器的 添加、移除 等监听器相关操作
* ———— 当然,我们可以有其他方式添加监听器(参:http://rokily.iteye.com/blog/775395),但是把addEventListener放在这个累里面感觉比较直接
* 此类只是简单实现,实际中我们需要完善其功能,可以写的很复杂 !
*/
public class EventSource {
private EventObserveable ob = new EventObserveable();
public void addEventListener(Observer listener) {
ob.addObserver(listener);
}
public void removeEventListener(Observer listener) {
ob.deleteObserver(listener);
}
public void notifyEvent(Object arg) {
ob.action(arg);
}
}
测试类:
package com.test.observer;
public class Test {
/**
* @param args
*/
public static void main(String[] args) {
EventSource ds = new EventSource();
ds.addEventListener(new EventObserver());
ds.notifyEvent("Hello LuK ! ");
}
}
总共4个类,个个简单。
总结: 看再多的设计模式的书或blog或面试宝典都没用,如果自己不去code不去花时间领会的话;当然如果自己没基础,code了后可能还是不明白。。