观察者模式

2020-08-05

字数统计: 1.6k字 | 阅读时长≈ 7分

观察者模式定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖与他的对象都会得到通知并被自动更新。

1. 观察者模式的定义

观察者模式又称发布-订阅(Publish/Subscribe)模式。观察者模式定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖与他的对象都会得到通知并被自动更新。这里的一对多分别指被观察者和观察者，其中一个重要的因素就是解耦。也就是将被观察者和观察者进行解耦，使得他们之间的依赖性更小。

观察者模式主要有一下几个角色：

Subject被观察者

定义被观察者必须实现的职责，他必须能够动态地增加、取消观察者。他一般是抽象类或者是实现类，仅仅完成作为被观察者必须实现的职责：管理观察者并通知观察者。
Observer观察者

观察者收到消息后，进行update(更新方法)，对接收到的信息处理。
ConcreteSubject具体的被观察者

定义被观察者自己的业务逻辑，同时定义对哪些事件进行通知。
ConcreteObserver具体的观察者
每个观察者在接收到消息后的处理反应是不同的，各个观察者都有自己的处理逻辑。

2. 通用观察者实现

2.1 被观察者

public abstract class Subject {

    //定义一个观察这数组
    private Vector<Observer> obVector = new Vector<>();

    //添加一个观察者
    public void addObserver(Observer observer) {
        this.obVector.add(observer);
    }

    //删除一个观察者
    public void delObserver(Observer observer) {
        this.obVector.remove(observer);
    }

    //通知所有观察者
    public void notifyObservers(Book book) {
        for (Observer observer : obVector) {
            observer.update(book);
        }
    }
}

2.2 具体的被观察者

public class ConcreteSubject extends Subject{

    // 具体业务
    public void doSomething() {
        super.notifyObservers();
    }
}

2.3 观察者

1
2
3

public interface Observer {
    public void update();
}

2.4 具体观察者

public class ConcreteObserver implements Observer{
    //实现更新方法
    @Override
    public void update() {
        System.out.println("我已接收到消息");
    }
}

2.5 场景类

public class Client {

    public static void main(String[] args) {
        // 创建一个被观察者
        ConcreteSubject subject = new ConcreteSubject();
        // 创建一个观察者
        Observer observer = new ConcreteObserver();
        // 观察者观察被观察者
        subject.addObserver(observer);
        // 观察者开始活动
        subject.doSomething();
    }
}

3. 具体案例

韩非子作为被观察者，李斯、王斯、刘斯作为观察者

3.1 观察者接口

public interface Observer {
    // 一发现别人有动静，自己也要行动起来
    public void update(String context);
}

3.2 被观察者接口

public interface IHanFeiZi {
    public void haveBreakfast();
    public void haveFun();
}

public interface Observable {
    // 增加一个观察者
    public void addObserver(Observer observer);
    // 删除一个观察者
    public void deteleObserver(Observer observer);
    // 通知观察者
    public void notifyObservers(String context);
}

3.3 被观察者实现类

public class HanFeiZi implements Observable, IHanFeiZi {
    private ArrayList<Observer> observerList = new ArrayList<>();
    
    // 增加观察者
    @Override
    public void addObserver(Observer observer) {
        this.observerList.add(observer);
    }

    // 删除观察者
    @Override
    public void deteleObserver(Observer observer) {
        this.observerList.remove(observer);
    }

    // 通知所有的观察者
    @Override
    public void notifyObservers(String context) {
        for (Observer observer : observerList) {
            observer.update(context);
        }
    }

    // 韩非子吃饭
    @Override
    public void haveBreakfast() {
        System.out.println("韩非子：开始吃饭了");
        this.notifyObservers("韩非子在吃饭");
    }

    // 韩非子娱乐
    @Override
    public void haveFun() {
        System.out.println("韩非子开始娱乐了");
        this.notifyObservers("韩非子在娱乐");
    }
}

3.4 观察者实现类

public class Lisi implements Observer {

