常用设计模式之观察者模式（Observer）+JAVA例子实现

介绍

概述
观察者模式定义了对象之间的一对多的依赖，这样一来，当一个对象改变时，它的所有依赖者都会收到通知并自动更新。
角色介绍:
抽象主题（Subject）：它把所有观察者对象的引用保存到一个聚集里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象。
具体主题（ConcreteSubject）：将有关状态存入具体观察者对象；在具体主题内部状态改变时，给所有登记过的观察者发出通知。
抽象观察者（Observer）：为所有的具体观察者定义一个接口，在得到主题通知时更新自己。
具体观察者（ConcreteObserver）：实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题状态协调。
正文
如果你熟悉消息队列，观察者模式跟消息队列的发布订阅很像，如果你没有了解过也没关系，我用一个简单的例子帮你理解一下。
我们用一个小游戏“木头人”来理解一下，主题就是发布指令的那个人，他背对我们，他背过去的时候，我们可以走路，他改变状态扭过头，我们就不可以走路。所以我们就是观察者，我们通过观察他的状态做出不同的相应。
代码实现：
抽象主题，我们还是面向接口编程，用接口方式，你也可以使用抽象类。

public interface Subject {

	//注册观察者
	public void registerObserver(Observer o);
	//删除观察者
	public void removeObserver(Observer o);
	//通知观察者
	public void notifyObserver();

}

具体主题，实现抽象主题接口

public class Publisher implements Subject{

	private List<Observer> observers;

	private Integer state;

	public Publisher() {
		observers = new ArrayList<>();
	}

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

	@Override
	public void removeObserver(Observer o) {
		int i = observers.indexOf(o);
		if(i > 0){
			observers.remove(i);
		}
	}

	@Override
	public void notifyObserver() {
		for(int i=0;i<observers.size();i++){
			Observer observer = observers.get(i);
			observer.update(state);

		}
	}

	public void setState(Integer state) {
		this.state = state;
		//我们改变状态时，通知观察者
		notifyObserver();
	}
}

抽象观察者，只有一个update方法

public interface Observer {

	/**
	 * 更新状态state 0 表示不可以动，1表示可以动
	 * @param state
	 */
	public void update(Integer state);
}

具体观察者，每一个玩游戏的人

public class PlayerA implements Observer{
	private Subject publisher;
	private String name;

	public PlayerA(Subject publisher,String name) {
		this.publisher = publisher;
		this.name = name;
		//注册观察者
		publisher.registerObserver(this);
	}

	@Override
	public void update(Integer state) {
		if(state.equals(0)){
			System.out.println("不动，我不动");
		}
		//随机往前走的步数
		if(state.equals(1)){
			int step = (int)(1+Math.random()*10);
			System.out.println(name+"走了"+step+"步");
		}
	}

}

public class PlayerB implements Observer{

	private Subject publisher;

	private Integer steps;

	private String name;

	public PlayerB(Subject publisher,String name) {
		this.publisher = publisher;
		this.name = name;
		//注册观察者
		publisher.registerObserver(this);
	}

	@Override
	public void update(Integer state) {
		if(state.equals(0)){
			System.out.println("不动，我不动");
		}
		//随机往前走的步数
		if(state.equals(1)){
			int step = (int)(1+Math.random()*10);
			System.out.println(name+"走了"+step+"步");
		}
	}

}

客户端代码

public class Client {

	public static void main(String[] args) {
		Publisher publisher = new Publisher();
		PlayerA xiaoming = new PlayerA(publisher, "xiaoming");

		PlayerB xiaohong = new PlayerB(publisher, "xiaohong");
		publisher.setState(0);
		publisher.setState(1);
		publisher.setState(0);
		publisher.setState(1);
		publisher.setState(0);
		publisher.setState(1);

	}
}

输出结果

不动，我不动
不动，我不动
xiaoming走了6步
xiaohong走了1步
不动，我不动
不动，我不动
xiaoming走了6步
xiaohong走了8步
不动，我不动
不动，我不动
xiaoming走了4步
xiaohong走了4步

总结
优点：观察者模式解除了主题和具体观察者的耦合，让耦合的双方都依赖于抽象，而不是依赖具体。从而使得各自的变化都不会影响另一边的变化。
缺点：依赖关系并未完全解除，抽象通知者依旧依赖抽象的观察者。