观察者模式

观察者模式是一种行为型设计模式，它定义了一种一对多的依赖关系，当一个对象的状态发生改变时，其所有依赖者都会收到通知并自动更新。

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

介绍

意图

创建了对象间的一种一对多的依赖关系，当一个对象状态改变时，所有依赖于它的对象都会得到通知并自动更新。。

主要解决的问题

观察者模式解决的是一个对象状态改变时，如何自动通知其他依赖对象的问题，同时保持对象间的低耦合和高协作性。

使用场景

当一个对象的状态变化需要同时更新其他对象时。

实现方式

定义观察者接口：包含一个更新方法。
创建具体观察者：实现观察者接口，定义接收到通知时的行为。
定义主题接口：包含添加、删除和通知观察者的方法。
创建具体主题：实现主题接口，管理观察者列表，并在状态改变时通知它们。

关键代码

观察者列表：在主题中维护一个观察者列表。

应用实例

拍卖系统：拍卖师作为主题，竞价者作为观察者，拍卖价格更新时通知所有竞价者。
西游记故事：菩萨洒水作为状态改变，老乌龟作为观察者，观察到这一变化。

优点

抽象耦合：观察者和主题之间是抽象耦合的。
触发机制：建立了一套状态改变时的触发和通知机制。

缺点

性能问题：如果观察者众多，通知过程可能耗时。
循环依赖：可能导致循环调用和系统崩溃。
缺乏变化详情：观察者不知道主题如何变化，只知道变化发生。

使用建议

在需要降低对象间耦合度，并且对象状态变化需要触发其他对象变化时使用。
考虑使用Java内置的观察者模式支持类，如java.util.Observable和java.util.Observer。

注意事项

避免循环引用：注意观察者和主题之间的依赖关系，避免循环引用。
异步执行：考虑使用异步通知避免单点故障导致整个系统卡壳。

结构

观察者模式包含以下几个核心角色：

主题（Subject）：也称为被观察者或可观察者，它是具有状态的对象，并维护着一个观察者列表。主题提供了添加、删除和通知观察者的方法。
观察者（Observer）：观察者是接收主题通知的对象。观察者需要实现一个更新方法，当收到主题的通知时，调用该方法进行更新操作。
具体主题（Concrete Subject）：具体主题是主题的具体实现类。它维护着观察者列表，并在状态发生改变时通知观察者。
具体观察者（Concrete Observer）：具体观察者是观察者的具体实现类。它实现了更新方法，定义了在收到主题通知时需要执行的具体操作。

观察者模式通过将主题和观察者解耦，实现了对象之间的松耦合。当主题的状态发生改变时，所有依赖于它的观察者都会收到通知并进行相应的更新。

实现

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

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

步骤 1

创建 Subject 类。

Subject.java

import java.util.ArrayList; import java.util.List; public class Subject { 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(); } } }

步骤 2

创建 Observer 类。

Observer.java

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

步骤 3

创建实体观察者类。

BinaryObserver.java

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() ) ); } }

OctalObserver.java

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() ) ); } }

HexaObserver.java

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() ); } }

步骤 4

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

ObserverPatternDemo.java

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("First state change: 15"); subject.setState(15); System.out.println("Second state change: 10"); subject.setState(10); } }

步骤 5

执行程序，输出结果：

First state change: 15
Hex String: F
Octal String: 17
Binary String: 1111
Second state change: 10
Hex String: A
Octal String: 12
Binary String: 1010

备忘录模式

状态模式

11 篇笔记写笔记

118

观察者模式，我理解的就是观察者订阅被观察者的状态，当被观察者状态改变的时候会通知所有订阅的观察者的过程。所以以下这种写法会不会更加容易理解一些呢？

观察者接口：

public abstract class Observer {    
    public abstract void update(String msg);
}

第一个观察者：

public class F_Observer extends Observer {
    public void update(String msg) {
        System.out.println(F_Observer.class.getName() + " : " + msg);
    }
}

第二个观察者：

public class S_Observer extends Observer {
    public void update(String msg) {
        System.out.println(S_Observer.class.getName() + " : " + msg);
    }
}

第三个观察者：

public class T_Observer extends Observer {
    public void update(String msg) {
        System.out.println(T_Observer.class.getName() + " : " + msg);
    }
}

被观察者：

public class Subject {        
    private List<Observer> observers = new ArrayList<>();    //状态改变    
    public void setMsg(String msg) {        
        notifyAll(msg);    
    }   
     //订阅    
    public void addAttach(Observer observer) {        
        observers.add(observer);    
    }    
    //通知所有订阅的观察者    
    private void notifyAll(String msg) {        
        for (Observer observer : observers) {            
            observer.update(msg);        
        }   
    }
}

