`
lighter
  • 浏览: 500400 次
  • 性别: Icon_minigender_1
  • 来自: 广州
社区版块
存档分类
最新评论

体会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
..........
分享到:
评论

相关推荐

    Observer与Command模式在VTK类库设计中的应用研究

    #### 二、Observer/Command设计模式概述 ##### 1. Observer模式 Observer模式是一种行为设计模式,用于定义对象间的依赖关系,以便当一个对象(目标)的状态发生变化时,所有依赖于它的对象(观察者)都会自动收到...

    MVC小例子 使用Java类库observer和Observable

    在"Java类库observer和Observable"的上下文中,`Observer`和`Observable`是Java标准库中的接口和类,它们实现了观察者模式,这是MVC模式中的一个重要组成部分。观察者模式允许一个对象(观察者)注册到另一个对象...

    从Observer到Observable:使用Functional Swift提升复杂iOS项目的可维护性.pdf

    文档中提到的从Observer到Observable的转变,意味着在函数式编程思维的影响下,开发者倾向于使用Observable模式来代替传统的Observer模式。Observable模式是一种响应式编程的基础,允许对象注册自己想要的事件类型,...

    从Observer到Observable:使用Functional Swift提升复杂iOS项目的可维护性.zip

    使用Functional Swift提升复杂iOS项目的可维护性"这一主题深入探讨了如何利用Functional Programming(函数式编程)的理念,特别是Swift中的Observer(观察者)和Observable(可观察)模式,来优化代码设计,增强...

    observable-observer

    在Java中,`Observable`类和`Observer`接口是内置的实现,用于创建这种观察者模式。现在我们来详细探讨`Observable`和`Observer`的原理以及如何手动实现简单的`MyObservable`和`MyObserver`。 首先,`Observable`类...

    Observer模式

    在Java中,Observer模式主要通过java.util.Observable和java.util.Observer接口来实现。Observable类代表被观察的对象,Observer接口定义了观察者的基本行为。当Observable对象的状态发生变化时,会调用Observer接口...

    Observer设计模式实例

    Observer设计模式,也被称为“发布-订阅”(Publish-Subscribe)模式或“依赖倒置”模式,是软件设计中的一种行为模式。它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会得到...

    Go语言的Reactive扩展RxGo.zip

     // Create an `Observable` from a single item and subscribe to the observer.  sub := observable.Just(1).Subscribe(watcher)    fmt.Println(score) // 20 } 标签:RxGo

    Java高手真经 - Java Web系统设计与架构 源代码(一)设计模式

    pattern/src/behavior/observer //13.3观察者模式 pattern/src/behavior/iterator //13.4迭代子模式 pattern/src/behavior/chainofresponsibility//13.5责任链模式 pattern/src/behavior/command //13.6命令模式 ...

    C#面向对象设计模式纵横谈(19):(行为型模式) Observer 观察者模式 (Level 300)

    **C#面向对象设计模式纵横谈(19)**:**观察者模式**(Observer Pattern)是行为型模式的一种,它在软件工程中扮演着至关重要的角色。观察者模式是一种设计模式,它定义了对象之间的一对多依赖关系,当一个对象的状态...

    设计模式之略见一斑(Observer观察者模式)

    在Java中,我们可以使用`java.util.Observable`和`java.util.Observer`接口来实现观察者模式。但在这个例子中,我们可能看到的是自定义实现的观察者模式,因为文件列表中包含的`Test.java`, `Customer1.java`, `...

    Observer(观察者模式)学习源码

    在Java中,Observer模式主要通过java.util.Observable和java.util.Observer接口来实现。Observable类代表被观察的对象,Observer接口则代表观察者。以下是对这两个核心组件的详细说明: 1. **Observable类**: - `...

    Observer观察者模式

    在Java中,`java.util.Observable`类和`java.util.Observer`接口提供了内置的观察者模式支持。开发者可以通过继承`Observable`类来创建具体主题,实现`Observer`接口来创建具体观察者。当主题状态改变时,调用`...

    Observable与Observer

    在IT行业中,`Observable`与`Observer`是Java编程语言中的两个重要概念,它们是JavaFX和Java.util.Observable库的一部分,用于实现观察者模式。观察者模式是一种设计模式,它定义了对象之间的一对多依赖关系,当一个...

    利用观察者模式(发布/订阅模式)制作一个“代替”广播的通知类

    在Java中,`java.util.Observable`和`java.util.Observer`类提供了内置的观察者模式支持,但自定义实现可以更好地适应特定业务需求。在实际开发中,观察者模式广泛应用于事件驱动编程、GUI组件通信、状态管理等领域...

    observer观察者模式

    观察者模式(Observer Pattern)是一种行为设计模式,它允许你定义一个订阅机制,可以在对象状态改变时通知多个“观察”该对象的其他对象。在软件工程中,这常用于实现事件驱动编程,使得系统能够及时响应变化。 在...

    设计模式之观察者模式(Observer Pattern)

    "ObserverPattern(订阅模式)3.zip"中的代码可能进一步阐述了观察者模式,这里的“订阅”一词可能意味着用户可以订阅特定的主题,只有当这些主题的状态改变时,用户才会收到通知。这与传统的观察者模式类似,但更加...

    设计模式之Observer - 观察者模式

    在Java中,观察者模式的实现通常涉及到Java的内置接口`java.util.Observer`和`java.util.Observable`。`Observer`接口定义了一个方法`update(Observable o, Object arg)`,当被观察的对象状态改变时,这个方法会被...

Global site tag (gtag.js) - Google Analytics