    @Override
    public void update(String context) {
        System.out.println("观察到韩非子活动");
    }
}

public class Wangsi implements Observer {

    @Override
    public void update(String context) {
        System.out.println("观察到韩非子活动");
    }
}

public class Liusi implements Observer {

    @Override
    public void update(String context) {
        System.out.println("观察到韩非子活动");
    }
}

3.5 场景类

public class Client {
    // 创建三个观察者
    Observer liSi = new Lisi();
    Observer wangSi = new Wangsi();
    Observer liuSi = new Liusi();
    // 创建被观察者
    HanFeiZi hanFeiZi = new HanFeiZi();
    // 为韩非子增加观察者
    hanFeiZi.addObserver(liSi);
    hanFeiZi.addObserver(wangSi);
    hanFeiZi.addObserver(liuSi);
    
    hanFeiZi.haveBreakfast();
    hanFeiZi.haveFun();
}

4. 观察者模式的优缺点

优点

观察者和被观察者之间是抽象耦合

建立了一套触发机制
缺点

观察者太多会影响运行效率，一旦其中一个观察者卡壳，会影响到整体的执行效率，在这种情况下一般采取异步方式。

多级触发会影响运行效率。

5. 观察者模式的应用：

文件系统：在一个目录下新建立一个文件，文件是被观察者，文件管理器是观察者

猫鼠游戏：猫叫了一声，吓走老鼠，吵醒了人；猫是被观察者，老鼠和人是观察者

5.1 SpringBoot中基于接口的观察者模式

消息类型实体(需要继承ApplicationEvent )

public class Event extends ApplicationEvent {
    public Event(Object source) {
        super(source);
    }
}

创建监听者

@Component
public class Listener implements ApplicationListener<Event> {

    @Override
    @Async
    public void onApplicationEvent(Event event) {
        String s = event.getSource().toString();
        System.out.println("旭旭宝宝面板:" + s);
    }
}

@Component
public class Listenercopy implements ApplicationListener<Event> {

    @Override
    @Async
    public void onApplicationEvent(Event event) {
        String s = event.getSource().toString();
        System.out.println("枪魂冰子面板:" + s);
    }
}

@Component
public class Listenercopy2 implements ApplicationListener<Event> {

    @Override
    @Async
    public void onApplicationEvent(Event event) {
        String s = event.getSource().toString();
        System.out.println("剑舞红颜笑面板: " + s);
    }
}

消息发布：

@Component
public class Publisher implements CommandLineRunner {

    private final ApplicationEventPublisher applicationEventPublisher;

    @Autowired
    public Publisher(ApplicationEventPublisher applicationEventPublisher) {
        this.applicationEventPublisher = applicationEventPublisher;
    }

    @Override
    public void run(String... args) throws Exception {
        try {
            applicationEventPublisher.publishEvent(new Event("XXX强化别云剑-无用 +16失败！"));
        }
        catch (Exception ignore) {
        }
    }
}

输出

1
2
3

旭旭宝宝面板:XXX强化别云剑-无用 +16失败！
枪魂冰子面板:XXX强化别云剑-无用 +16失败！
剑舞红颜笑面板: XXX强化别云剑-无用 +16失败！

5.2 SpringBoot基于注解的观察者模式

事件监听不在用ApplicationListener接口，而是基于注解@EventListener驱动

@Component
public class OrderCreateEventListenerAnnotation {
    
    @EventListener
    public void orderCreateEvent(OrderCreateEvent event) {
        System.out.println("订单创建事件，@EventListener 注解驱动实现");
    }
}

如果在方法内没有使用事件对象，方法上也可以去掉它，但是要指定这个方法监听的是哪个事件类。如：

@Component
public class OrderCreateEventListenerAnnotation {
    @EventListener(OrderCreateEvent.class)
    public void orderCreateEvent() {
        System.out.println("订单创建事件，@EventListener 注解驱动实现");
    }
}

本文作者： zicair
本文链接： https://zicair.github.io/2020/08/05/观察者模式/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！