观察者模式

什么是观察者模式：

定义了对象之间的一对多依赖，这样一来，当主题对象改变状态时，它的所有依赖者都会收到通知并自动更新。

这就好比订阅报纸，我们知道出版社每天都要出版报纸（主题Subject），如果你（观察者Observer）订阅了报纸，那么出版社一旦出版了报纸，就会给每个订阅过报纸的用户派发一份报纸。如果你不想要了，随时可以取消订阅，那么下次出版社就不会派发报纸给你了，就这么简单。

 

 

设计原则：
为了交互对象之间的松耦合设计而努力。即主题和观察者之间的松耦合。

 

 

这里先了解下两个概念：

主题 Subject ，也叫Observable ，可观察者 。当数据有变化通过它来通知所有注册了的观察者 Observer 。

 

 

那么这一切该如何实现呢？

我们先来看看效果图

 

 

说明下：这里的SeekBar起到的作用是模拟数据更新变化的作用，当然需要你来滑动它。当它的数据变化的时候，告诉主题，再由主题负责通知主题所维护的每个观察者（Button），来更新数据。你可以这样看，实际上主题在这充当了桥梁的作用，负责变化的数据源和Button之间的沟通。

 

我们再来看看项目的结构：

 

这里我定义了两个接口，一个是为主题定义的，一个是为观察者定义的。

 

Observable.java:

/**
 * 主题接口，也就是起到java.util.Observable这个类的作用
 * 
 * */
public interface Observable {

	void addObserver(Observer observer);
	void deleteObserver(Observer observer);
	void notifyObservers(int progress);
}

 这个接口的目的是为了维护观察者对象，这里的维护包括了添加，取消，通知。

 

Observer.java:

public interface Observer {

	void update(int degree);
}

 就一个方法，负责更新主题传递过来的数据。

 

下面我们看看如何实现这两个接口：

主题接口的实现ObservableImpl.java：

public class ObservableImpl implements Observable{

	private List<Observer> observerList;//这个List维护着观察者的注册和取消注册
	
	public ObservableImpl() {
		observerList = new ArrayList<Observer>();
	}

	/**
	 * 注册监听
	 * 
	 * */
	@Override
	public void addObserver(Observer observer) {
		observerList.add(observer);
	}

	/**
	 * 取消监听
	 * 
	 * */
	@Override
	public void deleteObserver(Observer observer) {
		int index = observerList.indexOf(observer);
		if(index >= 0)
		{
			observerList.remove(index);
		}
	}

	/**
	 * 通知所有的观察者改变数据
	 * 
	 * */
	@Override
	public void notifyObservers(int progress) {
		for (Observer observer : observerList) {
			observer.update(progress);
        }
	}
	
	
	/**
	 * SeekBar通过这个方法与Subject进行交互
	 * 当然，通过notifyObservers也是一样的。
	 * 
	 * */
	public void setData(int progress)
	{
		notifyObservers(progress);
	}
	
}

 

观察者接口的实现ObserverButton.java:

public class ObserverButton extends Button implements Observer{
	
	public ObserverButton(Context context, AttributeSet attrs, int defStyle) {
		super(context, attrs, defStyle);
	}

	public ObserverButton(Context context, AttributeSet attrs) {
		super(context, attrs);
	}

	public ObserverButton(Context context) {
		super(context);
	}

	/**
	 * 将本类注册成为一个观察者，本来这个最好是在构造器中进行，但是由于构造器的参数限制，因此写一个方法用来注册
	 * 这个方法需要首先被调用
	 * 
	 * */
	public void registerObserver(Observable observable)
	{
		observable.addObserver(this);
	}
	
	/**
	 * 取消监听
	 * 
	 * */
	public void unRegisterObserver(Observable observable)
	{
		observable.deleteObserver(this);
	}
	
	/**
	 * 对主题的改变进行处理
	 * 
	 * */
	@Override
	public void update(int degree) {
		this.setText("" + degree);
	}
}

 

MainActivity.java:

