java观察者模式

在一对多依赖的对象关系中, 如果这个'一'对象状态发生了变化,那么它所有依赖的'多'对象都应该被通知,然后做相应的变化,这就是观察者模式. 就如同'多'对象一直在观察'一'对象的状态变化一样.

在观察者模式中最重要的俩个对象分别是:Observable和Observer对象.它们的关系可总结如下:

1. Observable和Observer对象是一对多的关系,也就是说一旦Observable对象状态变化,它就要负责通知所有和它有关系的Observer对象,然后做相应的改变.

1. Observable对象不会主动去通知各个具体的Observer对象其状态发生了变化,而是提供一个注册接口供Observer对象使用,任何一个Observer对象如果想要被通知,则可以使用这个接口来注册.

3. 在Observable中有一个集合和一个状态控制开关,所有注册了通知的Observer对象会被保存在这个集合中.这个控制开关就是用来控制Observable是否发生了变化,一旦发生了变化,就通知所有的Observer对象更新状态.

在java api中分别提供了Observable对象:java.util.Observable和Observer接口:java.util.Observer. 下面用实例来实现一下观察者模式: 股票系统

所有的类如下:

StockData (Observable对象,也就是所股票数据发生了变化,它就要通知所有和它有关系的交易实体做相应的变化)

BigBuyer (Observer对象, 实现了Observer接口)

TradingFool (Observer对象, 实现了Observer接口)

StockQuote 测试类

在这个例子中一旦StockData对象的状态发生了变化,那BigBuyer和TradingFool都应该受到通知:

StockData.java:

Java代码

1. importjava.util.Observable;
3. publicclassStockDataextendsObservable
4. {
5. privateStringsymbol;
6. privatefloatclose;
7. privatefloathigh;
8. privatefloatlow;
9. privatelongvolume;
11. publicStockData()
12. {}
14. publicStringgetSymbol()
15. {
16. returnsymbol;
17. }
19. publicfloatgetClose()
20. {
21. returnclose;
22. }
24. publicfloatgetHigh()
25. {
26. returnhigh;
27. }
29. publicfloatgetLow()
30. {
31. returnlow;
32. }
34. publiclonggetVolume()
35. {
36. returnvolume;
37. }
39. publicvoidsendStockData()
40. {
41. setChanged();
42. notifyObservers();
43. }
45. publicvoidsetStockData(Stringsymbol,floatclose,floathigh,floatlow,longvolume)
46. {
47. this.symbol=symbol;
48. this.close=close;
49. this.high=high;
50. this.low=low;
51. this.volume=volume;
52. sendStockData();
53. }
54. }

BigBuyer.java:

Java代码

1. publicclassBigBuyerimplementsObserver
2. {
3. privateStringsymbol;
4. privatefloatclose;
5. privatefloathigh;
6. privatefloatlow;
7. privatelongvolume;
9. publicBigBuyer(Observableobservable)
10. {
11. observable.addObserver(this);//注册关系
12. }
14. publicvoidupdate(Observableobservable,Objectargs)
15. {
16. if(observableinstanceofStockData)
17. {
18. StockDatastockData=(StockData)observable;
19. this.symbol=stockData.getSymbol();
20. this.close=stockData.getClose();
21. this.high=stockData.getHigh();
22. this.low=stockData.getLow();
23. this.volume=stockData.getVolume();
24. display();
25. }
26. }
28. publicvoiddisplay()
29. {
30. DecimalFormatSymbolsdfs=newDecimalFormatSymbols();
31. DecimalFormatvolumeFormat=newDecimalFormat("###,###,###,###",dfs);
32. DecimalFormatpriceFormat=newDecimalFormat("###.00",dfs);
33. System.out.println("BigBuyerreports...");
34. System.out.println("\tThelasteststockquotefor"+symbol+"is:");
35. System.out.println("\t$"+priceFormat.format(close)+"pershare(close).");
36. System.out.println("\t$"+priceFormat.format(high)+"pershare(high).");
37. System.out.println("\t$"+priceFormat.format(low)+"pershare(low).");
38. System.out.println("\t"+volumeFormat.format(volume)+"sharestraded.");
39. System.out.println();
40. }
41. }

TradingFool.java:

Java代码

1. publicclassTradingFoolimplementsObserver
2. {
3. privateStringsymbol;
4. privatefloatclose;
6. publicTradingFool(Observableobservable)
7. {
8. observable.addObserver(this);//注册关系
9. }
11. publicvoidupdate(Observableobservable,Objectargs)
12. {
13. if(observableinstanceofStockData)
14. {
15. StockDatastockData=(StockData)observable;
16. this.symbol=stockData.getSymbol();
17. this.close=stockData.getClose();
18. display();
19. }
20. }
22. publicvoiddisplay()
23. {
24. DecimalFormatSymbolsdfs=newDecimalFormatSymbols();
25. DecimalFormatpriceFormat=newDecimalFormat("###.00",dfs);
26. System.out.println("TradingFoolsays...");
27. System.out.println("\t"+symbol+"iscurrentlytradingat$"+priceFormat.format(close)+"pershare.");
28. System.out.println();
29. }
30. }

StokeQuote.java

Java代码

1. publicclassStockQuotes
2. {
3. publicstaticvoidmain(String[]args)
4. {
5. System.out.println();
6. System.out.println("--StockQuoteApplication--");
7. System.out.println();
9. StockDatastockData=newStockData();
11. //registerobservers...
12. newTradingFool(stockData);
13. newBigBuyer(stockData);
15. //generatechangestostockdata...
16. stockData.setStockData("JUPM",16.10f,16.15f,15.34f,(long)481172);
17. stockData.setStockData("SUNW",4.84f,4.90f,4.79f,(long)68870233);
18. stockData.setStockData("MSFT",23.17f,23.37f,23.05f,(long)75091400);
19. }
20. }

在测试类中我们可以看到俩个Observer对象都注册了Observable对象,而当Observable对象发生改变时,这俩个Observable对象就会做相应的更新了, 运行结果如下:

Java代码

1. BigBuyerreports...
2. ThelasteststockquoteforJUPMis:
3. $16.10pershare(close).
4. $16.15pershare(high).
5. $15.34pershare(low).
6. 481,172sharestraded.
8. TradingFoolsays...
9. JUPMiscurrentlytradingat$16.10pershare.
11. BigBuyerreports...
12. ThelasteststockquoteforSUNWis:
13. $4.84pershare(close).
14. $4.90pershare(high).
15. $4.79pershare(low).
16. 68,870,233sharestraded.
18. TradingFoolsays...
19. SUNWiscurrentlytradingat$4.84pershare.
21. BigBuyerreports...
22. ThelasteststockquoteforMSFTis:
23. $23.17pershare(close).
24. $23.37pershare(high).
25. $23.05pershare(low).
26. 75,091,400sharestraded.
28. TradingFoolsays...
29. MSFTiscurrentlytradingat$23.17pershare.

我们通过Observable源码可以看到,其实Observable对象不关心具体的Observer的实例类型. 只要是实现了Observer接口的Observer对象都可以得到通知,这就为我们如果想要对模型进行扩展提供了方便,使Observable对象和Observer对象实现了松耦合. 如果我们需要添加一个新的Observer对象时,我们只要注册一下,当Observable对象发生变化时就可以得到通知,而不要做其他任何改变,非常方便.