java

观察者模式

观察者模式：

​ 定义了对象的一对多依赖，这样一来，当一个对象改变状态的时候，它的所有依赖者都会收到通知并作出相应的动作；

当subject状态更新的时候，如果想要通知观察他的对象，那么subject本身势必要持有观察他的对象的集合，这样才会自身有状态更新的时候，根据集合去通知观察者；观察者众多，通知的时候肯定是通过统一的接口来调用观察者的方法，这个统一的接口可以看做observer；subject本身拥有观察者的集合，那么自身会有一些管理观察者的动作，这些动作可以集合在subject接口；

从observer角度来说，要实施观察动作，那么就需要持有一个subject对象；

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.vayne.design;

/**
 * @author Volcanno
 */
public interface Subject {

    boolean registerObserver(Observer observer);

    boolean removeObserver(Observer observer);

    void notifyObserver();
}

观察者：

1
2
3
4
5
6
7
8
9
10
package com.vayne.design;

/**
 * @author Volcanno
 */
public interface Observer {

    boolean update(String name,int age);

}

各自的一个实现：

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
package com.vayne.design;

import java.util.ArrayList;
import java.util.List;

/**
 * @author Volcanno
 */
public class WeatherData implements Subject {

    private List<Observer> observers = new ArrayList<>();

    private String name;
    private int age;

    public void Do(String name, int age) {
        this.name = name;
        this.age = age;
        notifyObserver();
    }

    @Override
    public boolean registerObserver(Observer observer) {
        if (observer != null) {
            observers.add(observer);
            return true;
        }
        return false;
    }

    @Override
    public boolean removeObserver(Observer observer) {
        if (observer != null) {
            observers.remove(observer);
            return true;
        }
        return false;
    }

    @Override
    public void notifyObserver() {
        for (Observer observer : observers) {
            observer.update(this.name, this.age);
        }
    }
}
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
package com.vayne.design;

/**
 * @author Volcanno
 */
public class CenterOne implements Observer {

    private Subject subject;

    private String name;
    private int age;

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

    @Override
    public boolean update(String name, int age) {
        this.name = name;
        this.age = age;
        display();
        return true;
    }

    public void display() {
        System.out.println("name:");
        System.out.println(name);
        System.out.println("age");
        System.out.println(age);

    }
}

几个原则：

  1. 封装变化；
  2. 多用组合，少用继承；
  3. 针对接口编程；不针对具体实现编程；

参考《headfirst设计模式》