GoF23 观察者模式

观察者模式

意图

定义对象间的一种一对多的依赖关系 ,当一个对象的状态发生改变时 , 所有依赖于它的对象 都得到通知并被自动更新。

别名

依赖 ( D e p e n d e n t s ) , 发布 -订阅 ( P u b l i s h - S u b s c r i b e )

适用场景

• 当一个抽象模型有两个方面 , 其中一个方面依赖于另一方面。将这二者封装在独立的对
象中以使它们可以各自独立地改变和复用。
• 当对一个对象的改变需要同时改变其它对象 , 而不知道具体有多少对象有待改变。
• 当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之 , 你不希望这些
对象是紧密耦合的。

UML结构图

角色

•Subject (目标)
— 目标知道它的观察者。可以有任意多个观察者观察同一个目标。
— 提供注册和删除观察者对象的接口。
• Observer(观察者)
— 为那些在目标发生改变时需获得通知的对象定义一个更新接口。
• ConcreteSubject(具体目标)
— 将有关状态存入各 ConcreteObserver对象。
— 当它的状态发生改变时 , 向它的各个观察者发出通知。
• ConcreteObserver(具体观察者)
— 维护一个指向 ConcreteSubject对 象 的 引 用 。
— 存储有关状态，这些状态应与目标的状态保持一致。
— 实现 Observer 的 更 新 接 口 以 使 自 身 状 态 与 目 标 的 状 态 保 持 一 致 。

demo

举一个图书降价到栗子，当图书降价到时候需要广播和通知用户。
这里图书降价是一个事件，图书是被观察者，广播和通知用户是两个观察者；
Subject (目标) — Book

public class Book extends Observable {

    String name;
    String author;
    Double price;

    public Book(String name, String author, Double price) {
        this.name = name;
        this.author = author;
        this.price = price;
    }

     ... get set

    void changePrice(Double price){
        Double priceOld = this.getPrice();
        System.out.println("书名："+getName());
        System.out.println("修改价格："+priceOld+"==》"+price);
        setPrice(price);
        // 更新发生改变的标志
        setChanged();
        // 通知观察者
        notifyObservers(priceOld);
     }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

ConcreteObserver(具体观察者) —EventListener

public class EventListener  implements Observer {
    /**
     * This method is called whenever the observed object is changed. An
     * application calls an Observable object's
     * notifyObservers method to have all the object's
     * observers notified of the change.
     *
     * @param o   the observable object.
     * @param arg an argument passed to the notifyObservers
     */
    @Override
    public void update(Observable o, Object arg) {
        if(o instanceof Book){
          Book book =   (Book)o;
            System.out.println("-----降价广播通知-----");
            System.out.println("书名："+book.getName());
            System.out.println("作者："+book.getAuthor());
            System.out.println("原价："+arg);
            System.out.println("现价格："+book.getPrice());

        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

ConcreteObserver(具体观察者) —SendEventListener

public class SendEventListener implements Observer {
    String phone;
    String user;

    public SendEventListener(String phone, String user) {
        this.phone = phone;
        this.user = user;
    }

    @Override
    public void update(Observable o, Object arg) {
        if(o instanceof Book){
          Book book =   (Book)o;
            System.out.println("-----降价短信通知-----");
            StringBuffer sb = new StringBuffer();
            sb.append(book.getName());
            sb.append("  ");
            sb.append(book.getAuthor());
            sb.append("原价"+arg+" ");
            sb.append("现价"+book.getPrice());
            System.out.println("send sms to "+user+ " phone:"+phone +" msg: "+sb.toString());
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

Observable Observer都是JDK 1.8 提供的框架 注释去掉了 感兴趣可以去看下jdk源码

Observer 观察者

public class Observable {
    private boolean changed = false;
    private Vector<Observer> obs;
 
    public Observable() {
        obs = new Vector<>();
    }
 
    public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
        if (!obs.contains(o)) {
            obs.addElement(o);
        }
    }

    
    public synchronized void deleteObserver(Observer o) {
        obs.removeElement(o);
    }
 
    public void notifyObservers() {
        notifyObservers(null);
    }
 
    public void notifyObservers(Object arg) {
    
        Object[] arrLocal;

        synchronized (this) {
          
            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }

        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);
    }

    
    public synchronized void deleteObservers() {
        obs.removeAllElements();
    } 
    protected synchronized void setChanged() {
        changed = true;
    }
 
    protected synchronized void clearChanged() {
        changed = false;
    }
 
    public synchronized boolean hasChanged() {
        return changed;
    }
 
    public synchronized int countObservers() {
        return obs.size();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

Observable 被观察者接口

package java.util;
public interface Observer {
 
    void update(Observable o, Object arg);
}

1
2
3
4
5
6

测试

public class Test {
    public static void main(String[] args) {
        Book book = new Book("《金字塔原理》","【美】芭芭拉·明托",120D);
        book.addObserver(new EventListener());
        book.addObserver(new SendEventListener("17606868686","Jack Ma"));
        book.changePrice(100D);
    }
}

1
2
3
4
5
6
7
8
9

控制台