设计模式(六)_观察者模式

继续学习设计模式,这个月准备再学习几个重要的设计模式。废话不多说，观察者模式，走起！

• 观察者模式定义了对象之间的一对多依赖，这样一来。当一个对象改变状态时，它的所有的依赖着都会收到通知并自动更新。

• 观察者模式属于行为型模式。行为型模式关注的是对象之间的通讯，观察者模式就是观察者和被观察者之间的通讯

举例说明

比如，我们以订阅报纸为例，当你订阅了一份报纸，每天都会有一份最新的报纸送到你的手上。有多少人订阅报纸，报社就会发多少份报纸，这就是典型的订阅-发布模式，报社和订阅报纸的客户就是一对多的依赖关系。

根据这个例子，简单画下UML类图

具体代码

观察者（客户）

public interface Customer {

    public abstract void update();
}

public class CustomerA implements Customer {
    @Override
    public void update() {
        System.out.println("我是客户A.我收到报纸了");
    }
}

public class CustomerB implements Customer {
    @Override
    public void update() {
        System.out.println("我是客户B,我收到报纸了");
    }
}

被观察者（报社）

public class NewsOffice {

    private List<Customer> customers = new ArrayList<>();

    public void addCustomer(Customer customer){
        this.customers.add(customer);
    }

    //报纸来了
    public void newspaperCome(){
        this.notifyAllObservers();
    }

    public void notifyAllObservers(){
        for (Customer customer: customers) {
            customer.update();
        }
    }
}

测试

NewsOffice office = new NewsOffice();

Customer customerA = new CustomerA();
Customer customerB = new CustomerB();

//客户A订阅报纸
office.addCustomer(customerA);
// 客户B订阅报纸
office.addCustomer(customerB);

office.notifyAllObservers();

输出：

我是客户A.我收到报纸了
我是客户B,我收到报纸了

观察者模式，最重要的一点，就是要搞清楚谁是观察者，谁是被观察者。

收通知的就是观察者

客户是订阅报纸，收报纸的人（收通知） 。所以客户就是观察者，那么报社就是被观察者

Java中提供的观察者模式

java 已经为我们提供观察者模式 所需要的类：Observer类 和 Subject 类，只不过在 Java 中 Subject 不叫 Subject，而叫 Observable。

查看Observable类的结构

我使用idea，直接ctrl+N 输入Observable，打开Observable类，然后输入alt+7 .就显示类的结构了

观察源码和我们自己写的代码有什么区别？

• 保存观察者列表不是用的List

private Vector<Observer> obs;

• 通知观察者 用了synchronized关键字

public void notifyObservers(Object arg) {
        /*
         * a temporary array buffer, used as a snapshot of the state of
         * current Observers.
         */
        Object[] arrLocal;

        synchronized (this) {
            /* We don't want the Observer doing callbacks into
             * arbitrary code while holding its own Monitor.
             * The code where we extract each Observable from
             * the Vector and store the state of the Observer
             * needs synchronization, but notifying observers
             * does not (should not).  The worst result of any
             * potential race-condition here is that:
             * 1) a newly-added Observer will miss a
             *   notification in progress
             * 2) a recently unregistered Observer will be
             *   wrongly notified when it doesn't care
             */
            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }
        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);
     }

我们利用java提供的这2个类实现刚刚的情景

public class NewsOffice2 extends Observable {

    /**
     * 模拟报纸来了
     */
    public void newspaperCome(){
        this.setChanged();
        this.notifyObservers();
    }
}

public class CustomerC implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("我是客户c 我收到报纸了");
    }
}

测试

        NewsOffice2 office2 = new NewsOffice2();

        CustomerC customerC = new CustomerC();

        office2.addObserver(customerC);

        office2.newspaperCome();

运行结果

我是客户c 我收到报纸了

优缺点

优点

• 观察者和被观察者之间抽象耦合，自有一套触发机制，被观察者无需知道通知的对象是谁，只要是符合观察者接口的就可以

缺点

• 观察者只知道被观察发生变化，而无法知道如何变化的
• 如果存在多个观察者，一个个通知，比较耗时。