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.调用