设计模式-观察者模式

来源：《设计模式之禅》

定义：观察者模式也叫订阅者模式。定义对象间一种一对多的依赖关系，使得每当一个对象改变状态时，所有依赖他的对象都会得到通知并更新状态。

观察者角色：

1. Subject 被观察者：定义被观察者的职责，动态的新增，删除观察者。

2. ConcreteSubject 具体被观察者：实现Subject。

3. observer 观察者：定义观察者结束消息和状态更新的方法。

4. ConcreteObserver 具体观察者：实现observer 观察者定义。

类图：

代码：

抽象主题，被观察者

/**
 * 
 */
package cc.rico.pattern.observe;

/**
 * @author rico
 * 抽象主题，被观察者
 */
public interface Subject {
	
	/**
	 * 添加观察者
	 * @param observer
	 */
	public void add(Observer observer);
	
	/**
	 * 删除观察者
	 * @param observer
	 */
	public void remove(Observer observer);
	
	/**
	 * 发送消息给观察者
	 */
	public void messageNotify();
}

具体主题

/**
 * 
 */
package cc.rico.pattern.observe;

import java.util.Vector;

/**
 * @author rico
 * 具体主题
 */
public class ConcreteSubject implements Subject {
	private Vector<Observer> vector = new Vector<Observer>();

	/* (non-Javadoc)
	 * @see cc.rico.pattern.observe.Subject#add(cc.rico.pattern.observe.Observer)
	 */
	@Override
	public void add(Observer observer) {
		vector.add(observer);
	}

	/* (non-Javadoc)
	 * @see cc.rico.pattern.observe.Subject#remove(cc.rico.pattern.observe.Observer)
	 */
	@Override
	public void remove(Observer observer) {
		vector.remove(observer);
	}

	/* (non-Javadoc)
	 * @see cc.rico.pattern.observe.Subject#messageNotify()
	 */
	@Override
	public void messageNotify() {
		for(Observer item : vector) {
			item.action("###具体主题发送消息...");
		}
	}

}

抽象观察者

/**
 * 
 */
package cc.rico.pattern.observe;

/**
 * @author rico
 * 抽象观察者
 */
public interface Observer {
	
	/**
	 * 观察内容
	 * @param context
	 */
	public void action(String context);
}

具体观察者

/**
 * 
 */
package cc.rico.pattern.observe;

/**
 * @author rico
 * 具体观察者
 */
public class ConcreteObserver1 implements Observer {

	/* (non-Javadoc)
	 * @see cc.rico.pattern.observe.Observer#action(java.lang.String)
	 */
	@Override
	public void action(String context) {
		System.out.println("###ConcreteObserver1.action");
		System.out.println("接收的消息：" + context);
	}

}

/**
 * 
 */
package cc.rico.pattern.observe;

/**
 * @author rico
 * 具体观察者
 */
public class ConcreteObserver implements Observer {

	/* (non-Javadoc)
	 * @see cc.rico.pattern.observe.Observer#action(java.lang.String)
	 */
	@Override
	public void action(String context) {
		System.out.println("###ConcreteObserver.action");
		System.out.println("接收的消息：" + context);
	}

}

场景类:

/**
 * 
 */
package cc.rico.pattern.observe;

/**
 * @author rico
 * 场景类
 */
public class Client {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Observer ob1 = new ConcreteObserver();
		Observer ob2 = new ConcreteObserver1();
		
		Subject subject = new ConcreteSubject();
		subject.add(ob1);
		subject.add(ob2);
		
		subject.messageNotify();
	}

}

观察者模式优点：

1. 被观察者和观察者之间是抽象耦合，易于扩展。

2. 建立一套触发机制。

观察者模式缺点：

     观察者模式需要考虑一下开发效率和运行效率问题，一个被观察者，多个观察者，开发和调试会比较复杂。

使用场景：

1. 关联行为场景。

2. 事件多级触发。

3. 夸系统的消息交互。

扩展：