设为首页收藏本站
开启辅助访问

在路上

 找回密码
 立即注册
在路上 › 站点首页 ›学习 › 查看内容

Java设计模式开发中使用观察者模式的实例教程

2016-7-29 15:37| 发布者: zhangjf| 查看: 674| 评论: 0

摘要: 观察者模式是软件设计模式中的一种，使用也比较普遍，尤其是在GUI编程中。关于设计模式的文章，网络上写的都比较多，而且很多文章写的也不错，虽然说有一种重复早轮子的嫌疑，但此轮子非彼轮子，侧重点不同，思路也 ...

观察者模式是软件设计模式中的一种，使用也比较普遍，尤其是在GUI编程中。关于设计模式的文章，网络上写的都比较多，而且很多文章写的也不错，虽然说有一种重复早轮子的嫌疑，但此轮子非彼轮子，侧重点不同，思路也不同，讲述方式也不近相同。
关键要素

主题:

主题是观察者观察的对象，一个主题必须具备下面三个特征。

  • 持有监听的观察者的引用
  • 支持增加和删除观察者
  • 主题状态改变，通知观察者

观察者:

当主题发生变化，收到通知进行具体的处理是观察者必须具备的特征。

为什么要用这种模式

这里举一个例子来说明，牛奶送奶站就是主题，订奶客户为监听者，客户从送奶站订阅牛奶后，会每天收到牛奶。如果客户不想订阅了，可以取消，以后就不会收到牛奶。

松耦合

观察者增加或删除无需修改主题的代码，只需调用主题对应的增加或者删除的方法即可。
主题只负责通知观察者，但无需了解观察者如何处理通知。举个例子，送奶站只负责送递牛奶，不关心客户是喝掉还是洗脸。
观察者只需等待主题通知，无需观察主题相关的细节。还是那个例子，客户只需关心送奶站送到牛奶，不关心牛奶由哪个快递人员，使用何种交通工具送达。

Java实现观察者模式
1. Java自带的实现
类图

201642494900291.jpg (806×524)

  2. /**
  3. * 观察目标 继承自 java.util.Observable
  4. * @author stone
  5. *
  6. */
  7. public class UpdateObservable extends Observable {
  9. private int data;
  11. public UpdateObservable(Observer observer) {
  12. addObserver(observer);
  13. /*
  14. * add other observer
  15. */
  16. }
  18. public int getData() {
  19. return data;
  20. }
  22. public void setData(int data) {
  23. if (data != this.data) {
  24. this.data = data;
  25. setChanged(); //标记 改变, 只有标记后才能通知到
  26. notifyObservers(); //通知
  27. }
  29. }
  31. @Override
  32. public synchronized void addObserver(Observer o) {
  33. super.addObserver(o);
  34. }
  36. @Override
  37. public synchronized void deleteObserver(Observer o) {
  38. super.deleteObserver(o);
  39. }
  41. @Override
  42. public void notifyObservers() {
  43. super.notifyObservers();
  44. }
  46. @Override
  47. public void notifyObservers(Object arg) {
  48. super.notifyObservers(arg);
  49. }
  51. @Override
  52. public synchronized void deleteObservers() {
  53. super.deleteObservers();
  54. }
  56. @Override
  57. protected synchronized void setChanged() {
  58. super.setChanged();
  59. }
  61. @Override
  62. protected synchronized void clearChanged() {
  63. super.clearChanged();
  64. }
  66. @Override
  67. public synchronized boolean hasChanged() {
  68. return super.hasChanged();
  69. }
  71. @Override
  72. public synchronized int countObservers() {
  73. return super.countObservers();
  74. }
  76. }
复制代码
  2. /**
  3. * 观察者 实现 java.util.Observer接口
  4. * @author stone
  5. *
  6. */
  7. public class UpdateObserver implements Observer {
  9. @Override
  10. public void update(Observable o, Object arg) {
  11. System.out.println("接收到数据变化的通知:");
  12. if (o instanceof UpdateObservable) {
  13. UpdateObservable uo = (UpdateObservable) o;
  14. System.out.print("数据变更为：" + uo.getData());
  15. }
  16. }
  18. }
复制代码

2. 自定义的观察模型
类图

201642494952492.jpg (968×676)

  2. /**
  3. * 抽象观察者 Observer
  4. * 观察 更新
  5. * @author stone
  6. *
  7. */
  8. public interface IWatcher {
  9. /*
  10. * 通知接口：
  11. * 1. 简单通知
  12. * 2. 观察者需要目标的变化的数据，那么可以将目标用作参数, 见Java的Observer和Observable
  13. */
  14. // void update(IWatched watched);
  16. void update();
  18. }
