【设计模式专题】观察者模式实战详细分析

🍍每日推荐

🍖文章开始之前我想首先介绍一下牛客，以便没有使用过的小伙伴能够快速入手，牛客网是国内最大的算法、面试、招聘网站，涵盖了多种大厂面试真题以及题解，里面大佬云集，各种题目的解决方案层出不穷，绝对能让你大开眼界，而且牛客是你在人生中不同的阶段都能对你有所帮助的编程软件（完全免费），如果感兴趣可以访问注册一下

访问链接：牛客-国内最大的刷题网站

一 什么是观察者模式

定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知，并自动更新。

新手经常会把观察者模式经常与发布订阅模式，其实二者还是有一些区别的，

二 观察者模式与发布订阅模式的区别

• 观察者模式主要的使用场景是一对多的状态，且需要知道通知的对象是谁。

• 发布订阅模式的主要使用场景是一对多或者多对多的状态，且不需要知道通知的对象也就是消费者是谁。

• 观察者模式属于Gang of Four 提出的23中设计模式中的一种，发布订阅模式并不属于其中的一种而是一种软件设计理念。

• 观察者模式耦合度较高，因为观察者模式中目标的只有一个，观察者需要知道目标的所有行为。

• 发布订阅的耦合度较低，而发布订阅的发布者可以有多个，订阅者不需要知道发布者是谁，只需要关心发布的内容。

三 编写demo案例

比如今天是周一，Leader需要公司里的员工加班，员工分别有Jack、Mark，然而每个人对加不加班是有自己的看法和行为的，这时就可以把Leader作为目标/主题，Jack、Mark做为观察者，观察者需要根据目标的指令来做出对应的行为。

一般观察者模式有4个角色，分别为：抽象目标类、具体目标类、抽象观察类、具体观察类。

代码实现如下：

抽象目标类 ：MySubject

import java.util.List;

/**
 * @author liuy 抽象目标类
 * @create 2022-08-18-13:05
 */
public abstract class MySubject {
    protected List<MyObserver> observers = new ArrayList<>();

    //注册方法
    public void attach(MyObserver observer){
        observers.add(observer);
    }

    //注销方法
    public void detach(MyObserver observer){
        observers.remove(observer);
    }

    public abstract void push(int state); //抽象通知方法

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

具体目标类：Leader

/**
 * @author liuy 具体目标类
 * @create 2022-08-18-13:05
 */
public class Leader extends MySubject {
    @Override
    public void push(int state) {
       observers.forEach(obs->obs.response(state));
    }
}
1
2
3
4
5
6
7
8
9
10
11

抽象观察者类：MyObserver

/**
 * @author liuy 抽象观察者类
 * @create 2022-08-18-13:05
 */
public interface MyObserver {
    void response(int state); //抽象响应方法
}

1
2
3
4
5
6
7
8

具体观察者类一：Jack

/**
 * @author liuy 具体观察者类
 * @create 2022-08-18-13:05
 */
public class Jack implements MyObserver {
    @Override
    public void response(int state) {
        String name = "Jack：";
        if(state ==1){
            System.out.println(name + "需要加班，开摆！");
        }else {
            System.out.println(name + "哈哈哈,不加班就可以回家打游戏了");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

具体观察者类二：Mark

/**
 * @author liuy 具体观察者类
 * @create 2022-08-18-13:05
 */
public class Mark implements MyObserver {
    @Override
    public void response(int state) {
        String name = "Mark：";
        if(state ==1){
        System.out.println(name + "我爱加班，因为有加班费");
        }else {
            System.out.println(name + "呜呜呜，没加班费拿了");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

现在基本的观察者模式已经实现了，现在开始测试。

/**
 * @author liuy 客户端测试
 * @create 2022-08-18-13:05
 */
public class Client {
    public static void main(String[] args) {
        MySubject subject = new Leader();

        MyObserver obs1, obs2;
        obs1 = new Jack();
        obs2 = new Mark();
        subject.attach(obs1);
        subject.attach(obs2);


//        subject.detach(ObserverEnum.Dog.getMyObserver());

        System.out.println("===================== 第一天 =======================");

        //1代表需要加班，2代表不加班
        System.out.println("Leader：今天所有人都要加班！");
        subject.push(1);

        System.out.println("===================== 第二天 ====================");

        //1代表需要加班，2代表不加班
        System.out.println("Leader：今天大家不用加班了！");
        subject.push(2);
    }
}
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

测试结果

相信有一些小伙伴已经发现了，如果像测试类中的写法，每次发送消息的时候都需要new对应的对象然后添加到观察者集合中，这样很不方便

我们可以使用观察者模式+工厂模式来解决这个问题。

四 优化demo案例 观察者模式+工厂模式

创建观察者工厂枚举类：ObserverEnum

/**
 * @Author liuy
 * @Description 观察者工厂枚举类
 * @Date 2022/8/18 14:55
 * @Version 1.0
 */
public enum ObserverEnum {
    Mouse(new Jack()),
    Dog(new Mark()),
    ;

    ObserverEnum(MyObserver myObserver) {
        this.myObserver = myObserver;
    }

    private  MyObserver  myObserver;
    public MyObserver getMyObserver() {
        return myObserver;
    }

    public void setMyObserver(MyObserver myObserver) {
        this.myObserver = myObserver;
    }

    public static List<MyObserver> getObservers(){
        return Arrays.stream(ObserverEnum.values()).map(ObserverEnum::getMyObserver).collect(Collectors.toList());
    }
}
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

然后只需要修改抽象目标类中的观察者集合成员变量：observers

import java.util.List;

/**
 * @author liuy 抽象目标类
 * @create 2022-08-18-13:05
 */
public abstract class MySubject {
    //所有观察者集合
    //旧 protected List observers = new ArrayList<>() ;
    protected List<MyObserver> observers = ObserverEnum.getObservers();

    //注册方法
    public void attach(MyObserver observer){
        observers.add(observer);
    }

    //注销方法
    public void detach(MyObserver observer){
        observers.remove(observer);
    }

    public abstract void push(int state); //抽象通知方法

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

测试

/**
 * @author liuy 客户端测试
 * @create 2022-08-18-13:05
 */
public class Client {
    public static void main(String[] args) {
        MySubject subject = new Leader();

        System.out.println("===================== 第一天 =======================");

        //1代表需要加班，2代表不加班
        System.out.println("Leader：今天所有人都要加班！");
        subject.push(1);

        System.out.println("===================== 第二天 ====================");

        //1代表需要加班，2代表不加班
        System.out.println("Leader：今天大家不用加班了！");
        subject.push(2);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

五 优缺点

主要优点

（1）观察者模式可以实现表示层和数据逻辑层的分离，定义了稳定的消息传递机制，并抽象了更新接口，使得可以有各种各样的表示层充当具体的观察者角色。

（2）观察者模式在观察目标和观察者之间建立一个抽象的耦合。观察者对象只需要维持一个抽象观察者的集合，无需了解其具体观察者。

（3）观察者模式支持广播通信，观察目标会向所有已注册的观察者发送通知，降低了一对多系统的设计难度。

（4）观察者模式满足开闭原则的要求，增加新的具体观察者无须修改原有的系统代码。

主要缺点

（1）如果一个观察目标对象有很多的直接观察者和间接观察者，那么所有的观察者接收到消息会耗费大量的时间。

（2）如果观察者和被观察者之间存在循环依赖，那么观察目标会触发它们之间进行循环调用，可能导致系统崩溃。

（3）观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道目标观察对象发生了变化