/**
 * 自己实现的观察者模式，效果类似于java API中的Observable类
 * 
 * 
 * */
public class MainActivity extends Activity {

	
	private SeekBar sbDataChanger;
	private ObservableImpl subjectImpl;
	private ObserverButton  btnObserverOne;
	private ObserverButton  btnObserverTwo;
	private ObserverButton  btnObserverThree;
	
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        subjectImpl = new ObservableImpl();
        sbDataChanger = (SeekBar)findViewById(R.id.sb_data_changer);
        btnObserverOne = (ObserverButton )findViewById(R.id.btn_observer_one);
        btnObserverTwo = (ObserverButton )findViewById(R.id.btn_observer_two);
        btnObserverThree = (ObserverButton )findViewById(R.id.btn_observer_three);
        
        //这里需要在3个按钮被实例化的时候都调用registerObserver(Observable observable)方法
        //一便一开始就实现监听，本来这个是要放在构造器中来做的，但是Button的构造器不能自定义，因此放在这里来调用
        btnObserverOne.registerObserver(subjectImpl);
        btnObserverTwo.registerObserver(subjectImpl);
        btnObserverThree.registerObserver(subjectImpl);
        
        sbDataChanger.setOnSeekBarChangeListener(new OnSeekBarChangeListener() {
			
			@Override
			public void onStopTrackingTouch(SeekBar seekBar) {
				
			}
			
			@Override
			public void onStartTrackingTouch(SeekBar seekBar) {
				
			}
			
			@Override
			public void onProgressChanged(SeekBar seekBar, int progress,
					boolean fromUser) {
				// SeekBar在这个地方与主题进行交互
				//当SeekBar的progress改变的时候，主题中的数据也改变，主题再对所有监听了该主题的观察者一一通知，从而达到改变数据的目的
				//主题在这个地方相对于桥梁的作用，不仅这样，它还负责观察者的注册和取消注册
				subjectImpl.setData(progress);
			}
		});
        
        btnObserverOne.setOnClickListener(clickListener);
        btnObserverTwo.setOnClickListener(clickListener);
        btnObserverThree.setOnClickListener(clickListener);
    }

    private View.OnClickListener clickListener = new View.OnClickListener() {
		
		@Override
		public void onClick(View v) {

			switch (v.getId()) {
			case R.id.btn_observer_one:
				cancelRegister(v);
				break;
			case R.id.btn_observer_two:
				cancelRegister(v);
				break;
			case R.id.btn_observer_three:
				cancelRegister(v);
				break;
			default:
				break;
			}
		}
	};
	
	/**
	 * 取消监听
	 * 
	 * */
	private void cancelRegister(View view)
	{
		ObserverButton observerButton = (ObserverButton)view;
		observerButton.unRegisterObserver((Observable)subjectImpl);
		Toast.makeText(this, "一个按钮取消了监听", Toast.LENGTH_SHORT).show();
	}
}

 

这样我们自定义的一个观察者模式就实现了。

 

 

当然这样的做法利于对象之间的松耦合，可是每次为了实现观察者都需要大量的代码量，未免太麻烦了，因此java语言中提供了内置的类和接口供你方便地使用观察者模式。

 

主题：java.util.Observable;

观察者：java.util.Observer;

 

注意主题Observable是一个类，而不是接口！Observer是接口。这也就是说，如果你的主题对象已经继承自别的类，那么就限制了你使用java所提供的Observable类，你就不得不按照上面的做法来实现观察者模式了。

 

下面看看工程结构：

 

 

主题：ObservableImpl.java:

/**
 * 这个类继承自java.util.Observable，注意：这个类是一个类，而不是接口
 * 这个是java API提供的类，我们就不需要自己去实现观察者对象的管理了，即不需要使用List来管理以及发送通知了。
 * 
 * 但是这个类最大的缺点就是它是一个类，而不是接口，扩展性较差
 * 
 * */
public class ObservableImpl extends Observable{

	int progress = 0;
	