复制代码
  2. /**
  3. * 抽象目标 Subject
  4. * 提供注册和删除观察者对象的接口, 及通知观察者进行观察的接口
  5. * 及目标 自身被观察的业务的接口
  6. * @author stone
  7. *
  8. */
  9. public interface IWatchedSubject {
  11. public void add(IWatcher watch);
  13. public void remove(IWatcher watch);
  15. public void notifyWhatchers();
  17. public void update();//被观察业务变化的接口
  18. }
复制代码
  2. /**
  3. * 具体观察者 Concrete Observer
  4. *
  5. * @author stone
  6. *
  7. */
  8. public class UpdateWatcher implements IWatcher {
  10. @Override
  11. public void update() {
  12. System.out.println(this + "观察到：目标已经更新了");
  13. }
  15. }
复制代码


  2. /**
  3. * 具体目标角色 Concrete Subject
  4. * @author stone
  5. *
  6. */
  7. public class UpdateWatchedSubject implements IWatchedSubject {
  8. private List<IWatcher> list;
  10. public UpdateWatchedSubject() {
  11. this.list = new ArrayList<IWatcher>();
  12. }
  14. @Override
  15. public void add(IWatcher watch) {
  16. this.list.add(watch);
  17. }
  19. @Override
  20. public void remove(IWatcher watch) {
  21. this.list.remove(watch);
  22. }
  24. @Override
  25. public void notifyWhatchers() {
  26. for (IWatcher watcher : list) {
  27. watcher.update();
  28. }
  29. }
  31. @Override
  32. public void update() {
  33. System.out.println("目标更新中....");
  34. notifyWhatchers();
  35. }
  37. }
复制代码


监听器是观察者的一种实现：
类图

201642495137152.jpg (780×502)

  2. /**
  3. * 监听 用户在注册后
  4. * @author stone
  5. *
  6. */
  7. public interface IRegisterListener {
  8. void onRegistered();
  9. }
复制代码
  2. /**
  3. * 监听 当用户登录后
  4. * @author stone
  5. *
  6. */
  7. public interface ILoginListener {
  8. void onLogined();
  9. }
复制代码
  2. /*
  3. * 监听器 是观察者模式的一种实现
  4. * 一些需要监听的业务接口上添加 监听器，调用监听器的相应方法，实现监听
  5. */
  6. public class User {
  8. public void register(IRegisterListener register) {
  9. /*
  10. * do ... register
  11. */
  12. System.out.println("正在注册中...");
  13. //注册后
  14. register.onRegistered();
  15. }
  17. public void login(ILoginListener login) {
  18. /*
  19. * do ... login
  20. */
  21. System.out.println("正在登录中...");
  22. //登录后
  23. login.onLogined();
  24. }
  26. }
复制代码


  2. /**
  3. * 观察者(Observer)模式 行为型模式
  4. * 观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时观察某一个目标对象。
  5. * 这个目标对象在状态上发生变化时，会通知所有观察者对象，让它们能够自动更新自己
  6. * 目标对象中需要有添加、移除、通知 观察者的接口
  7. *
  8. * @author stone
  9. */
  10. public class Test {
  12. public static void main(String[] args) {
  13. /*
  14. * 使用Java自带的Observer接口和Observable类
  15. */
  16. UpdateObservable observable = new UpdateObservable(new UpdateObserver());
  17. observable.setData(99);
  18. System.out.println("");
  19. System.out.println("");
  20. /*
  21. * 自定义的观察者模型
  22. */
  23. IWatchedSubject watched = new UpdateWatchedSubject();
  24. watched.add(new UpdateWatcher());
  25. watched.add(new UpdateWatcher());
  26. watched.update();
  27. System.out.println("");
  29. /*
  30. * 子模式-监听器
  31. */
  33. User user = new User();
  34. user.register(new IRegisterListener() {
  36. @Override
  37. public void onRegistered() {
  38. System.out.println("监听到注册后。。。");
  39. }
  40. });
  41. user.login(new ILoginListener() {
  43. @Override
  44. public void onLogined() {
  45. System.out.println("监听到登录后。。。");
  46. }
  47. });
  49. }
  50. }
复制代码


打印

  2. 接收到数据变化的通知:
  3. 数据变更为：99
  5. 目标更新中....
  6. observer.UpdateWatcher@457471e0观察到：目标已经更新了
  7. observer.UpdateWatcher@5fe04cbf观察到：目标已经更新了
  9. 正在注册中...
  10. 监听到注册后。。。
  11. 正在登录中...
  12. 监听到登录后。。。
复制代码

收藏 邀请
上一篇：Java多线程编程中线程锁与读写锁的使用示例下一篇：实例讲解Java编程中数组反射的使用方法

最新评论

相关分类

小黑屋|在路上 ( 蜀ICP备15035742号-1 )  

;

GMT+8, 2025-10-31 21:27

Copyright 2015-2025 djqfx

返回顶部