设计模式之观察者模式

1. 观察者模式概述

我们不断提到软件系统解耦的重要性,当减少依赖关系时,我们可以扩展、开发和测试不同的模块,而无需了解其他模块的实现,只需要知道它们实现的抽象。尽管如此,在实践中,模块是需要协同工作的,一个对象往往能够知道另一个对象的变化。例如某种商品的物价上涨时会导致部分商家高兴,而消费者会伤心。

观察者模式的定义:指多个对象间存在一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新,这种模式有时又被称为发布-订阅模式、模型视图模式。

观察者模式的优点:

  • 降低了目标和观察者之间的耦合关系,两者直接是抽象的耦合关系,符合依赖倒置原则。
  • 目标与观察者建立了一种触发机制。

观察者模式的缺点:

  • 目标与观察者之间的依赖关系并没有完全解耦,而且有可能出现循环引用。
  • 当观察者很多的时候,通知的发布会花费很长时间,影响程序的效率。

观察者模式类图如下:

设计模式之观察者模式_第1张图片

  • 抽象主题(Subject):也叫抽象目标类,它提供一个用于保存观察者对象的容器,可以增加、删除观察者,以及通知所有观察者的抽象方法。
  • 具体主题(ConcreteSubject):也叫具体目标类,它实现抽象目标中的通知方法,当主题内部状态发生改变时,通知所有注册了的观察者对象。
  • 抽象观察者(Observer):它是一个抽象类或接口,包含一个响应方法用来对主题内部状态发生改变时做出对应的反应。
  • 具体观察者(ConcreteObserver):实现抽象观察者中定义的抽象方法,以便在得到目标的更改时及时做出自己对应的反应。

2. 观察者模式案例

模拟观察者模式,当主题变更时,不同的观察者输出自己观察到主题发生变化。

2.1 抽象观察者

新建一个抽象观察者接口,定义观察者的反应行为方法,接口名称为Observer,内容如下:

public interface Observer {

    /**
     * 观察者的反应
     */
    void reponse();
}

2.2 具体观察者

新建具体观察者1实现抽象观察者接口,类名称为ConcreteObserver1,内容如下:

public class ConcreteObserver1 implements Observer {
    
    @Override
    public void reponse() {
        System.out.println("我是观察者1,观察到主题的变化......");
    }
    
}

类似的新建具体观察者2实现抽象观察者接口,类名称为ConcreteObserver2,内容如下:

public class ConcreteObserver2 implements Observer {
    
    @Override
    public void reponse() {
        System.out.println("我是观察者2,观察到主题的变化......");
    }
    
}

2.3 抽象主题

新建抽象主题类用来定义主题的行为,包括注册观察者、注销观察者、发布通知,类名称为Subject,内容如下:

public abstract class Subject {

    /**
     * 订阅列表
     */
    protected List<Observer> observers = new ArrayList<>();

    /**
     * 注册观察者
     */
    protected void attach(Observer observer){
        observers.add(observer);
    }

    /**
     * 注销观察者
     */
    protected void detach(Observer observer){
        observers.remove(observer);
    }

    /**
     * 通知观察者
     */
    protected abstract void notifyObserver();
}

2.4 具体主题

新建具体主题类继承抽象主题类,完成发布通知方法,类名称为ConcreteSubject,内容如下:

public class ConcreteSubject extends Subject {

    @Override
    protected void notifyObserver() {
        for (Observer observer : observers) {
            observer.reponse();
        }
    }
}

2.5 客户端

新建客户端进行测试,内容如下:

public class Client {
    public static void main(String[] args) {
        // 创建一个主题
        Subject subject = new ConcreteSubject();

        // 注册观察者1
        subject.attach(new ConcreteObserver1());

        // 注册观察者2
        subject.attach(new ConcreteObserver2());

        // 通知观察者主题发生变化,观察者做出对应的反应
        subject.notifyObserver();
    }
}

设计模式之观察者模式_第2张图片

3. 观察者模式应用

