还在用jdk那鸡肋的观察者模式？五分钟学会完美的观察者模式

1. 前言

如果某个对象的改变会引起其它很多对象的改变，就可以用观察者模式。观察者模式定义了对象之间一对多的关系，当一个对象改变后，其他对象都会收到通知

2. 实现一个观察者模式

有这样一个场景：新冠疫苗可以预约了，丈八社区附近的几千人都订阅了丈八社区的公众号，等疫苗到达后，这些人都会收到打疫苗通知，然后决定是否去打疫苗。这里面丈八社区就是“被观察者/主题”（Subject），打疫苗的人就是“观察者”（Observer）。

1. 定义主题接口

/**
 * @author yulin.chen
 * @description 主题接口
 * @date 2021/7/20 13:54
 */
public interface Subject {
    /**
     * @description 添加观察者
     * @author yulin.chen
     * @date 2021/7/20 13:59
     */
    void addObserver(Observer o);

    /**
     * @description 移除观察者
     * @author yulin.chen
     * @date 2021/7/20 14:00
     */
    void deleteObserver(Observer o);

    /**
     * @description 通知观察者
     * @param arg 传递的参数，可传递任意值
     * @author yulin.chen
     * @date 2021/7/20 14:00
     */
    void notifyObservers(Object arg);


}

1. 定义观察者接口

/**
 * @author yulin.chen
 * @description 观察者接口
 * @date 2021/7/20 14:03
 */
public interface Observer {
    /**
     * @description 更新
     * @param arg 传递的参数，可传递任意值
     * @author yulin.chen
     * @date 2021/7/20 14:03
     */
    void update(Object arg);

    /**
     * @description 取消订阅
     * @author yulin.chen
     * @date 2021/7/20 14:40
     */
    default void unsubscribe(Subject subject){
        subject.deleteObserver(this);
    };
}

3. 定义传递参数：疫苗批次

/**
 * @author yulin.chen
 * @description 疫苗批次
 * @date 2021/7/20 14:07
 */
public enum VaccineBatch {
    /**
     * 第一针
     */
    BATCH_ONE(1, "第一针"),
    /**
     * 第二针
     */
    BATCH_TWO(2, "第二针"),
    /**
     * 第三针
     */
    BATCH_THREE(3, "第三针");
    private final int batch;
    private final String desc;

    VaccineBatch(int batch, String desc) {
        this.batch = batch;
        this.desc = desc;
    }

    public int getBatch() {
        return batch;
    }

    public String getDesc() {
        return desc;
    }
}

4. 定义主题“丈八社区”

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

/**
 * @author yulin.chen
 * @description 被观察者，丈八社区
 * @date 2021/7/20 14:05
 */
public class ZhangBaCommunity implements Subject {
    private List<Observer> observers;

    public ZhangBaCommunity() {
        observers = new ArrayList<>();
    }

    @Override
    public void addObserver(Observer o) {
        observers.add(o);
    }

    @Override
    public void deleteObserver(Observer o) {
        int i = observers.indexOf(o);
        if (i >= 0) {
            observers.remove(i);
        }
    }

    @Override
    public void notifyObservers(Object arg) {
        observers.forEach(o -> {
            o.update(arg);
        });
    }

    /**
     * @description 收到疫苗后通知
     * @author yulin.chen
     * @date 2021/7/20 14:13
     */
    public void receiveVaccine(VaccineBatch batch) {
        notifyObservers(batch);
    }
}

5. 定义准备打疫苗的人

/**
 * @author yulin.chen
 * @description 要打疫苗的人,要实现观察者接口
 * @date 2021/7/20 18:13
 */
public class Person implements Observer {
    private final String name;
    /**
     * 打哪一针
     */
    private final VaccineBatch batch;

    public Person(String name, VaccineBatch batch) {
        this.name = name;
        this.batch = batch;
    }

    public String getName() {
        return name;
    }

    @Override
    public void update(Object arg) {
        if (arg instanceof VaccineBatch) {
            VaccineBatch batch = (VaccineBatch) arg;
            String batchDesc = this.batch.getDesc();
            if (batch.equals(this.batch)) {
                System.out.println("["+name+"，需要打"+ batchDesc +"]终于等到"+batchDesc+"了，我马上去打");
            } else {
                System.out.println("["+name+"，需要打"+ batchDesc +"]"+batchDesc+"没有了吗，打不上，着急啊");
            }
        }
    }

}

6. 测试

public class Main {
    public static void main(String[] args) {
        //创建主题丈八社区
        ZhangBaCommunity subject = new ZhangBaCommunity();
        //创建观察者“observer1”
        Person observer1 = new Person("张三",VaccineBatch.BATCH_ONE);
        //创建观察者“observer2”
        Person observer2 = new Person("李四",VaccineBatch.BATCH_TWO);
        //创建观察者“observer2”
        Person observer3 = new Person("王五",VaccineBatch.BATCH_THREE);
        //添加观察者
        subject.addObserver(observer1);
        subject.addObserver(observer2);
        subject.addObserver(observer3);
        System.out.println("=========== 第一针疫苗到了 =============");
        subject.receiveVaccine(VaccineBatch.BATCH_ONE);
        System.out.println();
        System.out.println();
        System.out.println("=========== 第二针疫苗到了 =============");
        subject.receiveVaccine(VaccineBatch.BATCH_TWO);

        System.out.println();
        System.out.println();
        System.out.println();
        System.out.println();
        System.out.println("=========== ["+observer1.getName()+"]不想打疫苗了，取消订阅 =============");
        observer1.unsubscribe(subject);
        System.out.println("=========== 第一针疫苗到了 =============");
        subject.receiveVaccine(VaccineBatch.BATCH_ONE);
        System.out.println();
        System.out.println();
        System.out.println("=========== 第二针疫苗到了 =============");
        subject.receiveVaccine(VaccineBatch.BATCH_TWO);
        System.out.println();
        System.out.println();
        System.out.println("=========== 第三针疫苗到了 =============");
        subject.receiveVaccine(VaccineBatch.BATCH_THREE);

    }
}

运行结果

=========== 第一针疫苗到了 =============
[张三，需要打第一针]终于等到第一针了，我马上去打
[李四，需要打第二针]第二针没有了吗，打不上，着急啊
[王五，需要打第三针]第三针没有了吗，打不上，着急啊


=========== 第二针疫苗到了 =============
[张三，需要打第一针]第一针没有了吗，打不上，着急啊
[李四，需要打第二针]终于等到第二针了，我马上去打
[王五，需要打第三针]第三针没有了吗，打不上，着急啊




=========== [张三]不想打疫苗了，取消订阅 =============
=========== 第一针疫苗到了 =============
[李四，需要打第二针]第二针没有了吗，打不上，着急啊
[王五，需要打第三针]第三针没有了吗，打不上，着急啊


=========== 第二针疫苗到了 =============
[李四，需要打第二针]终于等到第二针了，我马上去打
[王五，需要打第三针]第三针没有了吗，打不上，着急啊


=========== 第三针疫苗到了 =============
[李四，需要打第二针]第二针没有了吗，打不上，着急啊
[王五，需要打第三针]终于等到第三针了，我马上去打

3. 吐槽下JDK观察者模式

垃圾，主题【java.util.Observable】竟然是一个类，并且没有实现接口，只能通过继承的方式实现。违背了“多用组合，少用继承”的原则。