在现在的项目中,后台有一块程序感觉用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
..........