体会Observer/Observable模式

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

再写一个在通知观察者之前需要做什么工作的类：
[code]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);
}
}[/code]

然后后，想想啊，就是写一个观察者嘛：
[code]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());
}
}
}[/code]

再就是，写一个最核心的Observable类啦，如下：
[code]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();
}
}[/code]

最后，就是再随便添加一个执行的类，如下：
[code]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();
}
}
[/code]

执行的结果：
[quote]填充[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
..........[/quote]