使用方法：

public class Main {    
    public static void main(String[] args) {        
        F_Observer fObserver = new F_Observer();        
        S_Observer sObserver = new S_Observer();        
        T_Observer tObserver = new T_Observer();                
        Subject subject = new Subject();        
        subject.addAttach(fObserver);        
        subject.addAttach(sObserver);        
        subject.addAttach(tObserver);                
        subject.setMsg("msg change");    
    }
}

运行结果： test.F_Observer : msg changetest.S_Observer : msg changetest.T_Observer : msg change

fatcheung7年前 (2018-02-23)

用 C# 实现了示例并优化了一下:

Subject.cs

public class Subject
{
    private readonly List<Observer> _observers = new List<Observer>();

    private int _state;

    public int State
    {
        get => _state;
        set
        {
            _state = value;
            NotifyAllObservers();
        }

    }

    public void AddObserver(Observer observer)
    {
        observer.Subject = this;
        _observers.Add(observer);
    }

    public void NotifyAllObservers() => _observers.ForEach(o => o.Update());
}

Observer.cs

public abstract class Observer
{
    public Subject Subject;
    
    public abstract void Update();
}

BinaryObserver.cs

public class BinaryObserver:Observer
{
    public BinaryObserver()
    {
        
    }
    public BinaryObserver(Subject subject)
    {
        subject.AddObserver(this);
    }
    public override void Update()
    {
        Console.WriteLine($"Binary String: {Convert.ToString(Subject.State, 2)}");
    }
}

OctalObserver.cs

public class OctalObserver:Observer
{
    public OctalObserver()
    {
        
    }
    public OctalObserver(Subject subject)
    {
        subject.AddObserver(this);
    }

    public override void Update()
    {
        Console.WriteLine($"Octal  String: {Convert.ToString(Subject.State, 8)}");
    }
}

HexaObserver.cs

public class HexaObserver:Observer
{
    public HexaObserver()
    {
        
    }
    public HexaObserver(Subject subject)
    {
        subject.AddObserver(this);
    }
    public override void Update()
    {
        Console.WriteLine($"Hex   String: {Convert.ToString(Subject.State, 16)}");
    }
}

Demo.cs

public void NumberChange()
{
    Subject subject1 = new Subject();
    new BinaryObserver(subject1);
    new OctalObserver(subject1);
    new HexaObserver(subject1);
    Console.WriteLine("1 state=15");
    subject1.State = 15;
    Console.WriteLine("1 state=10");
    subject1.State = 10;

    Subject subject2 = new Subject();
    subject2.AddObserver(new BinaryObserver());
    subject2.AddObserver(new OctalObserver());
    subject2.AddObserver(new HexaObserver(subject1));
    Console.WriteLine("2 state=15");
    subject1.State = 15;
    Console.WriteLine("2 state=10");
    subject1.State = 10;
}

DHclly6年前 (2018-08-06)

#0
   jade
  guo***u_study@163.com
20
Observer 模式的定义：该模式定义了对象之间的一对多依赖关系，Subject 对象是一，Observer 对象是多。当 Subject 对象的状态发生改变时，所有依赖于该 Subject 对象的 Observer 对象都会得到通知，并且自动更新。
仔细分析定义，要精确理解观察者模式主要注意三点：
1.定义了对象间的一对多依赖关系；
2.当 Subject 对象的状态发生改变时，所有依赖于该 Subject 对象的 Observer 对象都会得到通知；
3.Observer 对象得到通知后，会自动更新，而不是被动；
其它的所有点都是细枝末节，由具体业务需求来决定。比如：
1. Subject 角色是应该定义成类？比如内置的 java.util.Observable；还是应该定义成接口，以规避Java不支持多重继承的问题？比如《Head First 设计模式》中的推荐作法。
2.应该在什么时候订阅主题（或者说注册观察者）？是实例化观察者对象的同时？比如贴主的示例；还是由客户自主决定？比如此贴的第一篇分享笔记。
3.是否应该实现取消订阅功能（或者说取消注册）？
4.主题对象通知观察者时，是否携带消息？换句话说，是“推”消息？如贴主示例；还是“拉”消息？
5.是否支持多线程？
jade
   jade
  guo***u_study@163.com
6年前 (2018-09-19)

看了上面的代码，用 kotlin 实现了一下：

/**
 * 观察者
 */
interface Observer {
    fun <T : Any?> update(msg: T)
}
 
