设计模式之观察者模式

           观察者模式：定义对象之间的一种一对多的依赖关系，当一个对象状态发生改变时，所有依赖于他的对象都将得到通知并自动更新。

    下面通过该模式思想来实现一个事件机制。某个业务状态变更时发出具体事件，有需要的业务监听该业务事件，并在监听到事件时做出反应处理。

    首先定义抽象事件接口，包括发布事件、注册事件监听器、注销事件监听器等事件操作，并发布服务。

                

/**
* 事件抽象接口
* &&
* 提供事件发布以及事件监听器的注册、删除方法
* @author xx
*/
public interface EventService
{
/**
* 发布事件
* @param event 事件
*/
public void publish(Event event);

/**
* 批量发布事件
* @param collection 事件集合
*/
public void publish(Collection<Event> collection);

/**
* 注册事件监听
* @param eventListener 事件监听器
* @param eventID 事件ID
*/
public void addEventListener(EventListener eventListener, String eventID);

/**
* 注册事件监听，根据 filter 过滤
* @param eventListener 事件监听器
* @param filter 过滤器
* @param eventID 事件ID
*/
public void addEventListener(EventListener eventListener, EventFilter filter, String eventID);

/**
* 注销事件监听
* @param eventListener 事件监听器
*/
public void removeEventListener(EventListener eventListener);
}

           其中，Event是抽象事件类，包含基本的事件id,事件资源等属性，所有具体事件继承该类；EventListener为抽象事件监听器接口，所有具体事件监听器继承该接口；EventFilter为事件过滤接口。

    EventListener定义如下：

 

/**
* 事件监听器抽象接口，所有具体事件监听器继承该接口
* @author xx
*
*/
public interface EventListener
{
/**
* 事件监听器处理方法
* @param event 事件
*/
public void onEvent(Event event);
}

    然后，发布事件的业务可以定义自己的具体事件对象，如下，

/**
* 测试事件，继承自抽象事件
* @author xx
*
*/
public class TestEvent extends Event
{
/**
* 序列号
*/
private static final long serialVersionUID = 2107606925118238578L;

/**
* 事件类型，可以是个枚举，这里测试不再具体定义
*/
private String eventType;

/**
* 事件数据列表，测试，不再具体定义
*/
private List<Object> objList = new ArrayList<Object>();

public String getEventType()
{
return eventType;
}

public void setEventType(
String eventType)
{
this.eventType = eventType;
}

public List<Object> getObjList()
{
return objList;
}

public void setObjList(List<Object> objList)
{
this.objList = objList;
}
}

     并在状态发生变更的时候，发布事件

/**
* 测试事件发布类
* @author xx
*
*/
public class TestEventPublisher
{
private EventService eventService;

public void publicTestEvent()
{
TestEvent event = new TestEvent();
event.setEventType("testType");

//构造数据等代码省略

eventService.publish(event);
}

public EventService getEventService()
{
//测试代码，省掉具体获取服务方法
return eventService;
}

public void setEventService(EventService eventService)
{
this.eventService = eventService;
}
}

     然后，和该业务相关的业务监听该业务事件，定义一个抽象事件类，通过一个事件队列，在业务内部管理事件，当监听到事件时，加入事件队列，并为每个事件建立线程任务，通过该队列将事件分发出去处理。

/**
* 业务事件监听器抽象类
* @author xx
*
*/
public abstract class AbstractEventListener implements IEventListener
{
/**
* 事件队列
*/
private BlockingQueue<Event> eventQueue = new LinkedBlockingQueue<Event>();

/**
* 事件监听状态
*/
private AtomicBoolean isRunning = new AtomicBoolean(true);

/**
*启动事件监听
*/
@Override
public void start()
{
ThreadFactory.getInstance().startThread(new EventHandler());
}

public void onEvent(Event event)
{
try
{
//新增事件加入事件队列
eventQueue.put(event);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}

/**
* 停止事件监听
*/
@Override
public void stop()
{
isRunning.compareAndSet(true, false);
}

private class EventHandler implements Runnable
{

@Override
public void run()
{
try
{
while(isRunning.get())
{
//从事件队列取出事件执行
process(eventQueue.take());
}
}
catch (InterruptedException e)
{
e.printStackTrace();
}

}

}

}

    其中，IEventListener是该业务自己的监听接口，继承自基本监听接口EventListener

/**
* 业务事件监听接口，继承自基本事件监听接口
* @author xx
*
*/
public interface IEventListener extends EventListener
{
/**
* 事件处理方法
* @param event 事件
*/
public void process(Event event);

/**
* 启动事件监听
*/
public void start();

/**
* 停止事件监听
*/
public void stop();

}

    当然，该业务还没有注册事件监听器，这样当发布事件的业务发布事件时候，你也是收不到的，定义一个事件管理类，负责注册事件

   

/**
* 业务事件监听管理类
* @author xx
*
*/
public class EventMonitor
{
/**
* 事件管理服务
*/
private EventService eventService;

/**
* 测试用事件监听器
*/
private IEventListener testEventListener;

private void registerListeners()
{
//注册测试事件监听器
eventService.addEventListener(testEventListener, "testEventId");
}

private void unregisterListeners()
{
//注销事件监听器
eventService.removeEventListener(testEventListener);
}

/**
* 绑定服务
* @param service 服务
* @param properties 属性
*/
public void bindService(Object service, Map<Object, Object> properties)
{
if(service instanceof EventService)
{
eventService = (EventService)service;
registerListeners();
}
else
{
;
}
}

/**
* 解绑定服务
* @param service 服务
* @param properties 属性
*/
public void unbindService(Object service, Map<Object, Object> properties)
{
if(service instanceof EventService)
{
eventService = null;
unregisterListeners();
}
else
{
;
}
}

public EventService getEventService()
{
return eventService;
}

public void setEventService(
EventService eventService)
{
this.eventService = eventService;
}

public IEventListener getTestEventListener()
{
return testEventListener;
}

public void setTestEventListener(IEventListener testEventListener)
{
this.testEventListener = testEventListener;
}
}

    通过spring.xml中配置服务监听，绑定EventService服务，在系统启动是回调绑定方法bindService，并注册事件监听器，具体配置如下：

<!--监听EventService服务，并通过绑定的方式注入服务-->
<oms:reference id="eventService" interface="base.event.EventService" wait="false">
<oms:listener ref="Event_Service" bind-method="bindService" unbind-method="unbindService"/>
</oms:reference>

<!--通过依赖注入实例化EventMonitor中的具体监听器属性-->
<bean id="Event_Service" class="service.event.EventMonitor">
<property name="testEventListener" ref="Test_Event_Service">
</bean>

<!--注册实例化回调方法来启动监听器-->
<bean id="Test_Event_Service" class="service.event.TestEventListener"
init-method="start" destroy-method="stop">
</bean>

    事件监听器如下：

/**
* 一个具体的事件监听器
* @author xx
*
*/
public class TestEventListener extends AbstractEventListener
{

@Override
public void process(Event event)
{
//非指定具体事件不处理
if(event instanceof TestEvent)
{
return;
}

final TestEvent testEvent = (TestEvent)event;
//过滤事件类型
if(testEvent.getEventType().equals("testType"))
{
//处理事件
processEvent(event);
}

}

private void processEvent(Event event)
{
// TODO Auto-generated method stub

}

}

    通过以上操作，就说明整个事件机制，在自己的业务中可以注册所有需要的事件，而发布事件的业务只需要将自己的状态变换通过事件发布出去，很好的实现了模块之间的解耦。