设计模式 -- Observer（观察者模式）

在软件构建的过程中，我们需要为某些对象建立一种“通知依赖关系”——一个对象（目标对象）的状态发生改变，其他对象（观察者对象）都将得到通知。如果这样的依赖关系过于紧密，将使得软件不能很好的抵御变化。
使用面向对象技术，可以将这种依赖关系弱化，并形成一种稳定的依赖关系。从而实现软件体系结构的松耦合。

原先

示例是一个文件分割器类、假定在Main中T1方法在执行分割文件、而滚动条类在其他线程执行show显示进度。

// 一个滚动条类
class ProgressBar {
    // 滚动条进度
    private Integer value;

    // 设置滚动条进制
    void setValue(Integer value) {
        this.value = value;
    }

    // 滚动条显示
    void show() {}
}

class FileSplitter {
    // 文件路径
    private String filePath;
    // 分割文件数量
    private Integer fileNumber;
    // 滚动条
    private ProgressBar progressBar;

    FileSplitter(String filePath, Integer fileNumber, ProgressBar progressBar) {
        this.filePath = filePath;
        this.fileNumber = fileNumber;
        this.progressBar = progressBar;
    }

    void split(){

        //1.读取大文件

        //2.分批次向小文件中写入
        for (int i = 0; i < fileNumber; i++){
            // 具体步骤省略...

            // 写入滚动条值
            progressBar.setValue(i);
        }
    }
}

public class Main {
    // 滚动条类
    private ProgressBar progressBar = new ProgressBar();

    // 文件分割器类
    private FileSplitter fileSplitter = new FileSplitter("./test.txt", 10, progressBar);

    @Test
    public void T1() {
        // 执行分割
        fileSplitter.split();
    }
}

以上类中、文件分割器类大致上是稳定的、不怎么需要变更、而滚动条则是变化的、有时需要更换样式等、或者添加多个滚动条、这里面的更改的话耦合度很高、因而使用观察者模式、利用多态性解耦。

重构

在文件分割器类上添加一个集合、集合里面是滚动条相关的接口、这样就利用了多态性来解决解耦的问题。

interface ProgressBarInterface {
    // 将滚动条值传入、实现类在进行相应的操作
    void DoProgress(Integer value);
}

// 一个滚动条类
class ProgressBar1 implements ProgressBarInterface{
    @Override
    public void DoProgress(Integer value) {
        // ...
    }
}

// 第二个滚动条类、不同样式
class ProgressBar2 implements ProgressBarInterface{
    @Override
    public void DoProgress(Integer value) {
        // ...
    }
}

class FileSplitter {
    // 文件路径
    private String filePath;
    // 分割文件数量
    private Integer fileNumber;
    // 滚动条接口集合
    private List<ProgressBarInterface> progressBars;

    FileSplitter(String filePath, Integer fileNumber) {
        this.filePath = filePath;
        this.fileNumber = fileNumber;
        this.progressBars = new ArrayList<>();
    }

    // 添加滚动条到滚动条接口集合中
    public boolean addProgressBar(ProgressBarInterface progressBar) {
        return progressBars.add(progressBar);
    }

    public void split(){
        //1.读取大文件

        //2.分批次向小文件中写入
        for (int i = 0; i < fileNumber; i++){
            // 具体步骤省略...

            // 写入滚动条值、通知滚动条集合
            onProgress(i);
        }
    }

    protected void onProgress(Integer value) {
        for (ProgressBarInterface progressBar : progressBars) {
            progressBar.DoProgress(value);
        }
    }
}

public class Main {
    // 滚动条类
    private ProgressBar1 progressBar1 = new ProgressBar1();
    private ProgressBar2 progressBar2 = new ProgressBar2();

    // 文件分割器类
    private FileSplitter fileSplitter = new FileSplitter("./test.txt", 10);

    @Test
    public void T1() {
        // 将几个滚动条类添加到文件分割器类中
        fileSplitter.addProgressBar(progressBar1);
        fileSplitter.addProgressBar(progressBar2);

        // 执行分割、split里通知对应的滚动条集合
        fileSplitter.split();
    }
}

对于这个解决方案来说，将ProgressBar进行了抽象，对于FileSplitter只需要依赖一个list，由一个list来维护ProgressBarInterface 的列表，对于每个ProgressBar控件来说，只需要继承ProgressBarInterface 即可。

这样、就将文件分割器类中的变化点分离了、现在文件分割器类是稳定的、而变化的滚动条类即在外面扩展即可。

要点总结

使用面向对象的抽象，Observer模式使得我们可以独立地改变目标与观察者，从而使二者之间的依赖关系达到松耦合。
目标发送通知时，无需制定观察者，通知（可以携带通知信息作为参数）会自动传播
观察者（滚动条类）自己决定是否需要订阅通知（即需要则添加进文件分割器的集合中），目标对象对此一无所知
Observer模式是基于事件的UI框架中非常常用的设计模式，也是MVC模式的一个重要组成部分。