观察者模式

小灰灰 2020-06-13 05:42 669阅读 0赞

当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。

介绍

意图：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

主要解决：一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。

何时使用：一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知，进行广播通知。

如何解决：使用面向对象技术，可以将这种依赖关系弱化。

关键代码：在抽象类里有一个 ArrayList 存放观察者们。

应用实例 ：1、拍卖的时候，拍卖师观察最高标价，然后通知给其他竞价者竞价。 2、西游记里面悟空请求菩萨降服红孩儿，菩萨洒了一地水招来一个老乌龟，这个乌龟就是观察者，他观察菩萨洒水这个动作。

优点 ：1、观察者和被观察者是抽象耦合的。 2、建立一套触发机制。

缺点： 1、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。 2、如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。 3、观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

使用场景 ：

  • 一个抽象模型有两个方面，其中一个方面依赖于另一个方面。将这些方面封装在独立的对象中使它们可以各自独立地改变和复用。
  • 一个对象的改变将导致其他一个或多个对象也发生改变，而不知道具体有多少对象将发生改变，可以降低对象之间的耦合度。
  • 一个对象必须通知其他对象，而并不知道这些对象是谁。
  • 需要在系统中创建一个触发链，A对象的行为将影响B对象，B对象的行为将影响C对象……，可以使用观察者模式创建一种链式触发机制。

注意事项： 1、JAVA 中已经有了对观察者模式的支持类。 2、避免循环引用。 3、如果顺序执行，某一观察者错误会导致系统卡壳，一般采用异步方式。

实现

观察者模式使用三个类 Subject、Observer 和 Client。Subject 对象带有绑定观察者到 Client 对象和从 Client 对象解绑观察者的方法。我们创建 Subject 类、Observer 抽象类和扩展了抽象类 Observer 的实体类。

ObserverPatternDemo，我们的演示类使用 Subject 和实体类对象来演示观察者模式。

观察者模式

步骤 1

创建 Subject 类。

Subject.java

  1. public class Subject {
  3.     private List<Observer> observers = new ArrayList<>();
  5.     private int state;
  7.     public int getState() {
  8.         return state;
  9.     }
  11.     public void setState(int state) {
  12.         this.state = state;
  13.         notifyAllObservers();
  14.     }
  16.     public void attach(Observer observer) {
  17.         observers.add(observer);
  18.     }
  20.     public void notifyAllObservers() {
  21.         for (Observer observer : observers) {
  22.             observer.update();
  23.         }
  24.     }
  26. }

步骤 2

创建 Observer 类。

Observer.java

  1. public abstract class Observer {
  3.     protected Subject subject;
  5.     public abstract void update();
  7. }

步骤 3

创建实体观察者类。

BinaryObserver.java

  1. public class BinaryObserver extends Observer {
  3.     public BinaryObserver(Subject subject) {
  4.         this.subject = subject;
  5.         this.subject.attach(this);
  6.     }
  8.     @Override
  9.     public void update() {
  10.         System.out.println("Binary String: "
  11.                 + Integer.toBinaryString(subject.getState()));
  12.     }
  14. }

OctalObserver.java

  1. public class OctalObserver extends Observer {
  3.     public OctalObserver(Subject subject){
  4.         this.subject = subject;
  5.         this.subject.attach(this);
  6.     }
  8.     @Override
  9.     public void update() {
  10.         System.out.println( "Octal String: "
  11.                 + Integer.toOctalString( subject.getState() ) );
  12.     }
  14. }

HexaObserver.java

  1. public class HexaObserver extends Observer {
  3.     public HexaObserver(Subject subject){
  4.         this.subject = subject;
  5.         this.subject.attach(this);
  6.     }
  8.     @Override
  9.     public void update() {
  10.         System.out.println( "Hex String: "
  11.                 + Integer.toHexString( subject.getState() ).toUpperCase() );
  12.     }
  14. }

步骤 4

使用 Subject 和实体观察者对象。

ObserverPatternDemo.java

  1. public class ObserverPatternDemo {
  3.     public static void main(String[] args) {
  4.         Subject subject = new Subject();
  6.         new BinaryObserver(subject);
  7.         new HexaObserver(subject);
  8.         new OctalObserver(subject);
  10.         System.out.println("First state change: 15");
  11.         subject.setState(15);
  12.         System.out.println();
  14.         System.out.println("Second state change: 10");
  15.         subject.setState(10);
  16.     }
  18. }

步骤 5

验证输出。

  1. First state change: 15
  2. Binary String: 1111
  3. Hex String: F
  4. Octal String: 17
  6. Second state change: 10
  7. Binary String: 1010
  8. Hex String: A
  9. Octal String: 12

发表评论

表情：
评论列表 （有 0 条评论，669人围观）

还没有评论，来说两句吧...

相关阅读

    相关 观察者模式

    package 观察者模式; / 观察者模式， 理解就是一个状态的改变， 监视他的人就会给出不同的反应和业务

    清疚清疚/ 0 赞/ 100 阅读

    相关 观察者模式

    观察者模式 Observer 　　观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。 　　这个主题对象在状态上发生变化时，会通知所有观察者对

    梦里梦外;梦里梦外;/ 0 赞/ 115 阅读

    相关 观察者模式

    什么是观察者模式 有人这么说 > 观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。 > > 这个主题对象在状态上发生变化时，会通知所有观

    梦里梦外;梦里梦外;/ 0 赞/ 362 阅读

    相关 观察者模式

    场景描述：  一个气象站应用，可以实时获取温度、湿度和气压信息，气象站提供一个封装好的类WeatherData，该类有最新的气象信息，当这些信息发生变动的时候，类中的meas

    叁歲伎倆叁歲伎倆/ 0 赞/ 256 阅读

    相关 观察者模式

    观察者模式：定义了对象之间的一对多的依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。 观察者模式图： ![输入图片说明][13105107_Mf

    旧城等待，旧城等待，/ 0 赞/ 352 阅读

    相关 观察者模式

    什么是观察者模式？ 简单的来说，观察者模式=出版者+订阅者。用比较书面的话来说的话是：定义了对象之间的一对多依赖，当一所对应的对象状态改变时，它的所有依赖者都会收到通知并

    你的名字你的名字/ 0 赞/ 481 阅读

    相关 观察者模式

    当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。 意图：定义对象

    系统管理员系统管理员/ 0 赞/ 579 阅读

    相关 观察者模式

    对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。 介绍 ...

    小灰灰小灰灰/ 0 赞/ 669 阅读