Java设计模式_观察者模式&事件处理机制

74 阅读 0 评论 49 点赞

我是靠谱客的博主爱笑长颈鹿，最近开发中收集的这篇文章主要介绍Java设计模式_观察者模式&事件处理机制，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

1.什么是观察者模式:

观察者模式:定义了对象之间的一对多依赖,可以有任意个(一个或多个)观察者对象同时监听某一个对象;这样一来,当一个对象改变状态时,它的所有依赖者都会收到通知并自动更新.

观察者模式也叫发布/订阅模式,监听器模式

发布者+订阅者=观察者模式

2.观察者模式的作用:

降低交互对象之间的耦合度

java事件处理机制:

执行流程: 事件源生成事件,并发送至一个过多个监听器,监听器等待,直到收到一个事件,一旦事件被接收,监听器将处理这些事件,然后返回.

事件源:

事件源是一个生成事件的对象;一个事件源可能生成不同类型的事件;事件源提供了一组方法,用于事件注册一个或多个监听器(比如说，你点击一个button，那么button就是event source，要想使button对某些事件进行响应，你就需要注册特定的listener。)

事件: (继承java.util.EventObject)

事件是一个描述事件源状态改变的对象,(用于listener的相应的方法之中，作为参数，一般存在与listerner的方法之中)

事件监听: (继承 java.util.EventListener)

对每个明确的事件的发生，都相应地定义一个明确的Java方法。这些方法都集中定义在事件监听者（EventListener）接口中，这个接口要继承 java.util.EventListener。实现了事件监听者接口中一些或全部方法的类就是事件监听者。

代码结构:

1.Source

所有 Event 在构造时都引用了对象Source ,可以理解成产生Event的根源;(在swing中,Source 就类似一个button)

2.Event

封装了事件的各种状态的对象

3.Listener

如果收到一个事件,会通知所有的监听

4.Controller

--提供对事件订阅和通知的接口

--提供对业务操作的接口

--事件轮询器

package com.tomorrow_p.linkevent_p.core;
import android.os.Handler;
import android.os.Message;
import android.os.SystemClock;
import com.tomorrow_p.linkevent_p.event.LinkEvent;
import com.tomorrow_p.linkevent_p.listener.LinkEventListener;
import com.tomorrow_p.linkevent_p.source.LinkEventSource;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.concurrent.CopyOnWriteArrayList;
/**
* 事件 订阅/通知 接口
* Created by tomorrow_p on 2014/2/2.
* 注册事件 >> 移除事件 >> 通知事件
*/
public class LinkEventController implements ILinkEventController {
private static LinkEventController instance;
private EventThread mEventThread;
private LinkedList<LinkEvent> mStacks = new LinkedList<LinkEvent>();
private CopyOnWriteArrayList<LinkEventListener> listeners=new CopyOnWriteArrayList<LinkEventListener>();
private LinkEventController() {
initEventThread();
}
private void initEventThread() {
mEventThread = new EventThread();
mEventThread.start();
}
private Handler mHandler=new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
Iterator<LinkEventListener> iterator= listeners.iterator();
while(iterator.hasNext()){
LinkEventListener listener=iterator.next();
listener.onLinkEvent((LinkEvent)msg.obj);
}
}
};
public static LinkEventController getInstance() {
if (instance == null) {
synchronized (LinkEventController.class) {
if (instance == null) {
instance = new LinkEventController();
}
}
}
return instance;
}
private class EventThread extends Thread {
@Override
public void run() {
super.run();
while (!isInterrupted()) {
synchronized (mEventThread) {
if (!mStacks.isEmpty()){
LinkEvent linkEvent=getLinkEvent();
if(linkEvent!=null){
Message message=new
Message();
message.what=1;
message.obj=linkEvent;
mHandler.sendMessage(message);
}else {
// TODO Log
}
}else{
SystemClock.sleep(100);
}
}
}
}
}
public LinkEvent getLinkEvent(){
synchronized(mStacks){
if(mStacks.size()>0){
return mStacks.removeFirst();
}
}
return null;
}
@Override
public void registLinkEventListener(LinkEventListener listener) {
registLinkEventListener(listener,true);
}
@Override
public void registLinkEventListener(LinkEventListener listener, boolean singleton) {
boolean isExist=false;
for (LinkEventListener linkEventListener: listeners){
if(linkEventListener==listener){
isExist=true;
}
}
if(isExist&&singleton){
return;
}
listeners.add(listener);
}
@Override
public synchronized void unregistLinkEventListener(LinkEventListener listener) {
listeners.remove(listener);
}
@Override
public void notifyListener(LinkEvent event) {
addEvent(event);
}
private void addEvent(LinkEvent event) {
synchronized(mStacks){
mStacks.add(event);
}
}
@Override
public void notify(String uuid, LinkEvent event) {
throw new RuntimeException("not support this methord now!");
}
@Override
public void notify(LinkEventSource source, LinkEvent event) {
throw new RuntimeException("not support this methord now!");
}
}

5.调用