/**
 * 观察者1,2,3
 */
class Ob1(private val id: Int = 0) : Observer {
    override fun <T> update(msg: T) {
        println("接收消息，观察者$id:$msg")
    }
}
//这里是kotlin的类委托
class Ob2 : Observer by Ob1(2)
class Ob3 : Observer by Ob1(3)
 
/**
 * 被观察者（订阅者）
 */
class Subject {
 
    //存放观察者
    private  var observers =  ArrayList<Observer>()
    //订阅观察者
    fun attach(ob: Observer) {
        observers.add(ob)
    }
    //设置数据
    fun <T : Any?> setMsg(msg: T) {
        this.notify(msg)
    }
    //更新数据
    private fun <T : Any?> notify(msg: T) {
        for (iOb in this.observers) {
            iOb.update(msg)
        }
    }
}
 
/**
 * Kotlin版 观察者模式
 * @author IWH
 * Des：kotlin1.3支持主函数省略参数
 */
fun main() {
 
    val sub = Subject().apply {
        attach(Ob1())
        attach(Ob2())
        attach(Ob3())
    }
    with(sub){
        setMsg(123)
        setMsg("hello world")
        setMsg('A')
        setMsg(null)
    }
}

iwh冬5年前 (2019-04-11)

观音洒水

public class TortoisObserverDemo {
    public static void main(String[] args){
        GuanYin guanYin = new GuanYin();

        new SmallTortoise(guanYin);
        new BigTortoise(guanYin);

        guanYin.watering();
    }
}



public class GuanYin {
    private List<Observer> observers = new ArrayList<Observer>();

    public void watering(){
        System.out.println("观音洒水");
        notifyAllTortoise();
    }

    private void notifyAllTortoise() {
        int i = 0;
        for (Observer o:observers) {
            o.flyToGuanYin();
            System.out.println(++i);
        }
    }

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


public abstract class Observer {
    protected GuanYin guanYin;
    protected abstract void flyToGuanYin();
}



public class SmallTortoise extends Observer {

    public SmallTortoise(GuanYin guanYin) {
        this.guanYin = guanYin;
        this.guanYin.attach(this);
    }

    @Override
    protected void flyToGuanYin() {
        System.out.println("SmallTortoise fly to guanyin");
    }
}




public class BigTortoise extends Observer {

    public BigTortoise(GuanYin guanYin) {
        this.guanYin = guanYin;
        this.guanYin.attach(this);
    }

    @Override
    protected void flyToGuanYin() {
        System.out.println("BigTortoise fly to guanyin");
    }
}

shenshaonian5年前 (2019-05-17)

利用JDK实现观察者模式，在一对多中，一方代码：

import java.util.Observable;

public class Subject extends Observable {
    private int state;

    public int getState() {
        return state;
    }

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

多方代码：

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

public class BinaryObserver implements Observer {
    public BinaryObserver(Observable observable) {
        observable.addObserver(this);
    }

    @Override
    public void update(Observable o, Object arg) {
        if (o instanceof Subject) {
            System.out.println("Binary String: " + Integer.toBinaryString(((Subject) o).getState()));
        }
    }
}

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

public class HexaObserver implements Observer {
    public HexaObserver(Observable observable) {
        observable.addObserver(this);
    }

    @Override
    public void update(Observable o, Object arg) {
        if (o instanceof Subject) {
            System.out.println("Binary String: " + Integer.toHexString(((Subject) o).getState()));
        }
    }
}

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

public class OctalObserver implements Observer {
    public OctalObserver(Observable observable) {
        observable.addObserver(this);
    }

