GUI中的观察者模式

MVC模式对于用户界面的开发有着重要的意义，在Java中，不是按照标准的MVC模式实现的，而是将控制器和视图结合起来，而模型独立存在。模型成为观察者模式中的被观察对象，而控制器和视图则作为观察者。

下面是一个改自《重构》的例子，如下图所示：三个输入框之间的关系为start+length=end。 修改其中的任何一个输入框，都要保持这个关系恒成立。如果将数据模型和GUI界面、事件处理全部混在一个类，一样可以实现这个功能，但是代码将十分难懂，也难以维护和拓展。因此将数据模型独立出来。

首先定义数据模型类，数据模型提供接口操作，用于查询、修改或者其他更复杂的数据操作，供用户调用，代码如下：

/**
 * 
 */
package design.patterns.eventgenerator.observer;

import java.util.Observable;

/**
 * @author Brandon B. Lin
 * 
 */
public class TestModel extends Observable {

	private String end = "0";
	private String start = "0";
	private String length = "0";

	public String getEnd() {
		return end;
	}

	public void setEnd(String end) {
		this.end = end;
		setChanged();
		notifyObservers();
	}

	public String getStart() {
		return start;
	}

	public void setStart(String start) {
		this.start = start;
		setChanged();
		notifyObservers();
	}

	public String getLength() {
		return length;
	}

	public void setLength(String length) {
		this.length = length;
		setChanged();
		notifyObservers();
	}

	public void calculateLength() {
		try {
			int start = Integer.parseInt(getStart());
			int end = Integer.parseInt(getEnd());
			int length = end - start;
			setLength(String.valueOf(length));
		} catch (NumberFormatException exception) {
			exception.printStackTrace();
		}
	}

	public void calculateEnd() {
		try {
			int start = Integer.parseInt(getStart());
			int lenght = Integer.parseInt(getLength());
			int end = start + lenght;
			setEnd(String.valueOf(end));
		} catch (NumberFormatException exception) {
			exception.printStackTrace();
		}
	}

}

这个模型类继承了Observable抽象类，提供查询数据的get方法，同时提供修改数据的方法set，如果数据被修改，通知所有监听者（setChanged和notifyObservers方法）。除此以外，它还提供了逻辑操作接口calculateLength和calculateEnd。

接着定义用户界面，处理时间，同时与模型交互。代码如下：

/**
 * 
 */
package design.patterns.eventgenerator.observer;

import java.awt.GridLayout;
import java.awt.event.FocusAdapter;
import java.awt.event.FocusEvent;
import java.util.Observable;
import java.util.Observer;

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.SwingUtilities;

/**
 * @author Brandon B. Lin
 * 
 */
public class TestWindow extends JFrame implements Observer {

	private static final long serialVersionUID = 8232669335169364475L;
	private JTextField startField;
	private JTextField endField;
	private JTextField lengthField;

	private TestModel model;

	public TestWindow() {
		initFrame();
		initModel();
	}

	private void initFrame() {
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setTitle("Test Window");
		setSize(400, 300);
		add(createTextFieldPanel());
	}

	private void initModel() {
		model = new TestModel();
		model.addObserver(this);
		update(model, null);
	}

	private JPanel createTextFieldPanel() {
		JPanel textFieldPanel = new JPanel();
		textFieldPanel.setLayout(new GridLayout(3, 2));
		JLabel startLabel = new JLabel("Start: ");
		startField = new JTextField("0", 5);

		SymbolFocus listener = new SymbolFocus();
		startField.addFocusListener(listener);

		JLabel endLabel = new JLabel("End: ");
		endField = new JTextField("0", 5);
		endField.addFocusListener(listener);
		JLabel lengthLabel = new JLabel("Length: ");
		lengthField = new JTextField("0", 5);
		lengthField.addFocusListener(listener);

		textFieldPanel.add(startLabel);
		textFieldPanel.add(startField);
		textFieldPanel.add(endLabel);
		textFieldPanel.add(endField);
		textFieldPanel.add(lengthLabel);
		textFieldPanel.add(lengthField);

		return textFieldPanel;

	}

	// self encapsulate field
	public String getEnd() {
		return model.getEnd();
	}

	public void setEnd(String newValue) {
		model.setEnd(newValue);
	}

	public String getStart() {
		return model.getStart();
	}

	public void setStart(String newValue) {
		model.setStart(newValue);
	}

	public String getLength() {
		return model.getLength();
	}

	public void setLength(String newValue) {
		model.setLength(newValue);
	}

	@Override
	public void update(Observable observable, Object context) {
		endField.setText(model.getEnd());
		startField.setText(model.getStart());
		lengthField.setText(model.getLength());
	}

	public static void main(String[] args) {
		SwingUtilities.invokeLater(new Runnable() {

			@Override
			public void run() {
				new TestWindow().setVisible(true);
			}
		});

	}

	class SymbolFocus extends FocusAdapter {
		@Override
		public void focusLost(FocusEvent event) {
			Object source = event.getSource();
			if (source == lengthField) {
				setLength(lengthField.getText());
				model.calculateEnd();
			} else if (source == startField) {
				setStart(startField.getText());
				model.calculateLength();
			} else {
				setEnd(endField.getText());
				model.calculateLength();
			}
		}

	}

}

这个类实现了观察者接口Observer，在构造函数中，初始化用户界面，然后初始化模型。通过持有对模型类的引用来与模型类交互。当用户改变任何一个输入框的值的时候，作为响应，首先改变模型类中相应的数据，然后调用模型的业务逻辑，其结果也是改变了模型的数据，而一旦有模型数据改变，作为观察者的用户界面都会得到通知，得到通知后就可以更新界面。逻辑十分清晰。

《重构》中把这个称谓“Duplicate Observed Data”，其实就是通过观察者模式来保持数据模型和用户界面（数据的显示）之间的同步，是一种MVC变体。我们还看到在TestWindow类中，用到了“Self encapsulate field”重构方法，这一重构在这个例子中也许看不到什么好处，我们完全可以通过对model相关方法直接调用，但是通过封装，以函数的形式提供访问，显得更加整洁，另外，当子类覆盖这些方法的时候，可以对这些数据进行额外的操作修改。