Java中常用的设计模式之观察者模式详解

目录

• 优点
• 缺点
• 使用场景
• 注意事项
• 一、实现方式
• 1、观察者抽象类
• 2、第一个观察者
• 3、第二个观察者
• 4、第三个观察者
• 5、定义主题
• 二、测试
• 总结

优点

1.观察者和被观察者是抽象耦合的。

2.建立一套触发机制。

缺点

1.如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。

2.如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。

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

使用场景

一个抽象模型有两个方面，其中一个方面依赖于另一个方面。将这些方面封装在独立的对象中使它们可以各自独立地改变和复用。

一个对象的改变将导致其他一个或多个对象也发生改变，而不知道具体有多少对象将发生改变，可以降低对象之间的耦合度。

一个对象必须通知其他对象，而并不知道这些对象是谁。

需要在系统中创建一个触发链，A对象的行为将影响B对象，B对象的行为将影响C对象……，可以使用观察者模式创建一种链式触发机制。

注意事项

1.JAVA 中已经有了对观察者模式的支持类。

2.避免循环引用。

3.如果顺序执行，某一观察者错误会导致系统卡壳，一般采用异步方式。

一、实现方式

1、观察者抽象类

package com.asurplus.common.observe;
/**
 * 观察者
 */
public abstract class Observer {
    protected Subject subject;
    /**
     * 发布事件
     */
    public abstract void update();
}

2、第一个观察者

package com.asurplus.common.observe;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class Observer1 extends Observer {
    public Observer1(Subject subject) {
        this.subject = subject;
        this.subject.attach(this);
    }
    @Override
    public void update() {
        log.info("观察者 1 收到通知：{}", this.subject.getState());
    }
}

3、第二个观察者

package com.asurplus.common.observe;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class Observer2 extends Observer {
    public Observer2(Subject subject) {
        this.subject = subject;
        this.subject.attach(this);
    }
    @Override
    public void update() {
        log.info("观察者 2 收到通知：{}", this.subject.getState());
    }
}

4、第三个观察者

package com.asurplus.common.observe;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class Observer3 extends Observer {
    public Observer3(Subject subject) {
        this.subject = subject;
        this.subject.attach(this);
    }
    @Override
    public void update() {
        log.info("观察者 3 收到通知：{}", this.subject.getState());
    }
}

5、定义主题

package com.asurplus.common.observe;
import java.util.ArrayList;
import java.util.List;
/**
 * 主题
 */
public class Subject {
    /**
     * 观察者列表
     */
    private List<Observer> observers = new ArrayList<>();
    /**
     * 标志
     */
    private int state;
    public int getState() {
        return state;
    }
    /**
     * 标识被改变
     *
     * @param state
     */
    public void setState(int state) {
        this.state = state;
        // 通知所有观察者
        notifyAllObservers();
    }
    /**
     * 添加进接收者列表
     *
     * @param observer
     */
    public void attach(Observer observer) {
        observers.add(observer);
    }
    /**
     * 通知所有人被改变
     */
    public void notifyAllObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

类似于消息发布一样，有多个接收者，当标志位被改变的时候，通知多个接收者。

二、测试

package com.asurplus.common.observe;
public class TestMain {
    public static void main(String[] args) {
        // 创建主题
        Subject subject = new Subject();
        // 添加观察者
        new Observer1(subject);
        new Observer2(subject);
        new Observer3(subject);
        // 改变标志
        subject.setState(10);
    }
}

输出结果

可以看出，三个接收者都收到了事件通知，从而实现了我们的观察者模式。

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注我们的更多内容!