Java 设计模式——观察者模式

目录

  • 1.概述
  • 2.结构
  • 3.案例实现
    • 3.1.抽象观察者
    • 3.2.观察对象
    • 3.3.具体观察者
    • 3.4.具体观察对象
    • 3.5.测试
  • 4.优缺点
  • 5.使用场景
  • 6.JDK 源码解析——Observable / Observer
    • 6.1.Observable 类
    • 6.2.Observer 接口
    • 6.3.案例

1.概述

观察者模式 (Observer Pattern) 是一种行为型设计模式,又被称为发布-订阅 (Publish/Subscribe) 模式,它定义了对象之间的一种一对多的依赖关系,使得当一个对象的状态发生变化时,所有依赖于它的对象都会自动收到通知并更新

2.结构

在观察者模式中有如下角色:

  • Subject:观察对象,定义了注册观察者和删除观察者的方法。此外,它还声明了“获取现在的状态”的方法。
  • ConcreteSubject:具体观察对象,当自身状态发生变化后,它会通知所有已经注册的 Observer 角色。
  • Observer:抽象观察者,负责接收来自 Subject 角色的状态变化的通知,为此,它声明了 update 方法。
  • ConcrereObserver:具体观察者,当它的 update 方法被调用后,会去获取要观察的对象的最新状态。

3.案例实现

【例】微信公众号。在使用微信公众号时,大家都会有这样的体验,当你关注的公众号中有新内容更新的话,它就会推送给关注公众号的微信用户端。我们使用观察者模式来模拟这样的场景,微信用户就是观察者,微信公众号是观察对象,有多个的微信用户关注了程序猿这个公众号。 具体类图如下:
在这里插入图片描述
具体实现代码如下:

3.1.抽象观察者

Observer.java

public interface Observer {
    void update(String message);
}

3.2.观察对象

Subject.java

//观察对象
public interface Subject {
    
    //添加订阅者(观察者对象)
    void attach(Observer observer);
    
    //删除订阅者
    void detach(Observer observer);
    
    //通知订阅者更新消息
    void notify(String message);
}

3.3.具体观察者

WeiXinObserver.java

//具体的观察者角色类
public class WeiXinObserver implements Observer{
    
    private String name;
    
    public WeiXinObserver(String name) {
        this.name = name;
    }
    
    @Override
    public void update(String message) {
        System.out.println(name + " : " + message);
    }
}

3.4.具体观察对象

SubscriptionSubject.java

import java.util.ArrayList;
import java.util.List;

//具体主题角色类
public class SubscriptionSubject implements Subject{
    
    //定义一个集合,用来存储多个观察者对象
    private List<Observer> weiXinUserList = new ArrayList<>();
    
    @Override
    public void attach(Observer observer) {
        weiXinUserList.add(observer);
    }
    
    @Override
    public void detach(Observer observer) {
        weiXinUserList.remove(observer);
    }
    
    @Override
    public void notify(String message) {
        //遍历集合
        for (Observer observer : weiXinUserList) {
            //调用观察者对象中的 update 方法
            observer.update(message);
        }
    }
}

3.5.测试

Client.java

public class Client {
    public static void main(String[] args) {
        //1.创建公众号对象
        SubscriptionSubject subject = new SubscriptionSubject();
        
        //2.订阅公众号
        subject.attach(new WeiXinObserver("Tom"));
        subject.attach(new WeiXinObserver("Mike"));
        subject.attach(new WeiXinObserver("Jerry"));
        
        //3.公众号更新
        subject.notify("Java专栏更新了!");
    }
}

4.优缺点

(1)优点

  • 解耦性:观察者模式将观察者和主题(被观察者)解耦,使得它们之间的依赖关系变得松散。主题只需要知道观察者的抽象接口,而不需要知道具体的观察者对象。
  • 可扩展性:通过新增或删除观察者,可以方便地扩展系统的功能。主题可以随时添加或删除观察者,而不会影响到其他部分的代码。
  • 广播通信:主题通知所有的观察者对象,实现事件的广播通信,方便多个对象对事件做出响应。
  • 符合开闭原则:新增观察者时无需修改主题的代码,只需实现新的观察者接口即可,符合开闭原则的要求。

(2)缺点

  • 观察者过多可能导致性能问题:如果观察者过多,或者通知频繁,可能会导致系统性能下降。因此在设计时需注意对观察者的控制。
  • 观察者和主题关系不明确:观察者模式中的观察者和主题之间的关系是松散的,观察者无法准确知道有哪些其他观察者存在。可能存在一些潜在的问题和维护的困难。

5.使用场景

