java 观察者模式与spring配置

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

一、Observer模式的意图：

在对象的内部状态发生变化时，自动通知外部对象进行响应。

二、Observer模式的构成：

·被观察者：内部状态有可能被改变，而且又需要通知外部的对象

·观察者：需要对内部状态的改变做出响应的对象

三、Observer模式的Java实现：

Java的API中已经为我们提供了Observer模式的实现。具体由java.util.Observable类和java.util.Observer接口完成。

前者有两个重要的方法：

·setChanged：设置内部状态为已改变

·notifyObservers(Object obj)：通知观察者所发生的改变，参数obj是一些改变的信息

后者有一个核心方法：

·update(Object obj)：相应被观察者的改变，其中obj就是被观察者传递过来的信息，该方法会在notifyObservers被调用时自动调用。

下面是Observer模式的实现过程：

·创建一个被观察者，继承java.util.Observable

·创建一个观察者，实现java.util.Observer接口

· 注册观察着，调用addObserver(Observer observer)

·在被观察者改变对象内部状态的地方，调用setChanged()方法，然后调用notifyObservers(Object)方法，通知被观察者

·在观察者的update(Object)方法中，对改变做出响应。

四、Observer模式的好处：

1.Observer模式的优点：

·被观察者只需要知道谁在观察它，无需知道具体的观察细节

·被观察者一旦发生变化，只需要通过广播的方式告知观察者，至于消息如何到达则不需知道。这样的话无疑消除了被观察者和观察者之间通信的硬编码

·当一个被观察者同时被多个观察着观察时，观察者可以只选择自己感兴趣的事件，而忽略其它的事件

·多个观察者组合起来可以形成一个观察链，如果一旦需要回滚多个操作，此时观察链可以发挥作用

·观察者可以实时对被观察对象的变化做出响应，例如自动告警、中断运行等

2.运用Observer模式可以

·屏蔽线程间的通信机制：例如两个线程之间，主线程可以作为观察者，执行线程是被观察者。彼此之间只知道对方存在，但不知道之间通信的细节

·消除硬编码：如果没有Observer模式，则只能采用回调的模式，或者在代码中显示地调用观察者

·优化异常机制：特别适合在异常发生时向顶层监控，减少try-catch代码量

代码：

public class Observable {
private boolean changed = false;
private Vector obs;
//创建被观察者时就创建一个它持有的观察者列表，注意，这个列表是需要同步的。
public Observable() {
obs = new Vector();
}
/**
* 添加观察者到观察者列表中去
*/
public synchronized void addObserver(Observer o) {
if (o == null)
throw new NullPointerException();
if (!obs.contains(o)) {
obs.addElement(o);
}
}
/**
* 删除一个观察者
*/
public synchronized void deleteObserver(Observer o) {
obs.removeElement(o);
}
/**
* 通知操作，即被观察者发生变化，通知对应的观察者进行事先设定的操作，不传参数的通知方法
*/
public void notifyObservers() {
notifyObservers(null);
}
/**
* 与上面的那个通知方法不同的是，这个方法接受一个参数，这个参数一直传到观察者里，以供观察者使用
*/
public void notifyObservers(Object arg) {
Object[] arrLocal;
synchronized (this) {
if (!changed)
return;
arrLocal = obs.toArray();
clearChanged();
}
for (int i = arrLocal.length-1; i>=0; i--)
((Observer)arrLocal[i]).update(this, arg);
}
}
public interface Observer {
/**
* This method is called whenever the observed object is changed. An
* application calls an <tt>Observable</tt> object's
* <code>notifyObservers</code> method to have all the object's
* observers notified of the change.
*
* @param o the observable object.
* @param arg an argument passed to the <code>notifyObservers</code>
* method.
*/
void update(Observable o, Object arg);
}
}
public class MailObserver implements Observer{
/**
* 这个类取名为MailObserver，顾名思义，她是一个用来发送邮件的观察者
*/
public void update(Observable o, Object arg) {
System.out.println("发送邮件的观察者已经被执行");
}
}
public class JMSObserver implements Observer{
public void update(Observable o, Object arg) {
System.out.println("发送消息给jms服务器的观察者已经被执行");
}
}
public class Subject extends Observable{
/**
* 业务方法，一旦执行某个操作，则通知观察者
*/
public void doBusiness(){
if (true) {
super.setChanged();
}
notifyObservers("现在还没有的参数");
}
public static void main(String [] args) {
//创建一个被观察者
Subject subject = new Subject();
//创建两个观察者
Observer mailObserver = new MailObserver();
Observer jmsObserver = new JMSObserver();
//把两个观察者加到被观察者列表中
subject.addObserver(mailObserver);
subject.addObserver(jmsObserver);
//执行业务操作
subject.doBusiness();
}
}

在spring中使用观察者模式的方法如下

<bean id="mailObserver" class="MailObserver"/>

<bean id="jmsObserver" class="JMSObserver"/>

<bean id="subjectTarget" class="Subject"/>

<bean id="subject"
class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
<property name="targetObject"><ref local="subjectTarget"/></property>
<property name="targetMethod"><value>addObserver</value></property>
<property name="arguments">
<list>
<ref bean="mailObserver"/>
<ref bean="jmsObserver"/>
</list>
</property>
</bean>
观察者模式的效果有以下几个优点：