java设计模式学习之【观察者模式】

news2024/11/27 8:32:17

文章目录

引言
观察者模式简介
- 定义与用途
- 实现方式
使用场景
优势与劣势
在Spring框架中的应用
观察者示例
代码地址

引言

想象你在一个在线拍卖会上竞标一件珍贵的艺术品。每当有人出价更高，系统都会立即通知你。这个实时更新机制使你可以做出快速反应。这种模式，在软件开发中称为观察者模式，是一种广泛应用于实现事件驱动系统的设计模式。

观察者模式简介

定义与用途

观察者模式（Observer Pattern）是一种行为型设计模式，它定义了对象间的一种一对多的依赖关系，使得每当一个对象改变状态时，其所有依赖者都会得到通知并自动更新。这种模式用于构建松散耦合的系统，其中一个对象的改变可以影响一个或多个其他对象，而无需对象之间有紧密的关联。

实现方式

实现观察者模式通常涉及以下几个关键组件：

主题（Subject）：持有观察者的列表，并提供添加、删除观察者的接口。
观察者（Observer）：为那些在主题状态发生变化时需获得通知的对象定义一个更新接口。
具体主题（Concrete Subject）：状态发生改变时，向所有注册的观察者发出通知。
具体观察者（Concrete Observer）：实现观察者接口的类，定义当接收到主题通知时如何更新自己。

使用场景

观察者模式适用于以下场景：

当一个对象的改变需要同时改变其他对象，而不知道具体有多少对象待改变时。
当一个对象必须通知其他对象，而它又不能假定其他对象是谁。

例如：

股票市场应用：股票价格更新时，所有关注该股票的投资者都会收到通知。
社交媒体订阅：用户在社交媒体上订阅某个名人或主题，当有更新时用户可以立即收到通知。
电子邮件系统：当新邮件到达时，电子邮件客户端会通知用户。

优势与劣势

优势
- 支持简单的广播通信，解除对象间的紧密耦合。
- 支持实时通知，对象状态改变时，观察者立即得到更新。
劣势
- 如果观察者非常多，通知会花费较多时间。
- 如果观察者和主题之间有循环依赖，可能导致系统崩溃。

在Spring框架中的应用

Spring框架广泛应用了观察者模式，尤其是在事件驱动模型中。以下是一些具体应用：

1. 事件监听
Spring的事件监听机制就是观察者模式的一个例子。当一个事件被触发时，所有监听该事件的监听器都会收到通知。例如，ApplicationContext 发布了各种类型的事件，如 ContextRefreshedEvent，应用中的各个部分可以通过实现 ApplicationListener 来响应这些事件。

2. WebSocket
在Spring中，WebSocket的实现也使用了观察者模式。服务器和客户端之间的通信建立在这种模式上，当一方发送消息时，另一方可以即时接收和响应。

观察者示例

在这里插入图片描述
这个示例展示了观察者模式在Java中的实现。观察者模式是一种行为设计模式，它定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

步骤 1：创建主题类

private List<Observer> observers = new ArrayList<Observer>();
   private int state;

   public int getState() {
      return state;
   }

   public void setState(int state) {
      this.state = state;
      notifyAllObservers();
   }

   public void attach(Observer observer){
      observers.add(observer);		
   }

   public void notifyAllObservers(){
      for (Observer observer : observers) {
         observer.update();
      }
   }

Subject 是持有观察者列表的类，并提供了方法来添加和删除观察者。当它的状态改变时，它会通知所有观察者。

步骤 2：创建观察者类

public abstract class Observer {
   protected Subject subject;
   public abstract void update();
}

Observer 是一个抽象类，为所有具体的观察者定义了一个更新接口。每个具体的观察者都需要实现这个接口。

步骤 3：创建具体的观察者类

public class BinaryObserver extends Observer{

   public BinaryObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }

   @Override
   public void update() {
      System.out.println( "Binary String: " + Integer.toBinaryString( subject.getState() ) ); 
   }
}

BinaryObserver 是一个具体的观察者，它将主题的状态以二进制形式输出。

public class OctalObserver extends Observer{

   public OctalObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }

   @Override
   public void update() {
     System.out.println( "Octal String: " + Integer.toOctalString( subject.getState() ) ); 
   }
}

OctalObserver 是另一个具体的观察者，它将主题的状态以八进制形式输出。

public class HexaObserver extends Observer{

   public HexaObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }

   @Override
   public void update() {
      System.out.println( "Hex String: " + Integer.toHexString( subject.getState() ).toUpperCase() ); 
   }
}

HexaObserver 是第三个具体的观察者，它将主题的状态以十六进制形式输出。

步骤 4：使用主题和具体的观察者对象

public class ObserverPatternDemo {
   public static void main(String[] args) {
      Subject subject = new Subject();

      new HexaObserver(subject);
      new OctalObserver(subject);
      new BinaryObserver(subject);

      System.out.println("第一次状态改变: 15");	
      subject.setState(15);
      System.out.println("第二次状态改变: 10");	
      subject.setState(10);
   }
}