(1)观察者模式适用于以下场景:

  • 发布-订阅模型:当存在一个主题(或发布者)需要通知多个观察者(或订阅者)并进行相应的处理时,可以使用观察者模式。例如,新闻发布机构将新闻发布给多个订阅者。
  • UI 事件处理:在图形用户界面 (GUI) 开发中,观察者模式常用于处理用户界面上的事件。用户操作(如按钮点击、文本框输入等)可以作为主题,而界面元素的更新则可以作为观察者来处理。
  • 实时数据更新:当需要将实时数据的更新通知给多个组件或模块时,可以使用观察者模式。例如,股票交易系统中,股票价格的变化可以作为主题,而界面上的多个组件可以作为观察者。
  • 消息队列系统:在消息队列系统中,观察者模式可以用于消息的发布和订阅的机制。生产者发布消息到主题中,而消费者作为观察者订阅主题,在消息到达时进行相应的处理。
  • MVC 架构:观察者模式常用于应用程序的 MVC(模型-视图-控制器)架构中,用于实现模型与视图之间的通信。当模型的状态发生变化时,观察者模式可以通知相关的视图来刷新界面。
  • 多线程编程中的消息通知:在多线程编程中,观察者模式可以用于实现线程间的消息通知机制。一个线程可以作为主题,而其他线程可以作为观察者,通过观察者模式实现线程间的协同工作。

(2)总之,观察者模式适用于需要一对多的依赖关系,并且对观察者和被观察者之间的耦合度要求较低的场景。它常用于发布-订阅模型、UI 事件处理、实时数据更新、消息队列系统、MVC 架构等应用场景。

6.JDK 源码解析——Observable / Observer

在 Java 中,通过 java.util.Observable 类java.util.Observer 接口定义了观察者模式,只要实现它们的子类就可以编写观察者模式实例。

6.1.Observable 类

其源码如下:

package java.util;

public class Observable {
	/*
		changed 为一个 boolean 类型的内部标志,注明目标对象是否发生了变化
		当它为 true 时,notifyObservers() 才会通知观察者
	*/
    private boolean changed = false;
    //存储所有的观察者对象
    private Vector<Observer> obs;

    public Observable() {
        obs = new Vector<>();
    }

	//用于将新的观察者对象添加到集合中
    public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
        if (!obs.contains(o)) {
            obs.addElement(o);
        }
    }

    //从集合中删除一个观察者
    public synchronized void deleteObserver(Observer o) {
        obs.removeElement(o);
    }

    public void notifyObservers() {
        notifyObservers(null);
    }

    public void notifyObservers(Object arg) {      
        Object[] arrLocal;

        synchronized (this) {         
            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }
		
        for (int i = arrLocal.length-1; i>=0; i--)
        	//逆序通知集合中的观察者更新消息
            ((Observer)arrLocal[i]).update(this, arg);
    }

    //删除所集合中所有的观察者
    public synchronized void deleteObservers() {
        obs.removeAllElements();
    }

    protected synchronized void setChanged() {
        changed = true;
    }

    protected synchronized void clearChanged() {
        changed = false;
    }

    public synchronized boolean hasChanged() {
        return changed;
    }

    //返回集合中观察者的数量
    public synchronized int countObservers() {
        return obs.size();
    }
}

6.2.Observer 接口

Observer 接口是抽象观察者,它监视目标对象的变化,当目标对象发生变化时,观察者得到通知,并调用 update() 方法,进行相应的工作。其源码如下:

package java.util;

public interface Observer {
    /**
     * This method is called whenever the observed object is changed. An
     * application calls an Observable object's
     * notifyObservers method to have all the object's
     * observers notified of the change.
     *
     * @param   o     the observable object.
     * @param   arg   an argument passed to the notifyObservers
     *                 method.
     */
    void update(Observable o, Object arg);
}

6.3.案例

【例】警察抓小偷。警察抓小偷也可以使用观察者模式来实现,警察是观察者,小偷是被观察者。代码如下:

(1)小偷是一个被观察者,所以需要继承 Observable 类

import java.util.Observable;

public class Thief extends Observable {
    private String name; public Thief(String name) {
        this.name = name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void steal() {
        System.out.println("小偷:我偷东西了,有没有人来抓我!!!");
        super.setChanged();  //即令changed = true
        super.notifyObservers();
    }
}

(2)警察是一个观察者,所以需要让其实现 Observer 接口

import java.util.Observable;
import java.util.Observer;

public class Policemen implements Observer {
    
    private String name;
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public Policemen(String name) {
        this.name = name;
    }
    
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("警察:" + ((Thief) o).getName() + ",我已经盯你很久了,你可以保持沉默,但你所说的将成为呈堂证供!!!");
    }
}
public class Client {
    public static void main(String[] args) {
        //创建小偷对象
        Thief t = new Thief("小偷");
        //创建警察对象
        Policemen p = new Policemen("小李");
        //让警察盯着小偷
        t.addObserver(p);
        //小偷偷东西
        t.steal();
    }
}

结果如下:

小偷:我偷东西了,有没有人来抓我!!!
警察:小偷,我已经盯你很久了,你可以保持沉默,但你所说的将成为呈堂证供!!!

你可能感兴趣的:(Java,设计模式,Java,观察者模式,设计模式)