观察者模式普遍应用在事件监听上,当某个事件发生时事件监听者就会相应做出反应,例如上课铃声响了,老师和学生听到了会做出不同的响应。JAVA中的事件处理主要包含三种角色:

  • 事件源:产生事件的源头,即发生事件的组件,例如按钮、下拉框等。
  • 事件:一个组件某种同类型操作动作的集合,例如按钮的单击事件、按钮的双击事件。
  • 事件监听器:对发生的事件做出的反应者,是事件处理中的核心。

JAVA中事件的根抽象是EventObject,而EventListener是事件监听器的顶层抽象。

扩展观察者模式来实现事件处理过程,铃声事件源会发出上课铃事件和下课铃事件,事件监听者老师和学生会做出不同的反应。

3.1 铃声事件

新建铃声事件类继承EventObject类,类名称为RingEvent,内容如下:

public class RingEvent extends EventObject {

    /**
     * 事件特性:是否是上课铃声
     */
    private Boolean isSound;

    public RingEvent(Object source, boolean isSound) {
        super(source);
        this.isSound = isSound;
    }

    /**
     * 获取事件状态
     */
    public Boolean isSound(){
        return this.isSound;
    }
}

3.2 事件监听器

新建铃声事件监听器接口,继承EventListener接口,定义铃声事件处理的行为,接口名称为BellEventListener,内容如下:

public interface BellEventListener extends EventListener {

    /**
     * 铃声事件处理
     */
    void handleBell(RingEvent ringEvent);
}

新建具体铃声事件监听器老师,实现铃声事件监听器接口,完成老师听到老师后做出的反应,类名称为TeacherListener,内容如下:

public class TeacherListener implements BellEventListener{

    @Override
    public void handleBell(RingEvent ringEvent) {
        if (ringEvent.isSound()){
            // 上课
            System.out.println("老师:上课了,带上课件,走向教室......");
        } else {
            // 下课
            System.out.println("老师:下课了,我们下节课再讲......");
        }
    }
}

类似的新建学生铃声事件监听器,类名称为StudentListener,内容如下:

public class StudentListener implements BellEventListener{
    @Override
    public void handleBell(RingEvent ringEvent) {
        if (ringEvent.isSound()){
            // 上课
            System.out.println("学生:上课了,认真听课.......");
        } else {
            // 下课
            System.out.println("学生:下课了,上厕所吗?");
        }
    }
}

3.3 事件源

新建铃声事件源,它应该包含注册事件监听器、注销事件监听器、触发事件、通知事件监听器等行为,类名称为BellEventSource,内容如下:

public class BellEventSource {
    /**
     * 监听者列表
     */
    private List<BellEventListener> listeners;

    public BellEventSource(){
        this.listeners = new ArrayList<>();
    }

    /**
     * 注册监听者
     */
    public void registerListener(BellEventListener bellEventListener){
        listeners.add(bellEventListener);
    }

    /**
     * 注销监听者
     */
    public void removeListener(BellEventListener bellEventListener){
        listeners.remove(bellEventListener);
    }

    /**
     * 触发事件
     */
    public void ring(boolean isSound){
        System.out.println(String.format("叮叮叮......,%s了", isSound ? "上课" : "下课"));
        RingEvent event = new RingEvent(this, isSound);
        notifyListener(event);
    }

    /**
     * 通知监听者
     */
    private void notifyListener(RingEvent ringEvent){
        for (BellEventListener listener : listeners) {
            listener.handleBell(ringEvent);
        }
    }
}

3.4 客户端

新建客户端测试,内容如下:

public class Client {
    public static void main(String[] args) {
        // 创建一个事件源
        BellEventSource bellEventSource = new BellEventSource();

        // 给这个事件源注册一个教师监听器
        bellEventSource.registerListener(new TeacherListener());
        // 给这个事件源注册一个学生监听器
        bellEventSource.registerListener(new StudentListener());

        // 铃声响了,触发上课事件
        bellEventSource.ring(true);
        System.out.println("-----------------------------------------------");

        // 铃声响了,触发下课事件
        bellEventSource.ring(false);
    }
}

设计模式之观察者模式_第3张图片

你可能感兴趣的:(JAVA笔记,JAVA设计模式,JAVA,设计模式,观察者模式)