1.spring 是一个强大的应用结构，有很多优点，设计模式也是应用的淋淋尽致，一下简单介绍spring 中观察者应用。
首先我们通过源码可以清晰的知道，在我们spring beandefinition等初始化之后，有一个监听器注册的方法
// Check for listener beans and register them. registerListeners();
这是注册的一个入口，
看上述代码，大致描述下，首先获取实现spplicationlistener接口的所有类，将其注册到容器中，然后创建发布监听，
可以看到，这里做的工作就是启动任务线程，任务的最终调用是调用实现applicationlistener的
onApplicationEvent方法
整个过程就是这样，那么让我们简单实现模拟一个这样的过程
1.编写一个监听器
package com.consult.listen;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
public class MyListen implements ApplicationListener {
public void onApplicationEvent(ApplicationEvent arg0) {
if(arg0 instanceof MyEvent) {
MyEvent event = (MyEvent)arg0;
System.out.println(this.getClass().getName() + event.getParam1());
System.out.println(this.getClass().getName() + event.getParam2());
System.out.println(this.getClass().getName() + event.getSource());
}
}
}
2.监听事件
package com.consult.listen;
import org.springframework.context.ApplicationEvent;
public class MyEvent extends ApplicationEvent {
public String param1;
public String param2;
public MyEvent(Object source,String param1,String param2) {
super(source);
this.param1 = param1;
this.param2 = param2;
}
public Object getSource() {
return super.getSource();
}
public String getParam1() {
return param1;
}
public void setParam1(String param1) {
this.param1 = param1;
}
public String getParam2() {
return param2;
}
public void setParam2(String param2) {
this.param2 = param2;
}
}
注意一定定义一个构造函数，测试类如下：
package com.consult.listen;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.consult.postprocess.Student;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class MyTest implements ApplicationContextAware {
public ApplicationContext context;
@Test
public void test1(){
Student s = (Student)context.getBean("jackstudent");
System.out.println(s.getUsername());
System.out.println(s.getPassword());
System.out.println(s.getSchool());
}
@Override
public void setApplicationContext(ApplicationContext arg0)
throws BeansException {
this.context = arg0;
}
@Test
public void test2() {
MyEvent event = new MyEvent("source","param1","param2");
context.publishEvent(event);
}
}
以上测试类配置没有写，搞这个的很简单，大致代码如上述。
好了，整个的源码解析和简单应用就是这样。下面是模式的基础概念：
一. 观察者模式简介
1. 定义
观察者模式：定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖它的对象都会得到通知并自动更新。
2. 意义
此设计模式最重要的作用就是 解耦！将观察者与被观察者解耦，使得他们之间的依赖性更小。
Subject：就是“被观察”的角色，它将所有观察者对象的引用保存在一个集合中。
Observer：是抽象的“观察”角色，它定义了一个更新接口，使得在被观察者状态发生改变时通知自己。
ConcreteObserver：具体的观察者。
二. 观察者模式实现
以上理论相信大家并不模式，现在我们来应用到实际中。
1. 被观察者Subject对象
首先是一个Subject类的父类，它实现了维护装有观察者引用集合的功能。
public class Subject {
//保存注册的观察者对象
private List<Observer> mObervers = new ArrayList<>();
//注册观察者对象
public void attach(Observer observer) {
mObervers.add(observer);
Log.e("SZH", "attach an observer");
}
//注销观察者对象
public void detach(Observer observer) {
mObervers.remove(observer);
Log.e("SZH", "detach an observer");
}
//通知所有注册的观察者对象
public void notifyEveryOne(String newState) {
for (Observer observer : mObervers) {
observer.update(newState);
}
}
}
接着是一个具体的被观察者对象
public class ConcreteSubject extends Subject {
private String state;
public String getState() {
return state;
}
public void change(String newState) {
state = newState;
Log.e("SZH", "concreteSubject state:" + newState);
//状态发生改变，通知观察者
notifyEveryOne(newState);
}
}
2. 观察者Observer对象
首先是一个接口，抽象出了一个及时更新的方法
public interface Observer {
void update(String newState);
}
1
2
3
接着是几个观察者对象。
public class ObserverA implements Observer {
//观察者状态
private String observerState;
@Override
public void update(String newState) {
//更新观察者状态，让它与目标状态一致
observerState = newState;
Log.e("SZH", "接收到消息：" + newState + "；我是A模块，快来抢吧！！");
}
}
public class ObserverB implements Observer {
//观察者状态
private String observerState;
@Override
public void update(String newState) {
//更新观察者状态，让它与目标状态一致
observerState = newState;
Log.e("SZH", "接收到消息：" + newState + "；我是B模块，快来抢吧！！");
}
}
public class ObserverC implements Observer {
//观察者状态
private String observerState;
@Override
public void update(String newState) {
//更新观察者状态，让它与目标状态一致
observerState = newState;
Log.e("SZH", "接收到消息：" + newState + "；我是C模块，快来抢吧！！");
}
}