阅读《Design pattern》-观察者模式

摘抄《设计模式》

意图：

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

别名：

依赖（dependent），发布-订阅（publish-subscribe）

适用性：

在以下情况下可以使用观察者模式：

一个抽象模型有两个方面，其中一个方面依赖于另一个方面。将这二者封装在独立的对象中，以使它们可以各自独立地改变和复用。

对一个对象的改变需要同时改变其他对象，而不知道具体由多少对象需要改变。

一个对象必须通知其他对象，而他又不能假定其他对象是谁。换言之，你不希望这些对象紧密耦合的。

 

---

简单一句话：目标状态变化，触发所有观察者变化。

注意：一对多的关系，一个目标，多个观察者

 

目标提供一个方法：用于附上观察者，便于notify（通知）

观察者在初始时，关注（订阅）目标，并附上在目标上。释放时，取消关注（订阅），移除。

 

---

建立一个简单的观察者代码：

/**
 * 观察者模式-目标接口
 */
public interface ISubject {
    /**
     * 附上观察者
     * @param observer 观察者
     */
    public void attach(IObserver observer);

    /**
     * 移除观察者
     * @param observer 观察者
     */
    public void detach(IObserver observer);

    /**
     * 通知所有观察者
     */
    public void notifyAllObserver();
}

/**
 * 观察者模式-观察者接口
 */
public interface IObserver {
    /**
     * 订阅目标
     * @param subject 目标
     */
    public void subscribe(ISubject subject);

    /**
     * 取消订阅
     */
    public void unsubscribe();

    /**
     * 业务更新
     * @param subject 目标
     */
    public void update(ISubject subject);
}

上述是接口。下面定义父类基类

/**
 * 目标基类/父类
 */
public class BaseSubject implements ISubject {
    /**
     * 观察者列表
     */
    protected List<IObserver> observerList;

    /**
     * 构造函数
     */
    public BaseSubject() {
        observerList = new ArrayList<>();
    }

    @Override
    public void attach(IObserver observer) {
        if (observer != null) {
            observerList.add(observer);
        }
    }

    @Override
    public void detach(IObserver observer) {
        if (observer != null) {
            observerList.remove(observer);
        }
    }

    @Override
    public void notifyAllObserver() {
        for (IObserver item :
                observerList) {
            item.update(this);
        }
    }

    @Override
    protected void finalize() throws Throwable {
        for (IObserver item :
                observerList) {
            item.unsubscribe();
        }
        observerList.clear();
        super.finalize();
    }
}

/**
 * 观察者基类/父类
 */
public class BaseObserver implements IObserver {
    /**
     * 目标对象
     */
    protected ISubject subject;

    /**
     * 构造函数
     */
    public BaseObserver() {
        this.subject = null;
    }

    /**
     * 构造函数
     * @param subject 目标
     */
    public BaseObserver(ISubject subject) {
        this.subject = null;
        subscribe(subject);
    }

    @Override
    public void subscribe(ISubject subject) {
        if (subject != null) {
            this.subject = subject;
        }
        if (this.subject != null) {
            this.subject.attach(this);
        }
    }

    @Override
    public void unsubscribe() {
        if (this.subject != null) {
            this.subject.detach(this);
        }
    }

    @Override
    public void update(ISubject subject) {
        if (subject == this.subject) {
            // 自己的业务
        }
    }

    @Override
    protected void finalize() throws Throwable {
        unsubscribe();
        this.subject = null;
        super.finalize();
    }
}

上述是基类/父类，后续再继承各自的父类，进行实际业务的开展。

【实际业务的代码以及测试，这里不写了】

 

---

 

特别说明：

在不考虑效率的情况下，上述代码可以了。

但更多的时候，更多业务和资源，不允许不限制使用。

 

说简单点，在上述的情况下，需要做一个资源优化（比如，重复刷新、频繁刷新、占用资源过多如何处理、推或拉的效率问题）。这个取决于业务本身。

再比如：

1、需要观察多个目标，是观察者模式1对多关系的升级扩展

2、更新协议-推拉模型的选定或混用

3、封装复杂的更新语义