观察者模式

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

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

介绍

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

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

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

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

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

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

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

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

使用场景：

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

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

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

主题（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 篇笔记写笔记

116

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

观察者接口：

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

fatcheung6年前 (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岁,疾病-糖尿病

glory1年前 (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。通过注册观察者、更新状态和通知观察者的过程，实现了主题和观察者之间的交互。

RUNOOB10个月前 (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 篇笔记写笔记