设计模式系列:观察者模式

发表于 | 分类于 ， | |

概念

观察者模式也被称为 Model-View模式。观察者的状态依赖于被观察者的行为。一旦被观察者的行为发生改变
观察者的状态也随之发生改变。是一种对象间的信息交互方式。

实现

  • 类图

图片

  • Observer
1
2
3
4
5
6
7
8
9
10
11
12
13
14

package com.littlehui.design.observer;

/**
 * @Description TODO
 * @ClassName Observer
 * @Author littlehui
 * @Date 2019/10/9 16:32
 * @Version 1.0
 **/
public interface Observer {

    public void update(String message);
}
  • ConcreteObserver
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

package com.littlehui.design.observer;

/**
 * @Description TODO
 * @ClassName ConcreteObserver
 * @Author littlehui
 * @Date 2019/10/9 16:38
 * @Version 1.0
 **/
public class ConcreteObserver implements Observer {

    @Override
    public void update(String message) {
        System.out.println("观察者1：" + message);
    }
}
  • ConcreteObserver2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.littlehui.design.observer;

/**
 * @Description TODO
 * @ClassName ConcreteObserver2
 * @Author littlehui
 * @Date 2019/10/9 16:41
 * @Version 1.0
 **/
public class ConcreteObserver2 implements Observer {

    @Override
    public void update(String message) {
        System.out.println("观察者2：" + message);
    }
}
  • Subject
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

package com.littlehui.design.observer;

/**
 * @Description TODO
 * @ClassName Subject
 * @Author littlehui
 * @Date 2019/10/9 16:34
 * @Version 1.0
 **/
public interface Subject {

    public void register(Observer observer);

    public void remove(Observer observer);

    public void notify(String message);

}
  • ConcreteSubject
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.littlehui.design.observer;

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

/**
 * @Description TODO
 * @ClassName ConcreteSubject
 * @Author littlehui
 * @Date 2019/10/9 16:38
 * @Version 1.0
 **/
public class ConcreteSubject implements Subject {

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

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

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

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

  • Client

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    package com.littlehui.design.observer;

    /**
     * @Description TODO
     * @ClassName Client
     * @Author littlehui
     * @Date 2019/10/9 16:42
     * @Version 1.0
     **/
    public class Client {

        public static void main(String[] args) {
            Observer observer1 = new ConcreteObserver();
            Observer observer2 = new ConcreteObserver2();

            Subject subject = new ConcreteSubject();
            subject.register(observer1);
            subject.register(observer2);

            subject.notify("呼叫司令。");

        }
    }

  • 执行

1
2
3
4
5
6
7

Connected to the target VM, address: '127.0.0.1:51436', transport: 'socket'
观察者1：呼叫司令。
观察者2：呼叫司令。
Disconnected from the target VM, address: '127.0.0.1:51436', transport: 'socket'

Process finished with exit code 0

场景

观察者模式功能是用于信息广播。观察者在得到广播信息后进行一系列的状态变更。比如前端菜单面板的应用，面板上的
按钮，图标观察面板的状态。一旦面板发生关闭或者取消，面板上的按钮，图标随之也可能发生变更，比如取消或者重新绘制等等。

总结

观察者模式提供了一种对象设计,让主题和观察者之间耦合度降得很低,为什么呢?关于观察者的一切,主题只知道观察者实现了Observer接口,并不需要观察者具体的类是谁,做了什么或者其他细节.
这样的话,由于松耦合,改变主题或者观察者其中一方,并不会影响另一方,只要他们之间的接口仍被遵守,就可以自由地改变它.
降低对象之间的耦合度,也是面设对象设计的一个很重要的原则.