观察者模式(有时又被称为发布-订阅Subscribe>模式、模型-视图View>模式、源-收听者Listener>模式或从属者模式)是软件设计模式的一种。在此种模式中,一个目标物件管理所有相依于它的观察者物件,并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实现事件处理系统。
观察者模式(Observer)完美的将观察者和被观察的对象分离开。举个例子,用户界面可以作为一个观察者,业务数据是被观察者,用户界面观察业务数据的变化,发现数据变化后,就显示在界面上。
面向对象设计的一个原则是:系统中的每个类将重点放在某一个功能上,而不是其他方面。一个对象只做一件事情,并且将他做好。观察者模式在模块之间划定了清晰的界限,提高了
应用程序的可维护性和重用性。
观察者设计模式定义了对象间的一种一对多的依赖关系,以便一个对象的状态发生变化时,所有依赖于它的对象都得到通知并自动刷新。
Java代码Demo
//观察者,需要用到观察者模式的类需实现此接口
public interface Observer{
void update(Object...objs);
}
//被观察者(一个抽象类,方便扩展)
public abstract class Observable{
public finalArrayList<Class<?>> obserList = new ArrayList<Class<?>>();
/**AttachObserver(通过实例注册观察者)
*<b>Notice:</b>obcan'tbenull,oritwillthrowNullPointerException
**/
public<T> void registerObserver(Tob){
if(ob==null) throw new NullPointerException();
this.registerObserver(ob.getClass());
}
/**
*AttachObserver(通过Class注册观察者)
*@paramcls
*/
public void registerObserver(Class<?>cls){
if(cls==null) throw new NullPointerException();
synchronized(obserList){
if(!obserList.contains(cls)){
obserList.add(cls);
}
}
}
/**UnattachObserver(注销观察者)
*<b>Notice:</b>
*<b>ItreverseswithattachObserver()method</b>
**/
public<T>void unRegisterObserver(Tob){
if(ob==null) throw new NullPointerException();
this.unRegisterObserver(ob.getClass());
}
/**UnattachObserver(注销观察者,有时候在未获取到实例使用)
*<b>Notice:</b>
*<b>ItreverseswithattachObserver()method</b>
**/
public void unRegisterObserver(Class<?>cls){
if(cls==null) throw new NullPointerException();
synchronized(obserList){
Iterator<Class<?>>iterator=obserList.iterator();
while(iterator.hasNext()){
if(iterator.next().getName().equals(cls.getName())){
iterator.remove();
break;
}
}
}
}
/**detachallobservers*/
public void unRegisterAll(){
synchronized(obserList){
obserList.clear();
}
}
/**Ruturnthesizeofobservers*/
public int countObservers(){
synchronized(obserList){
returnobserList.size();
}
}
/**
*notify all observer(通知所有观察者,在子类中实现)
*@paramobjs
*/
public abstract void notifyObservers(Object... objs);
/**
*notify one certain observer(通知某一个确定的观察者)
*@paramcls
*@paramobjs
*/
public abstract void notifyObserver(Class<?> cls, Object... objs);
/**
*notifyonecertainobserver
*@paramcls
*@paramobjs
*/
public abstract<T> void notifyObserver(T t, Object... objs);
}
//目标被观察者
public class ConcreteObservable extends Observable{
private static ConcreteObservableinstance = null;
private ConcreteObservable(){};
public static synchronized ConcreteObservablegetInstance(){
if(instance == null){
instance=newConcreteObservable();
}
returninstance;
}
@Override
public <T> void notifyObserver(T t, Object... objs){
if(t == null) throw new NullPointerException();
this.notifyObserver(t.getClass(), objs);
}
@Override
public void notifyObservers(Object... objs){
for(Class<?>cls : obserList){
this.notifyObserver(cls, objs);
}
}
//通过java反射机制实现调用
@Override
public void notifyObserver(Class<?>cls, Object...objs){
if(cls == null) throw new NullPointerException();
Method[] methods = cls.getDeclaredMethods();
for(Method method : methods){
if(method.getName().equals("update")){
try{
method.invoke(cls,objs);
break;
}catch(IllegalArgumentException e){
e.printStackTrace();
}catch(IllegalAccessException e){
e.printStackTrace();
}catch(InvocationTargetException e){
e.printStackTrace();
}
}
}
}
}
//使用(实现Observer接口)
public class Text extends Activity implements Observer{
publicvoidonCreate(...){
ConcreteObservable.getInstance().registerObserver(Text.class);
....
}
//实现接口处理
publicvoidupdate(Object...objs){
//做操作,比如更新数据,更新UI等
}
}