23种设计模式之---观察者模式(Observer Factory)

1.观察者模式(行为型模式)

观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时,会通知所有的观察者对象,使它们能够自己更新自己。

2.观察者模式结构图

3.观察者模式结构图分析

Subject类,可理解为主题或抽象通知者,一般用一个抽象类或一个接口实现。它把所有对观察者对象的引用保存在一个聚集中,每个主题都可以有任何数量的观察者。抽象主题提供一个接口,可以增加和删除观察者对象。

public abstract class Subject{
    private List<Observer> observers = new ArrayList<Observer>();
    //增加观察者
    public void attach(Observer observer){
        observers.add(observer);
    }
    //移除观察者
    public void detach(Observer observer){
        observers.remove(observer);
    }
    //通知
    public void notify(){
        for(Observer observer : observers){
            observer .update();
        }
    }
}

Observer类,抽象的观察者,为所有的具体观察者定义一个接口,在得到主题的通知时更新自己.这个接口叫做更新接口。抽象观察者一般用一个抽象类或者一个接口实现。更新接口通常包含一个update()方法,这个方法叫做更新方法。

public abstract class Observer{
    public abstract void update();
}

ConcreteSubject类,叫做具体主题或具体通知者,将有关状态存入具体的观察者对象;在具体主题的内部状态改变时,给所有登记过的观察者发出通知。具体主题角色通常用一个具体的子类实现。

public class ConcreteSubject extends Subject{
    private String subjectState;
    //具体被观察者状态
     public String getSubjectState() {
        return subjectState;
    }
    public void setSubjectState(String subjectState) {
        this.subjectState = subjectState;
    }
}

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

public class ConcreteObserver extends Observer{
    private String name;
    private String observerState;
    private ConcreteSubject subject;
    
    public ConcreteObserver(ConcreteSubject subject,String name){
        this.subject = subject;
        this.name = name;
    }
    @Override
    public void update(){
        observerState = subject.getSubjectState();
        System.out.println("观察者"+name+"的新状态是:"+observerState);
    }
}

客户端代码:

public static void main(String[] args){
    ConcreteSubject subject = new ConcreteSubject();
    subject.attach(new ConcreteObserver(s,"X"));
    subject.attach(new ConcreteObserver(s,"Y"));
    subject.attach(new ConcreteObserver(s,"Y"));
    s.setSubjectState = "ABC";
    s.notify();                    
}

控制台打印的结果:

观察者X的新状态是:ABC
观察者Y的新状态是:ABC
观察者Z的新状态是:ABC

4.观察者模式的特点

观察者模式的动机:将一个系统分割成一系列相互协作的类有一个很不好的副作用,那就是需要维护相关对象间的一致性。我们不希望为了维护一致性而使各类紧密耦合,这样会给维护,扩展和重用都带来不便。而观察者模式的对象是主题Subject和观察者Observer,一个Subject可以有任意数目的依赖它的Observer,一旦Subject的状态发生了改变,所有Observer都可以得到通知。Subject发出通知时并不需要知道谁是它的观察者。

当一个抽象模型有两方面,其中一方面依赖于另一方面,这是用观察者模式可以将这两者封装在独立的对象中使它们各自独立地改变和复用。观察者模式所做的工作其实就是在解除耦合。让耦合的双方都依赖于抽象,而不是依赖具体。从而使得各自的变化都不会影响另一边的变化。这其实就是依赖倒转原则的最佳的体现。

5.观察者模式的不足

尽管已经用了依赖倒转原则,但是抽象通知者还是依赖了抽象观察者,也就是说,万一没有了抽象观察者这样的接口,通知的功能就完不成了。

6.使用事件委托实现(代码就不贴了,可以先学习EventHandler,然后再代码实现)

简单来说就是每个具体的观察者中有各自不同的update()方法,通过事件委托然后将这些具体的方法挂钩到通知者的"更新"上。

事件委托说明:

委托就是一种引用方法的类型。一旦为委托分配了方法,委托将与该方法具有完全相同的行为。委托方法的使用可以将其他任何方法一样,具有参数和返回值。委托可以看做是对函数的抽象,是函数的'类',委托的实例将代表一个具体的函数。一个委托可以搭载多个方法,所有方法依次唤起,更重要的是它可以使得委托对象所搭载的方法并不需要属于同一个类。本来需要在具体的通知者(ConcreteSubject)类中的增加和减少的抽象观察者集合以及通知时遍历的抽象观察者都不必要了。转到客户端来让委托搭载多个方法,这就解决了本来与抽象观察者的耦合问题。但委托也是有前提的,那就是委托对象所搭载的所有方法必须具有相同的原形和形式,也就是具有相同的参数列表和返回值类型。

注意:是先有的观察者模式,再有的委托事件技术,它们各有优缺点。

在java中事件委托的实现是使用Event和EventHandler,具体Event和EventHandler是如何使用可以自己学习下。

7.总结

观察者模式:很好的解耦了代码,体现了依赖倒转原则;但抽象通知者还是依赖了抽象观察者,当没有观察者时,没办法更新,而且要求观察者的所有动作必须一样,如果不一样的话则不能实现。

时间委托机制:实现完全解耦;一次通知执行了不同类的不同方法;扩展性很高,重用性很好。

学习观察者模式可以参考下这篇博文(包含了事件委托机制的代码实现): https://blog.csdn.net/gdutxiaoxu/article/details/51824769

学习了那么久的设计模式,感觉更重要的在学习那些设计原则。比如说:依赖倒转原则,接口隔离,开闭原则等。

在学习设计模式的时候是参考的《大话设计模式》,不同的是用java语言实现的,基本上就是对这本书的整理和总结;之所以不像其他人那样改造成自己的语言来描述,一方面是觉得自己的语言不严谨,另一方面是觉得设计模式重在学习设计模式的思想,这些博客更多的是为了给自己看的,所以能够理解加记忆就行。