观察者模式

概念介绍

观察者模式实际在android中用到的地方是非常多的。
比如我们的eventbus，还有listview更新数据，以及最近非常火的rxjava，用到的都是观察者模式。
无论是从事java开发，还是android开发，熟悉设计模式中的观察者模式都是必要的。

使用场景

观察者模式的主要使用场景有以下：
1.一个抽象模型有两个方面，一个方面依赖另一个方面。
2.一个对象的改变将导致一个或多个其他对象发生改变。（主要使用场景）
3.需要在系统中创建一个触发链。

UML类图

Subject表示被观察者，在类里面定义都是一个被观察触发的方法。
Observer表示观察者。
Subject可以对应一个Observer，也可以对应多个Observer。
在一对多的情况下，观察者的数量上限是没有规定的。也就是说，一个被观察者可以只对应一个观察者，也可以对应多个观察者。被观察者通常会定义增加或者减少观察者的方法。比如图中的attach和detach，就是用来定义增加和删除观察者对象的方法。
当Subject的数据发生改变的时候，这时候被观察者就会调用notify（）方法来告诉它的Observer，数据已经发生改变。
Subject是抽象主题类，具体主题类是下面的ConcreteSubject，当ConcreateSubject里面的数据发生改变的时候，它会通知ConcreteObserver。就是指在具体的代码里面，我们不会调用Subject而是会调用具体的ConcreateSubject来通知它的观察者。
而ConcreateObserver当他被通知到改变的时候会执行update（）方法，来通知自己去做一些UI的改变或者是后续的操作。

松耦合

主题只是知道观察者实现了某个接口（也就是Observer）。主题不需要知道观察者的具体类是什么，做了什么具体的事情。
任何时候我们都可以增加新的观察者。因为主题唯一依赖的东西是一个实现Observer接口的对象列表，所以我们可以随时随地增加观察者。事实上，在运行时我们可以用新的观察者取代现在的观察者，主题也不会受到任何影响。同样的，也可以在任何时候删除某些观察者。
有新的观察者出现的时候，主题的代码不需要改变。
我们可以独立地复用主题或者观察者。如果我们在其他地方需要使用主题或者观察者，可以轻易地复用，因为二者并非紧耦合。
改变主题或者这观察者的一方，并不影响另一方。因为两者是送耦合的，所以只要他门之间的接口仍被遵守，我们就可以自由地改变他们。

java内置的观察者模式

java中的观察者模式是怎么运作的？

1.实现观察者接口（java.util.Observer）,然后调用任何Observable对象的addObserver（）方法。不想再当观察者时，调用deleteObserver（）方法就可以了。

2.发出通知： 先调用setChanged（）方法，标记状态已经改变。再调用notifyObservers（）或者notifyObservers(Object arg)

3.观察者接受通知，在update（Observable o ,Object arg）方法里面。

一些例子

public interface Observer
{
    public void update(float temprature);
}

public class ConcreteObserver implements Observer
{
    private float temperature;
    private final Subject subject;

    public ConcreteObserver(final Subject subject)
    {
        this.subject = subject;
        this.subject.registerObserver(this);
    }

    public float getTemperature()
    {
        return temperature;
    }

    public void setTemperature(final float temperature)
    {
        this.temperature = temperature;
    }

    @Override
    public void update(final float temperature)
    {
        this.temperature = temperature;
    }
}

public interface Subject
{
    public void registerObserver(Observer o);

    public void removeObserver(Observer o);

    public void notifyObservers();

}

public class ConcreteSubject implements Subject
{
    private final List<Observer> observers;
    private float temperature;

    public float getTemperature()
    {
        return temperature;
    }

    private void temperatureChanged()
    {
        this.notifyObservers();
    }

    public void setTemperature(final float temperature)
    {
        this.temperature = temperature;
        this.temperatureChanged();
    }

    public ConcreteSubject()
    {
        observers = new ArrayList<Observer>();
    }

    @Override
    public void registerObserver(final Observer o)
    {
        observers.add(o);
    }

    @Override
    public void removeObserver(final Observer o)
    {
        if (observers.indexOf(o) >= 0)
        {
            observers.remove(o);
        }
    }

    @Override
    public void notifyObservers()
    {
        for (final Observer o : observers)
        {
            o.update(temperature);
        }
    }
}

public class Client
{
    public static void main(final String[] args)
    {
        final ConcreteSubject sb = new ConcreteSubject();
        sb.setTemperature((float) 20.00);

     `
  final 
Observer o = new ConcreteObserver(sb);
        sb.setTemperature((float) 21.00);

    }
}

该模式的一小点缺陷

Observable必须通过继承的方式去实现，这违反了设计模式中“多用接口、少用继承”的建议。如果有一个类同时具有Observable类和另一个超类的行为，就会陷入两难，毕竟java不支持多继承。所以这就限制了Observable的复用潜力。再者，因为没有Observable接口，所以你无法建立自己的实现，和java内置的Observer API搭配使用。