阳光温暖 阅读(7) 评论(0)

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

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

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

举例说明

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

根据这个例子,简单画下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 我收到报纸了

优缺点

优点

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

缺点

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