【设计模式】观察者

观察者模式：

当某个事件发生时，通知客户端进行响应，如监听器的原理，即可采用此模式来实现。

观察者对主题中某些属性的改变感兴趣，或者对某个事件的发生感兴趣。

这些变化将由主题通知观察者。

观察者需要先注册到主题中，只要注册到主题中，当事件发生时就会得到通知。

当不关心事件是否发生时，可以取消注册。

 

===》主题

package pattern.observer;

public interface Subject {
	void registerObserver(Observer observer);
	void removeObserver(Observer observer);
	void notifyObserver();
}

package pattern.observer;

import java.util.ArrayList;
import java.util.List;

public class ConcreteSubject implements Subject {
	
	private String currentStatus;
	
	private boolean illegal;
	
	//维护若干感兴趣的观察者
	private List<Observer> observers;
	
	public ConcreteSubject() {
		observers = new ArrayList<Observer>();
	}
	
	//事件发生
	public void setDatas(String status, boolean illegal) {
		this.currentStatus = status;
		this.illegal = illegal;
		notifyObserver();//事件发生时，通知客户端
	}
	
	//注册
	public void registerObserver(Observer observer) {
		if(observer==null)
			return;
		if(!observers.contains(observer))
			this.observers.add(observer);
	}

	//取消注册
	public void removeObserver(Observer observer) {
		if(observer==null)
			return;
		if(observers.contains(observer))
			this.observers.remove(observer);
	}
	
	//将事件通知到客户端
	public void notifyObserver() {
		for(Observer obs : observers)
			obs.update(this);
	}
	
	//客户端可以采用拉的方式提取需要的数据
	public String getCurrentStatus() {
		return currentStatus;
	}

	public boolean isIllegal() {
		return illegal;
	}

}

===》观察者

package pattern.observer;

public interface Observer {
	void update(Subject subject);
}

 

package pattern.observer;

public class ClientA implements Observer {

	private String status;
	
	
	public ClientA(Subject subject) {
		subject.registerObserver(this);
	}

	public void update(Subject subject) {
		if(subject instanceof ConcreteSubject) {
			ConcreteSubject concreteSubject = (ConcreteSubject) subject;
			handleData(concreteSubject);
			showData();
		}
	}

	private void handleData(ConcreteSubject subject) {
		this.status = subject.getCurrentStatus();
	}

	private void showData() {
		System.out.println("status :" + this.status);
	}

}

 

package pattern.observer;

public class ClientB  implements Observer {

	private boolean  illegal;
	
	public ClientB(Subject subject) {
		subject.registerObserver(this);
	}
	
	public void update(Subject subject) {
		if(subject instanceof ConcreteSubject) {
			ConcreteSubject concreteSubject = (ConcreteSubject) subject;
			handleData(concreteSubject);
			showData();
		}
	}

	private void handleData(ConcreteSubject subject) {
		this.illegal = subject.isIllegal();
	}

	private void showData() {
		System.out.println("status :" + this.illegal);
	}
}

 

===》测试

package pattern.observer;

public class ObserverTest {
	public static void main(String[] args) {
		
		ConcreteSubject subject = new ConcreteSubject();
		
		//注册
		Observer a = new ClientA(subject);
		Observer b = new ClientB(subject);
		
		//状态发生改变，观察者将得到通知
		subject.setDatas("good", false);
		
		//解除注册
		subject.removeObserver(b);
		
		subject.setDatas("bad", true);
	}
}