设计模式演化之观察者模式1——经典实现

定义

定义一种对象之间的一对多关系，当一个对象状态改变时，所有依赖于它的对象都得到消息，并刷新。

演化

1.定义Subject和Observer两个类，现在要求当Subject对象中的一个属性改变时，Observer对象要把这个属性实时显示出来。在代码中我们可以这么写：让Subject对象持有Observer对象的引用，当属性改变时，调用Observer的update()方法。

(1) 定义Subject类

public class Subject {
    private String name;
    private Observer observer;

    public void setObserver(Observer observer) {
        this.observer = observer;
    }

    public void setName(String name) {
        this.name = name;
        if (observer != null) {
            observer.update(name);
        }
    }
}

(2) 定义Observer类

public class Observer {
    public void update(String name) {
        System.out.println(name);
    }
}

(3) 调用过程

public class ObserveClient {
    public static void display() {
        Subject subject = new Subject();
        Observer observer = new Observer();
        subject.setObserver(observer);
        subject.setName("新数据");
    }
}

从代码调用过程上讲，Observer在代码中是被调用者，而Subject是主动调用者。但从实际意义上讲，我们已经实现了一个观察者模式的基础：在Observer中观察Subject中name属性的变化，当name变化时通知Observer进行更新。总结起来就是被观察者需要持有观察者的引用，当改变数据时调用观察者的更新方法。下面我们基于这一点对这这段代码进行优化。

2.首先，我们已经明确了1中的过程已经满足了观察者模式的条件。为了让代码能更准确的表达含义，我们对方法名做出一定的修改。
(1) 将Subject中的setObserver()改为registerObserver()，表示给Subject注册观察者。setName()改为changeName()，表示name是变化的属性。

public class Subject {
    private String name;
    private Observer observer;

    public void registerObserver(Observer observer) {
        this.observer = observer;
    }

    public void changeName(String name) {
        this.name = name;
        if (observer != null) {
            observer.update(name);
        }
    }
}

(2) 将Observer中的update()改为onChange()。从字面意义上理解，update()看上去只是一个需要被调用的方法。而onChange()却表达了当属性变化时执行的意思。虽然它们的本质上都是被调用，但我们却能通过onChange()方法名来增强它观察者的身份。

public class Observer {
    public void onChange(String name) {
        System.out.println(name);
    }
}

3.现在我们添加一个要求，有很多个类的对象都需要观察name属性的变化，而且变化后各自执行不同的操作。此时就需要把Observer抽象成一个接口，让需要观察name变化的类都实现Observer接口。然后把它们都注册到Subject中去。
(1) 定义Observer抽象接口

public interface Observer {
    void onChange(String name);
}

(2) 定义Observer的实现类

public class FirstObserver implements Observer {
    @Override
    public void onChange(String name) {
        System.out.println(name + "Hello First");
    }
}

public class SecondObserver implements Observer {
    @Override
    public void onChange(String name) {
        System.out.println(name + "Hello Second");
    }
}

(3) 给Subject增加一个List，使它可以持有很多的观察者。当数据变化时，通知所有观察者，即调用所有观察则的onChange()方法。

public class Subject {
    private String name;
    private List<Observer> observers = new ArrayList<>();

    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    public void changeName(String name) {
        this.name = name;
        for (Observer observer: observers) {
            observer.onChange(name);
        }
    }
}

(4) 在客户端中调用的代码如下。

public class ObserveClient {
    public static void display() {
        Subject subject = new Subject();
        Observer observer1 = new FirstObserver();
        Observer observer2 = new SecondObserver();
        subject.registerObserver(observer1);
        subject.registerObserver(observer2);
        subject.changeName("新数据");
    }
}

4.此时还存在一个问题：这么多观察者对象都要观察Subject中的数据，Subject的生命周期一定相当的长，而且需要比所有的观察者对象都长。但是它又持有所有观察者的引用，这就导致了及时观察者对象已经无用了，内存也无法释放。因此还要提供给观察者解除注册的方法，当观察者对象不需要使用时，调用解除方法释放引用。

public class Subject {
    // ...
    public void unregisterObserver(Observer observer) {
        observers.remove(observer);
    }
}

经过四个步骤的演化，经典的观察模式已经完成了。但实际上这种经典的模式我们还是很少在代码中用到的，正如定义中提到的那样，只能满足多个观察者观察一个数据的变化。

优点：

（1）观察者和被观察者抽象耦合
（2）建立一套触发机制，建立之后不需要改变代码逻辑

缺点

（1）如果观察者较多，通知所有的观察者要花费很多时间，因此在观察者不可用的时候，要及时取消注册
（2）如果观察者与被观察者循环依赖，可能导致循环调用，导致系统崩溃
（3）观察者不知道所观察的对象是怎么变化的，只知道变化