定义:观察者模式定义了对象之间一对多的依赖,让多个观察者对象同时监听
,一个主体对象,当主体对象发生变化时,它的所有依赖者(观察者)都会受到通知并更新,属于行为型模式。
观察者模式有时也叫做发布订阅模式。观察者模式主要用于在关联行为之间建立一套触发机制的场景。
懒人源码:
扫描下面二维码关注公众号: 程序员修炼宝典 ,回复:观察者模式 获取源码
java源码模拟朋友圈动态通知:
public class GPer extends Observable {
private String name = "新野酒会";
private static GPer gPer = null;
private GPer() {}
public String getName() {
return name;
}
public static GPer getInstance() {
if (gPer == null) {
gPer = new GPer();
}
return gPer;
}
public void publishQuestion(Question question) {
System.out.println(question.getUserName() + "在" + this.name + "上提交了一个问题。");
setChanged();
notifyObservers(question);
}
}
public class Question {
private String userName;
private String content;
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
}
public class Teacher implements Observer {
private String name;
public Teacher(String name) {
this.name = name;
}
public void update(Observable o, Object arg) {
GPer gPer = (GPer) o;
Question question = (Question) arg;
System.out.println("==========================");
System.out.println(name + "老师,您好!\n" +
"您收到了一份来自“" + gPer.getName() + "”的提问,希望您解答,问题内容如下:\n"
+ question.getContent() + "\n" +
"提问者:" + question.getUserName());
}
}
public class MainTest {
public static void main(String[] args) {
GPer gPer = GPer.getInstance();
Teacher lone = new Teacher("卧龙");
Teacher bird = new Teacher("凤雏");
gPer.addObserver(lone);
gPer.addObserver(bird);
//业务逻辑代码
Question question = new Question();
question.setContent("卧龙凤雏得一可得天下?");
question.setUserName("刘备");
gPer.publishQuestion(question);
}
}
2.使用观察者模式设置一套鼠标事件监听器
/**
* 监听器的一种包装,标准事件源格式的定义
*
* 事件源管理
* @Author:
* @Date: 2020/12/15 16:06
*/
public class Event {
//事件源 事件是由谁发起的, 保存起来
private Object source;
//事件触发 要通知谁
private Object target;
// 事件触发 要做什么动作,回调
private Method callback;
// 事件的名称 触发的是什么事件
private String trigger;
// 事件触发的时间
private long time;
public Event(Object target, Method callback) {
this.target = target;
this.callback = callback;
}
public Object getSource() {
return source;
}
public Event setSource(Object source) {
this.source = source;
return this;
}
public Object getTarget() {
return target;
}
public Event setTarget(Object target) {
this.target = target;
return this;
}
public Method getCallback() {
return callback;
}
/* public Event setCallback(Method callback) {
this.callback = callback;
return this;
}*/
public String getTrigger() {
return trigger;
}
public Event setTrigger(String trigger) {
this.trigger = trigger;
return this;
}
public long getTime() {
return time;
}
public void setTime(long time) {
this.time = time;
}
@Override public String toString() {
return "Event{" + "source=" + source + ", target=" + target
+ ", callback=" + callback + ", trigger='" + trigger + '\''
+ ", time=" + time + '}';
}
}
监听器
public class EventLisenter {
//jdk底层的lisenter通常也是这种设计
protected Map<String, Event> events = new HashMap<>();
//通过事件名称和一个目标对象来触发事件
public void addLisenter(String eventType, Object target) {
try {
String upperEventType = "on" + toUpperFirstCase(eventType);
this.addLisenter(eventType, target, target.getClass().getMethod(upperEventType, Event.class));
}
catch (Exception e) {
e.printStackTrace();
}
}
private void addLisenter(String eventType, Object target, Method callBack) {
//注册事件
events.put(eventType, new Event(target, callBack));
}
/**
* 触发,只要有动作就触发
* @param
* @return
*/
private void trigger(Event event) {
event.setSource(this);
event.setTime(System.currentTimeMillis());
try {
//发起回调
if (event.getCallback() != null) {
//用反射调用它的回调函数
event.getCallback().invoke(event.getTarget(), event);
//也可以优化为策略模式组合,设置为不同的事件监听内执行各种回调函数
}
}
catch (IllegalAccessException e) {
e.printStackTrace();
}
catch (InvocationTargetException e) {
e.printStackTrace();
}
}
protected void trigger(String trigger) {
if (!this.events.containsKey(trigger)) {
System.out.println("事件" + trigger + "未注册");
return;
}
trigger(this.events.get(trigger).setTrigger(trigger));
}
private String toUpperFirstCase(String eventType) {
char[] chars = eventType.toCharArray();
chars[0] -= 32;
return String.valueOf(chars);
}
}
事件管理:
/**
* 事件
* @Author: Zhangdongdong
* @Date: 2020/12/15 16:32
*/
public class Mouse extends EventLisenter {
public void click() {
System.out.println("调用单击方法");
this.trigger(MouseEventType.ON_CLICK);
}
public void doubleClick() {
System.out.println("调用双击方法");
this.trigger(MouseEventType.ON_DOUBLE_CLICK);
}
public void up() {
System.out.println("调用弹起方法");
this.trigger(MouseEventType.ON_UP);
}
public void down() {
System.out.println("调用按下方法");
this.trigger(MouseEventType.ON_DOWN);
}
public void move() {
System.out.println("调用移动方法");
this.trigger(MouseEventType.ON_MOVE);
}
public void wheel() {
System.out.println("调用滚动方法");
this.trigger(MouseEventType.ON_WHEEL);
}
public void over() {
System.out.println("调用悬停方法");
this.trigger(MouseEventType.ON_OVER);
}
public void blur() {
System.out.println("调用失焦方法");
this.trigger(MouseEventType.ON_BLUR);
}
public void focus() {
System.out.println("调用获焦方法");
this.trigger(MouseEventType.ON_FOCUS);
}
}
回调函数:
/**
* 监听后执行事件
* @Author: Zhangdongdong
* @Date: 2020/12/15 16:37
*/
public class MouseEventCallback {
public void onClick(Event e) {
System.out.println("=============== 触发鼠标单击事件 ===============" + "\n" + e);
}
public void onDoubleClick(Event e) {
System.out.println("=============== 触发鼠标双击事件 ===============" + "\n" + e);
}
public void onUp(Event e) {
System.out.println("=============== 触发鼠标弹起事件 ===============" + "\n" + e);
}
public void onDown(Event e) {
System.out.println("=============== 触发鼠标按下事件 ===============" + "\n" + e);
}
public void onMove(Event e) {
System.out.println("=============== 触发鼠标移动事件 ===============" + "\n" + e);
}
public void onWheel(Event e) {
System.out.println("=============== 触发鼠标滚动事件 ===============" + "\n" + e);
}
public void onOver(Event e) {
System.out.println("=============== 触发鼠标悬停事件 ===============" + "\n" + e);
}
public void onBlur(Event e) {
System.out.println("=============== 触发鼠标失焦事件 ===============" + "\n" + e);
}
public void onFocus(Event e) {
System.out.println("=============== 触发鼠标获焦事件 ===============" + "\n" + e);
}
}
事件类型统一定义:
/**
* 事件类型定义
* @Author: Zhangdongdong
* @Date: 2020/12/15 16:27
*/
public interface MouseEventType {
//单击
String ON_CLICK = "click";
//双击
String ON_DOUBLE_CLICK = "doubleClick";
//弹起
String ON_UP = "up";
//按下
String ON_DOWN = "down";
// 移动
String ON_MOVE = "move";
// 滚动
String ON_WHEEL = "wheel";
// 悬停
String ON_OVER = "over";
// 失焦
String ON_BLUR = "blur";
// 获焦
String ON_FOCUS = "focus";
}
测试:
public class EventMainTest {
public static void main(String[] args) {
MouseEventCallback callback = new MouseEventCallback();
try {
//注册事件
Mouse mouse = new Mouse();
mouse.addLisenter(MouseEventType.ON_CLICK, callback);
mouse.addLisenter(MouseEventType.ON_MOVE, callback);
mouse.addLisenter(MouseEventType.ON_WHEEL, callback);
mouse.addLisenter(MouseEventType.ON_OVER, callback);
mouse.click();
mouse.blur();
}
catch (Exception e) {
e.printStackTrace();
}
}
}
结果为: