体会Observer/Observable模式

在现在的项目中，后台有一块程序感觉用Observer/Observable模式比较好一些，所以和同事就写这样一个很简单的demo出来，记录下来，当作记录吧。里面的用到的API是Doug Lea这一大牛写的concurrent包，已经成为了java1.5的标准库了。但我们只能1.4的JDK，所以用concurrent包来代替实现同样的功能。
有一个Pojo类如下：

public class Account {

	private int numOne;

	private int numTwo;

	private int sum;

	public int getNumOne() {
		return numOne;
	}

	public void setNumOne(int numOne) {
		this.numOne = numOne;
	}

	public int getNumTwo() {
		return numTwo;
	}

	public void setNumTwo(int numTwo) {
		this.numTwo = numTwo;
	}

	public int getSum() {
		return sum;
	}

	public void setSum(int sum) {
		this.sum = sum;
	}
}

再写一个在通知观察者之前需要做什么工作的类：

import edu.emory.mathcs.backport.java.util.concurrent.Callable;

public class AccountTask implements Callable {
	
       private int numOne,numTwo;
	
	public AccountTask(int numOne , int numTwo){
		this.numOne = numOne;
		this.numTwo = numTwo;
	}
	
	/**
	 * 计算numOne和numTwo的值并相加
	 */
	public Object call() throws Exception {
		int resultNum = this.numOne + this.numTwo;
		return String.valueOf(resultNum);
	}
}

然后后，想想啊，就是写一个观察者嘛：

import java.util.Observable;
import java.util.Observer;

public class PaddingDBObserver implements Observer {

	/** 假设的数据保存 */
	private int [][] db = new int [10][10];
	
	public void update(Observable o, Object arg) {
		if (arg instanceof Account) {
			Account obj = (Account)arg;
			int rowNum = obj.getNumOne();
			int colNum = obj.getNumTwo();
			db[rowNum][colNum] = obj.getSum(); //假设数据保存的，在这一个例子里面并没有什么用
			System.out.println("填充[" + rowNum + "][" + colNum +"]=" + obj.getSum());
		}
	}
}

再就是，写一个最核心的Observable类啦，如下：

import java.util.Observable;

import edu.emory.mathcs.backport.java.util.concurrent.ExecutionException;
import edu.emory.mathcs.backport.java.util.concurrent.ExecutorService;
import edu.emory.mathcs.backport.java.util.concurrent.Executors;
import edu.emory.mathcs.backport.java.util.concurrent.Future;

public class ServiceThread extends Observable implements Runnable{

	private static final long serialVersionUID = 7010111816402017124L;

	private volatile int numOne;

	private volatile int numTwo;

	public ServiceThread(int numOne, int numTwo) {
		this.numOne = numOne;
		this.numTwo = numTwo;
	}
	/**
	 * 线程运行
	 */
	public void run() {
		/** 创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。 */
		ExecutorService executor = Executors.newSingleThreadExecutor();
		/** 提交一个返回值的任务用于执行，返回一个表示任务的未决结果的 Future */
		Future future = executor.submit(new AccountTask(numOne, numTwo));
		try {
			String result = (String) future.get();
			int sum = Integer.parseInt(result);

			Account obj = new Account();
			obj.setNumOne(this.numOne);
			obj.setNumTwo(this.numTwo);
			obj.setSum(sum);

			setChanged();
			super.notifyObservers(obj);
		} catch (InterruptedException e) {
		} catch (ExecutionException e) {
		}
		/** 线程关闭 */
		executor.shutdown();
	}
}

最后，就是再随便添加一个执行的类，如下：

import edu.emory.mathcs.backport.java.util.concurrent.ExecutorService;
import edu.emory.mathcs.backport.java.util.concurrent.Executors;

public class AccountMain {

	/** 线程池 */
	private ExecutorService pool = null;
	
	public void start() {
		/** 创建一个可重用固定线程集合的线程池，以共享的无界队列方式来运行这些线程。 */
		pool = Executors.newFixedThreadPool(10);

		for (int i = 0; i < 10; i++) {
			for (int j = 0; j < 10; j++) {
				ServiceThread st = new ServiceThread(i, j);
				st.addObserver(new PaddingDBObserver());
				pool.execute(st);
			}
		}
		/** 关闭线程池 */
		pool.shutdown();
	}

	/**
	 * 测试程序
	 * @param args
	 */
	public static void main(String[] args) {
		AccountMain am = new AccountMain();
		am.start();
	}
}

执行的结果：

引用

填充[0][2]=2
填充[0][9]=9
填充[0][5]=5
填充[0][1]=1
.........
填充[1][8]=9
填充[1][7]=8
.......
填充[2][8]=10
填充[3][2]=5
填充[3][3]=6
..........