[设计模式] 设计模式课程（四）-- 观察者模式

场景

• Observer / Event，属于“组件协作”模式，解决了框架和应用的协作问题
• 在软件构建过程中，需要为某些对象建立一种“通知--依赖关系”
• 对象间存在一对多的依赖关系，当一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知并自动更新
• 使用面向对象技术，可将这种依赖关系弱化，形成一种稳定的依赖关系，降低软件体系的耦合

结构

• 发布者类（Publisher）：向其他对象发送值得关注的事件，事件在发布者自身状态改变或执行特定行为后发生
• 订阅者接口（Subscriber）：声明了通知接口
• 具体订阅者：可执行一些操作来回应发布者的通知
• 客户端：创建发布者和订阅者对象

实现

• 将业务逻辑拆分为两部分，独立于其他代码的核心功能作为发布者，其他代码作为订阅类
• 声明订阅者接口，接口至少声明一个update方法
• 声明发布者接口并定义一些接口在列表中添加和删除订阅对象，发布者仅通过订阅者接口与他们进行交互
• 确定存放实际订阅表的位置，实现订阅方法
• 创建具体发布者类
• 在具体订阅者类中实现通知更新的方法，通过通知方法的参数传递订阅者需要的上下文数据
• 在客户端生成所需的全部订阅者，并在发布者处完成注册工作

场景

• 定义对象间的一对多关系，一个对象发生改变时，所有依赖它的对象都得到通知并被自动更新

示例1

MainForm1.cpp

class MainForm : public Form
{
    TextBox* txtFilePath;
    TextBox* txtFileNumber;
    ProgressBar* progressBar;

public:
    void Button1_Click(){

        string filePath = txtFilePath->getText();
        int number = atoi(txtFileNumber->getText().c_str());

        FileSplitter splitter(filePath, number, progressBar);

        splitter.split();

    }
};

FileSplitter1.cpp

class FileSplitter
{
    string m_filePath;
    int m_fileNumber;
    ProgressBar* m_progressBar;

public:
    FileSplitter(const string& filePath, int fileNumber, ProgressBar* progressBar) :
        m_filePath(filePath), 
        m_fileNumber(fileNumber),
        m_progressBar(progressBar){
    }

    void split(){

        //1.读取大文件

        //2.分批次向小文件中写入
        for (int i = 0; i < m_fileNumber; i++){
            //...
            float progressValue = m_fileNumber;
            progressValue = (i + 1) / progressValue;
            m_progressBar->setValue(progressValue);
        }

    }
};

• 文件分割器程序，对于大文件，需要进度条显示分割进度
• MainForm1中收集用户输入的两个参数，传递给FIleSplitter1
• 问题：违反了依赖倒置原则。实现（FileSplitter）依赖细节（ProgressBar），而细节是容易变化的（比如后期改用一个Label展示进度，或在Linux平台没有图形界面，用...表示进度）
• 依赖：指编译层面的依赖（A依赖B，A编译的时候需要B才能编译通过）
• 不要依赖细节，而是依赖它的抽象
• ProgressBar是一个具体通知控件，是否可用抽象方式（接口 IProgress）表示

MainForm2.cpp

class MainForm : public Form, public IProgress
{
    TextBox* txtFilePath;
    TextBox* txtFileNumber;

    ProgressBar* progressBar;

public:
    void Button1_Click(){

        string filePath = txtFilePath->getText();
        int number = atoi(txtFileNumber->getText().c_str());

        ConsoleNotifier cn;

        FileSplitter splitter(filePath, number);

        splitter.addIProgress(this); //订阅通知
        splitter.addIProgress(&cn)； //订阅通知

        splitter.split();

        splitter.removeIProgress(this);

    }

    virtual void DoProgress(float value){
        progressBar->setValue(value);
    }
};

class ConsoleNotifier : public IProgress {
public:
    virtual void DoProgress(float value){
        cout << ".";
    }
};

FileSplitter2.cpp

class IProgress{
public:
    virtual void DoProgress(float value)=0;
    virtual ~IProgress(){}
};

class FileSplitter
{
    string m_filePath;
    int m_fileNumber;

    List<IProgress*>  m_iprogressList; // 抽象通知机制，支持多个观察者
    
public:
    FileSplitter(const string& filePath, int fileNumber) :
        m_filePath(filePath), 
        m_fileNumber(fileNumber){

    }

    void split(){

        //1.读取大文件

        //2.分批次向小文件中写入
        for (int i = 0; i < m_fileNumber; i++){
            //...

            float progressValue = m_fileNumber;
            progressValue = (i + 1) / progressValue;
            onProgress(progressValue);//发送通知
        }

    }


