Java设计模式-观察者模式

1 定义：

        观察者模式也叫作发布/订阅者模式，它定义了一种一对多的依赖关系，多个观察者同时观察一个主题对象，当这个对象的状态发生变化时候，会通知所有的观察者对象自动更新自己。

2 角色：

        a)Subject,抽象主题：即抽象观察者，它将任意的观察者对象存储在一个集合中，并且提供抽象的接口用来增删观察者对象

        b)ConcreteSubject:具体主题，即具体观察者，它将具体状态存入观察者对象，当具体主题的状态发生变化时候，会给所有注册的观察者发送通知更新自己

        c)Observer:抽象观察者，即观察者的抽象类，它定义了一个抽象的接口用来当主题发生变化时候通知更新自己

        d)ConcreteObserver:具体观察者,实现抽象观察者的抽象接口，当主题对象发生变化时候通知更新自己

  3 代码：

 a)Subject:抽象主题

   public interface Observer {
 	public void update(String msg);
   }

b)ConcreteSubject:具体主题

public class Observer1 implements Observer {
	private String name;

	public Observer1(String name) {
		super();
		this.name = name;
	}

	@Override
	public void update(String msg) {
		System.out.println("name:" + name + "--收到message:" + msg);
	}
}

public class Observer2 implements Observer {
	private String name;
	
	public Observer2(String name) {
		super();
		this.name = name;
	}

	@Override
	public void update(String msg) {
		System.out.println("name:"+name+"--收到message:"+msg);
	}
}

c)Observer:抽象观察者

public interface Subject {
	/* 增加观察者 */
	void add(Observer observer);

	/* 删除观察者 */
	void del(Observer observer);

	/* 通知所有的观察者 */
	void notifyObservers(String message);

	/* 自身的操作 */
	void operation(String msg);
}

public abstract class AbstractSubject implements Subject {
	private List<Observer> observers = new ArrayList<Observer>();

	@Override
	public void add(Observer observer) {
		observers.add(observer);
	}

	@Override
	public void del(Observer observer) {
		observers.remove(observer);
	}

	@Override
	public void notifyObservers(String message) {
		for(Observer observer:observers){
			observer.update(message);
		}
	}
}

d)ConcreteObserver:具体观察者

public class MySubject extends AbstractSubject {
	@Override
	public void operation(String msg) {
		System.out.println("自身关公收到的通知："+msg);
		notifyObservers(msg);
	} 
}

e)测试类

public class ObserverTest {
	public static void main(String[] args) {
		Subject sub = new MySubject();
		Observer1 observer1 = new Observer1("貂蝉");
		Observer1 observer2 = new Observer1("吕布");
		Observer2 observer3 = new Observer2("董卓");
		sub.add(observer1);
		sub.add(observer2);
		sub.add(observer3);
		sub.operation("通知更新版本2.0了");
		sub.del(observer3);
		sub.operation("算了，还是开除董卓，咱们自己玩儿吧 ");
	}
}

f)运行结果

4 总结

         优点：
接触了具体观察者和主题的耦合关系，使其依赖于抽象，不依赖于具体，这样的话使得各自的变化不会影响另外一边的变化

         缺点：依旧存在依赖关系，虽然是抽象的通知者依赖抽象的观察者

         适用场景：

       a)当一个对象改变需要改变其他对象，并且不知道有多少具体对象需要改变的时候

   b)一个抽象模型有两个方面，当其中一个方面依赖于另一个方面时候，这时候用观察者模式可以将两者封装在独立的对象中使他们各自独立的改变和复用