    @Override
    public void update(Observable o, Object arg) {
        if (o instanceof Subject) {
            System.out.println("Binary String: " + Integer.toOctalString(((Subject) o).getState()));
        }
    }
}

运行测试类：

public class ObserverPatternDemo {
    public static void main(String[] args) {
        Subject subject = new Subject();
        new BinaryObserver(subject);
        new OctalObserver(subject);
        new HexaObserver(subject);
        System.out.println("First state change: 15");
        subject.setState(15);
        System.out.println("Second state change: 10");
        subject.setState(10);
    }
}

运行结果：

First state change: 15
Binary String: f
Binary String: 17
Binary String: 1111
Second state change: 10
Binary String: a
Binary String: 12
Binary String: 1010

郭艺宾5年前 (2019-06-28)

#0
   infiniteH
  212***971@qq.com
10
被观察对象与观察者对象
一个被观察对象关联多个观察者对象
所以，被观察对象有个容器，去存储观察者对象
观察者对象也有一个被观察对象的成员变量
当被观察对象的某个属性发生改变，想让所以与之关联的观察者对象作出响应，就在改变属性的方法中，调用通知方法，所以需要声明一个通知方法，就是遍历所有观察者，调用一个观察者都有的方法，也就是update更新方法。
本质就是在更改某个属性后，遍历所有元素的某个方法，其实也就是多态
infiniteH
   infiniteH
  212***971@qq.com
4年前 (2020-02-29)

Python 方式：

# Observer Pattern with Python Code
from abc import abstractmethod,ABCMeta

# 创建一个目标对象Subject，如果有多种不同的目标，可以抽象subject，用子对象实现
class Subject:
    # 建立一个私有集合，存放观察者对象
    _observers = []
    _state = ""
    def getState(self):
        return self._state
    def setState(self,inState):
        self._state = inState
        self.notifyAllObservers()
    # 追加观察者
    def attach(self, inObserver):
        self._observers.append(inObserver)
    # 通知观察者
    def notifyAllObservers(self):
        for aObser in self._observers :
            aObser.update()

# 创建观察者抽象类
class Observer(metaclass=ABCMeta):
    subject = Subject()
    @abstractmethod
    def update(self):
        pass
    def __init__(self):
        self.subject = Subject()

# 实现具体观察者
class BinaryObserver(Observer):
    def __init__(self,inSubject):
        self.subject = inSubject
        self.subject.attach(self)
    def update(self):
        print("Binary String : " + str(bin(self.subject.getState())))
class OctalObserver(Observer):
    def __init__(self,inSubject):
        self.subject = inSubject
        self.subject.attach(self)
    def update(self):
        print("Octal String : " + str(oct(self.subject.getState())))
class HexaObserver(Observer):
    def __init__(self,inSubject):
        self.subject = inSubject
        self.subject.attach(self)
    def update(self):
        print("Hex String : " + str(hex(self.subject.getState())))

# 调用输出
if __name__ == '__main__':
    aSubject = Subject()

    HexaObserver(aSubject)
    OctalObserver(aSubject)
    BinaryObserver(aSubject)

    print("First state change : 15")
    aSubject.setState(15);
    print("======================")
    print("First state change : 10")
    aSubject.setState(10);

Siskin.xu4年前 (2020-02-29)

你的观察者和被观察者有组合关系不好，可以改成依赖关系：

public  class Subject {    
   private List observers = new ArrayList();   
      public void addObserver(Observer observer){       
      observers.add(observer);  
      }  
      protected void notifyObservers(){ 
      for (Observer o:observers){      
         o.update(this);    
      }    
   }
}
public abstract class Observer {    
   private Action action;    
   /**     * subject 观察谁 ,action 发生变化做什么     */    
   public  void observe(E subject,Action action){        
      subject.addObserver(this);        
      this.action=action;    
   }    
   public void update(Subject subject){        
      this.action.update(subject);    
   }    
   public interface Action{        
      void update(E subject);    
   }
}
public class Patient extends Subject {    
   private int age;    
   private String disease;    
   public Patient(int age, String disease) {        
      this.age = age;        
      this.disease = disease;    
   }    
   public void setAge(int age) {        
      this.age = age;        
      this.notifyObservers();    
   }    
   public void setDisease(String disease) {        
      this.disease = disease;        
      this.notifyObservers();    
   }    
   public int getAge() {        
      return age;    
   }    
   public String getDisease() {        
      return disease;    
   }
}
public class Doctor extends Observer {}
public class Test {    
   public static void main(String[] args) {        
      Patient patient = new Patient(10,"高血压");        
      new Doctor().observe(patient,
         (subject)-> System.out.println("医生观察到患者变化：年龄-"+subject.getAge()+"岁,疾病-"+subject.getDisease()) );        
      new Nurse().observe(patient,                
         (subject)-> System.out.println("护士观察到患者变化：年龄-"+subject.getAge()+"岁,疾病-"+subject.getDisease()));        
      System.out.println("============变化1========");        
      patient.setAge(20);        
      System.out.println("============变化2========");        
      patient.setDisease("糖尿病");    
   }
}
public class Nurse extends Observer {}

输出结果：

============变化1========
医生观察到患者变化：年龄-20岁,疾病-高血压
护士观察到患者变化：年龄-20岁,疾病-高血压
============变化2========
医生观察到患者变化：年龄-20岁,疾病-糖尿病
护士观察到患者变化：年龄-20岁,疾病-糖尿病

glory2年前 (2022-11-04)

这样写好像更容易理解。

public class Subject {
   private List observers = new ArrayList();
   private int state;