	/**
	 * SeekBar通过这个方法与Subject进行交互
	 * 
	 * */
	public void setData(int progress)
	{
		this.progress = progress;
		setChanged();//在调用notifyObservers方法之前，这个方法一定要调用！否则没有效果！看看源码就知道了，这里有一个boolean标志位
		notifyObservers(progress);
	}
	
	/**
	 * 供“拉”方法取数据
	 * 
	 * */
	public int getProgress()
	{
		return this.progress;
	}
	
}

 

观察者：ObserverButton.java:

/**
 * 实现的是java。util.Observer这个接口，而不是自定义的接口
 * 这个接口提供了一个update方法，用来接收主题传递过来的数据
 * 
 * */
public class ObserverButton extends Button implements Observer{
	
	public ObserverButton(Context context, AttributeSet attrs, int defStyle) {
		super(context, attrs, defStyle);
	}

	public ObserverButton(Context context, AttributeSet attrs) {
		super(context, attrs);
	}

	public ObserverButton(Context context) {
		super(context);
	}
	
	private int progress = 0;
	/**
	 * 将本类注册成为一个观察者，本来这个最好是在构造器中进行，但是由于构造器的参数限制，因此写一个方法用来注册
	 * 这个方法需要首先被调用
	 * 
	 * */
	public void registerObserver(Observable observable)
	{
		observable.addObserver(this);
	}
	
	/**
	 * 取消监听
	 * 
	 * */
	public void unRegisterObserver(Observable observable)
	{
		observable.deleteObserver(this);
	}
	
	/**
	 * 这里接收主题的通知
	 * 
	 * */
	@Override
	public void update(Observable arg0, Object arg1) {
		
		//这个是“拉”方法
		if(arg0 instanceof ObservableImpl){
			
			ObservableImpl subjectImpl = (ObservableImpl)arg0;
			this.progress = subjectImpl.getProgress();//需要自己去主题中取数据
			display();
		}
		
		//这个是“推”方法
//		if(arg1 instanceof Integer){
//			
//			this.progress = (Integer)arg1;
//			display();
//		}
		
	}
	
	/**
	 * 显示数据
	 * 
	 * */
	private void display()
	{
		this.setText(""+progress);
	}
}

 

MainActivity.java和第一种方法差不多，这里就不贴出来了。

可见让java语言提供的类来实现观察者确实可以省下不少的代码量，但是正如前面所说的。由于主题是一个类，这难免影响了主题类的扩展。所以，当你的主题没有从别的类继承，那么推荐你使用系统提供的Observable主题，如果你的主题已经继承自别的类，那么你就必须自己实现观察者了。

 

还需要解释下什么是“推”方法，什么是“拉”方法。看下面代码：

@Override
	public void update(Observable arg0, Object arg1) {
		
		//这个是“拉”方法
		if(arg0 instanceof ObservableImpl){
			
			ObservableImpl subjectImpl = (ObservableImpl)arg0;
			this.progress = subjectImpl.getProgress();//需要自己去主题中取数据
			display();
		}
		
		//这个是“推”方法
//		if(arg1 instanceof Integer){
//			
//			this.progress = (Integer)arg1;
//			display();
//		}
		
	}

 其实就是在update方法中，对参数的处理不太一样而已，update方法中将主题对象的引用和数据对象传递过来。通过主题对象的引用来调用getter方法，称为“拉”方法，而直接获取并使用传递过来的数据，称为“推”方法。这个很形象，应该不难理解。

当然，我在自定义的观察者模式中使用的是推方法，即直接将数据传递过去。并没有实现拉方法，你也可以自己加上去。多个参数而已。

 

下面是使用java内置观察者达到的效果，也自定义的没有什么区别：

 

 

我将这两个工程放到github上，有兴趣的同学可以下载看看：

 

https://github.com/michaelye/ObserverPattern 自定义观察者模式

 

https://github.com/michaelye/ObserverPattern_JavaUtil 使用java内置的观察者模式