观察者模式

发表于 | 分类于 | 阅读次数:

类图

代码

Observer

1
2
3
interface Observer{
    void update(String message);
}

Subject

1
2
3
4
5
6
7
8
9
interface Subject{

    void attach(Observer observer);

    void detach(Observer observer);

    void notify(String message);

}

ConcreteObverser

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class WexinUserObserver implements Observer{

    private String name;

    public WexinUserObserver(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void update(String message) {
        System.out.println(this.getName() + "收到了消息:" + message);
    }
}

ConcreteSubject

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class SubscriptionSubject implements Subject{

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

    @Override
    public void attach(Observer observer) {
        this.observers.add(observer);
    }

    @Override
    public void detach(Observer observer) {
        this.observers.remove(observer);
    }

    @Override
    public void notify(String message) {
        for (Observer observer : this.observers) {
            observer.update(message);
        }
    }
}

测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Main {
    public static void main(String args[]){
        Subject subject = new SubscriptionSubject();

        Observer user1 = new WexinUserObserver("用户1");
        Observer user2 = new WexinUserObserver("用户2");

        subject.attach(user1);
        subject.attach(user2);

        subject.notify("某人专栏更新了");
    }
}

运行结果

1
2
用户1收到了消息:某人专栏更新了
用户2收到了消息:某人专栏更新了

总结

概述

文中以类似微博订阅为例子，某人专栏更新后，用户1和用户2分别收到了订阅消息

优点

观察者和主题之间都是面向接口编程，主题不用观察者具体的实现，达到主题和观察者之间的解耦

缺点

如果观察者过多，可能会出现性能问题，要注意