    void addIProgress(IProgress* iprogress){
        m_iprogressList.push_back(iprogress);
    }

    void removeIProgress(IProgress* iprogress){
        m_iprogressList.remove(iprogress);
    }

protected:
    virtual void onProgress(float value){
        
        List<IProgress*>::iterator itor=m_iprogressList.begin();

        while (itor != m_iprogressList.end() )
            (*itor)->DoProgress(value); //更新进度条
            itor++;
        }
    }
};

• 添加抽象基类IProgress，由原先具体的通知控件变为抽象的通知机制
• c++支持多继承，但会导致耦合性问题，一般不推荐使用
• 只有推荐在一种情况下用，即父类中一个是主继承类（Form），其他都是接口或抽象基类（IProgress）
• 重构后，FileSplitter类不再耦合界面类（ProgressBar），实现了独立编译，符合了依赖倒置原则
• 将来可以放在Windows界面，或Linux界面运行，进度通知功能依赖抽象的IProgress完成
• 形式上，DoProgress()从FileSplitter1.cpp的23行，挪到了MainForm2.cpp的28行
• 利用容器，支持多个观察者（命令行，GUI等），FileSplitter 类构造函数的写法发生变化，并增加相应addIProgress()，removeIProgress()，改写onProgress()支持容器，在MainForm中增加订阅通知操作
• 观察者自己决定是否订阅通知（MainForm2 18-19），目标对象对此一无所知

• Subject和ConcreteSubject相当于FileSplitter（目标对象），Attach()相当于addIProgress()，Notify()相当于onProgress()
• Observer相当于IProgress（抽象观察者），Update相当于DoProgress()
• ConcreteObserver相当于MainForm和ConsoleNotifier（具体观察者）
• Subject和Observer是稳定的，ConcreteSubject和ConcreteObserver是变动的
• Observer模式使我们可以独立地改变目标与观察者，从而使二者的依赖关系为松耦合
• 目标发送通知时，无需指定观察者，通知会自动传播（不知道谁是观察者）
• Observer 模式是基于事件UI框架中非常常用的模式，是MVC模式的重要组成部分

• 重构过程
  • ProgressBar* m_progressBar; // 具体通知控件
  • IProgress* m_iprogress; // 抽象通知机制
  • List<IProgress*>  m_iprogressList; // 支持多个观察者

示例2

// 发布者基类包含订阅管理代码和通知方法。
class EventManager is
    private field listeners: hash map of event types and listeners

    method subscribe(eventType, listener) is
        listeners.add(eventType, listener)

    method unsubscribe(eventType, listener) is
        listeners.remove(eventType, listener)

    method notify(eventType, data) is
        foreach (listener in listeners.of(eventType)) do
            listener.update(data)

// 具体发布者包含一些订阅者感兴趣的实际业务逻辑。我们可以从发布者基类中扩
// 展出该类，但在实际情况下并不总能做到，因为具体发布者可能已经是子类了。
// 在这种情况下，你可用组合来修补订阅逻辑，就像我们在这里做的一样。
class Editor is
    public field events: EventManager
    private field file: File

    constructor Editor() is
        events = new EventManager()

    // 业务逻辑的方法可将变化通知给订阅者。
    method openFile(path) is
        this.file = new File(path)
        events.notify("open", file.name)

    method saveFile() is
        file.write()
        events.notify("save", file.name)

    // ...


// 这里是订阅者接口。如果你的编程语言支持函数类型，则可用一组函数来代替整
// 个订阅者的层次结构。
interface EventListener is
    method update(filename)

// 具体订阅者会对其注册的发布者所发出的更新消息做出响应。
class LoggingListener implements EventListener is
    private field log: File
    private field message

    constructor LoggingListener(log_filename, message) is
        this.log = new File(log_filename)
        this.message = message

    method update(filename) is
        log.write(replace('%s',filename,message))

class EmailAlertsListener implements EventListener is
    private field email: string

    constructor EmailAlertsListener(email, message) is
        this.email = email
        this.message = message

    method update(filename) is
        system.email(email, replace('%s',filename,message))


// 应用程序可在运行时配置发布者和订阅者。
class Application is
    method config() is
        editor = new TextEditor()

        logger = new LoggingListener(
            "/path/to/log.txt",
            "有人打开了文件：%s");
        editor.events.subscribe("open", logger)

        emailAlerts = new EmailAlertsListener(
            "admin@example.com",
            "有人更改了文件：%s")
        editor.events.subscribe("save", emailAlerts)

示例3

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

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

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

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

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

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

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

参考

观察者模式(Observer)解析例子

https://blog.51cto.com/tianli/40455