案例分析：设计模式与代码的结构特性

Posted 2020-11-24 pyinal

观察者模式

 　　

　　观察者模式是关于多个对象想知道一个对象中数据变化情况的一种成熟模式。观察者模式中有一个称作“主题”的对象和若干个称作“观察者”的对象，“主题”和“观察者”之间是一种一对多的依赖关系。

当“主题”的状态发生变化时，所有“观察者”都得到通知。通常被用来实现事件处理系统。

从代码实现的角度，我们又可以分为以下四种角色：

• 抽象主题角色： 把所有对观察者对象的引用保存在一个集合中，每个抽象主题角色都可以有任意数量的观察者。抽象主题提供一个接口，可以增加和删除观察者角色。一般用一个抽象类和接口来实现。

• 抽象观察者角色：为所有具体的观察者定义一个接口，在得到主题的通知时更新自己。

• 具体主题角色：在具体主题内部状态改变时，给所有登记过的观察者发出通知。具体主题角色通常用一个子类实现。

• 具体观察者角色：该角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。通常用一个子类实现。如果需要，具体观察者角色可以保存一个指向具体主题角色的引用。

代码示例

抽象主题角色

/**
 * 抽象主题，被观察者
 *
 */
public interface Subject {
    
    void addObserver(Observer observer);

    
    void removeObserver(Observer observer);

    
    void removeAll();

    void notifyAllObserver(Object data);

    void notify(Observer observer, Object data);

}

抽象观察者角色

/**
 * 抽象观察者接口
 */
public interface Observer {
    
    void update(Subject subject,Object data);
}

具体主题角色

public class ConcreteSubject implements Subject {

    //观察者集合，用于管理所有的观察者
    List<Observer> mList = new ArrayList<>();

    @Override
    public void addObserver(Observer observer) {
        // TODO Auto-generated method stub
        // 确保相同的观察者只含有一个
        if (observer == null) {
            throw new NullPointerException("observer == null");
        }

        if (!mList.contains(observer)) {
            mList.add(observer);
        }
    }

    @Override
    public void removeObserver(Observer observer) {
        // TODO Auto-generated method stub
        mList.remove(observer);
    }

    @Override
    public void removeAll() {
        // TODO Auto-generated method stub
        mList.clear();
    }

    @Override
    public void notifyAllObserver(Object data) {
        // TODO Auto-generated method stub
        for (Observer observer : mList) {
            observer.update(this, data);
        }
    }

    @Override
    public void notify(Observer observer, Object data) {
        // TODO Auto-generated method stub
        if (observer != null) {
            observer.update(this, data);
        }
    }

}

 

 

 

具体的观察者角色

public class ObserverOne implements Observer {

    @Override
    public void update(Subject subject, Object data) {
        // TODO Auto-generated method stub
        System.err
                .println("the messge from subject to-->" + this.getClass().getName() + "<---is " + data.toString());
    }

}

public class ObserverTwo implements Observer {

    @Override
    public void update(Subject subject, Object data) {
        // TODO Auto-generated method stub
        System.err
        .println("the messge from subject to-->" + this.getClass().getName() + "<---is " + data.toString());
    }

}

public class ObserverThree implements Observer {

    @Override
    public void update(Subject subject, Object data) {
        // TODO Auto-generated method stub
        System.err
        .println("the messge from subject to-->" + this.getClass().getName() + "<---is " + data.toString());
    }

}

 

总结

观察者模式在被观察者和观察者之间建立一个抽象的耦合。被观察者角色所知道的只是一个具体观察者列表，每一个具体观察者都符合一个抽象观察者的接口。被观察者并不认识任何一个具体观察者，它只知道它们都有一个共同的接口。由于被观察者和观察者没有紧密地耦合在一起，因此它们可以属于不同的抽象化层次。如果被观察者和观察者都被扔到一起，那么这个对象必然跨越抽象化和具体化层次。如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。