   public int getState() {
      return state;
   }

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

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

   public void notifyAllObservers() {
      for (Observer observer : observers) {
         observer.update(this);
      }
   }
} 
public abstract class Observer {
   public abstract void update(Subject subject);
} 
   
public class HexaObserver extends Observer{

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

} 
   
public class ObserverPatternDemo {

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

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

      System.out.println("First state change: 15");
      subject.setState(15);
      subject.notifyAllObservers();
      System.out.println("Second state change: 10");
      subject.setState(10);
      subject.notifyAllObservers();
   }

}

失业1年前 (2023-02-17)

观察者模式可以实现松耦合，使得主题和观察者之间的关系更加灵活。它可以方便地添加新的观察者，以及在运行时动态地增加、删除或修改观察者。同时，观察者模式符合开闭原则，使得主题和观察者可以独立变化，而不会相互影响。

下面是一个简单的观察者模式示例，假设有一个天气监测系统，主题是天气数据，观察者是不同的显示设备，它们实时显示天气数据的变化：

// 主题 - 天气数据
interface WeatherData {
    void registerObserver(WeatherObserver observer);
    void removeObserver(WeatherObserver observer);
    void notifyObservers();
}

// 观察者 - 显示设备
interface WeatherObserver {
    void update(float temperature, float humidity, float pressure);
}

// 具体主题 - 天气数据
class WeatherStation implements WeatherData {
    private List<WeatherObserver> observers;
    private float temperature;
    private float humidity;
    private float pressure;

    public WeatherStation() {
        this.observers = new ArrayList<>();
    }

    public void registerObserver(WeatherObserver observer) {
        observers.add(observer);
    }

    public void removeObserver(WeatherObserver observer) {
        observers.remove(observer);
    }

    public void notifyObservers() {
        for (WeatherObserver observer : observers) {
            observer.update(temperature, humidity, pressure);
        }
    }

    public void setMeasurements(float temperature, float humidity, float pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
        notifyObservers();
    }
}

// 具体观察者 - 显示设备
class DisplayDevice implements WeatherObserver {
    private String name;

    public DisplayDevice(String name) {
        this.name = name;
    }

    public void update(float temperature, float humidity, float pressure) {
        System.out.println(name + " - Temperature: " + temperature +
                " Humidity: " + humidity + " Pressure: " + pressure);
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        WeatherStation weatherStation = new WeatherStation();

        DisplayDevice display1 = new DisplayDevice("Display 1");
        DisplayDevice display2 = new DisplayDevice("Display 2");

        weatherStation.registerObserver(display1);
        weatherStation.registerObserver(display2);

        weatherStation.setMeasurements(25.5f, 65.2f, 1013.2f);
        // Output:
        // Display 1 - Temperature: 25.5 Humidity: 65.2 Pressure: 1013.2
        // Display 2 - Temperature: 25.5 Humidity: 65.2 Pressure: 1013.2

        weatherStation.removeObserver(display2);

        weatherStation.setMeasurements(27.8f, 62.8f, 1010.5f);
        // Output:
        // Display 1 - Temperature: 27.8 Humidity: 62.8 Pressure: 1010.5
    }
}

在上面的示例中，我们定义了主题接口 WeatherData 和观察者接口 WeatherObserver，具体主题类 WeatherStation 和具体观察者类 DisplayDevice。通过注册观察者、更新状态和通知观察者的过程，实现了主题和观察者之间的交互。

RUNOOB1年前 (2023-07-11)

菜鸟教程 -- 学的不仅是技术，更是梦想！

设计模式其他

观察者模式

介绍

意图

主要解决的问题

使用场景

实现方式

关键代码

应用实例

优点

缺点

使用建议

注意事项

结构

实现

步骤 1

Subject.java

步骤 2

Observer.java

步骤 3

BinaryObserver.java

OctalObserver.java

HexaObserver.java

步骤 4

ObserverPatternDemo.java

步骤 5

11 篇笔记写笔记

点我分享笔记

菜鸟教程 -- 学的不仅是技术，更是梦想！

设计模式其他

观察者模式

介绍

意图

主要解决的问题

使用场景

实现方式

关键代码

应用实例

优点

缺点

使用建议

注意事项

结构

实现

步骤 1

Subject.java

步骤 2

Observer.java

步骤 3

BinaryObserver.java

OctalObserver.java

HexaObserver.java

步骤 4

ObserverPatternDemo.java

步骤 5

11 篇笔记 写笔记

点我分享笔记

微信关注

11 篇笔记写笔记