Java设计模式之行为型-观察者模式（UML类图+案例分析）

黄团团

已于 2023-07-13 17:38:15 修改

阅读量2.3k

点赞数 5

分类专栏： Java 设计模式 Spring 文章标签：设计模式观察者模式

于 2023-07-02 14:17:18 首次发布

本文链接：https://blog.youkuaiyun.com/HJW_233/article/details/131493916

版权

Java 同时被 3 个专栏收录

45 篇文章

订阅专栏

Spring

25 篇文章

订阅专栏

设计模式

22 篇文章

订阅专栏

一、基本概念

观察者先订阅被观察者对象，当被观察者的状态发生变化时，观察者可以及时收到消息，在这种模式当中，被观察者维护了一个观察者列表，并提供了添加、删除、通知观察者的方法。

二、UML类图

三、角色设计

角色	描述
抽象主题	抽象被观察者，提供注册和移除观察者、通知观察者的接口
具体主题	将有关状态存入具体观察者对象，当自己的状态发生改变时，给所有登记过的观察者发出通知
抽象观察者	定义了一个更新接口，使得在得到主题更改通知时更新自己
具体观察者	实现抽象观察者接口，以便在得到主题的通知时更新自身的状态

四、代码实现

这边我分享了三个案例，分别是通过自定义撰写、JDK源码封装和Spring框架封装三种去实现。

案例一

假设有一个被观察者：优快云博主，它有2个粉丝分别是Jack和Tom，当优快云发布了通知，对应的粉丝都会收到私信。

定义被观察者接口：

public interface Blogger {

    /**
     * 新增粉丝
     */
    void addFans(Fans fans);

    /**
     * 移除粉丝
     */
    void removeFans(Fans fans);

    /**
     * 通知粉丝
     */
    void sendMessage(String message);
}

被观察者具体实现类：

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

public class 优快云 implements Blogger {

    private List<Fans> fansList = new ArrayList<>();


    @Override
    public void addFans(Fans fans) {
        this.fansList.add(fans);
    }

    @Override
    public void removeFans(Fans fans) {
        this.fansList.remove(fans);
    }

    @Override
    public void sendMessage(String message) {
        for(Fans fans : fansList){
            fans.receiveMessage(message);
        }
    }
}

定义观察者接口：

public interface Fans {

    void receiveMessage(String message);

}

定义具体观察者实现类：

public class JackFans implements Fans {
    @Override
    public void receiveMessage(String message) {
        System.out.println("Jack收到了私信："+message);
    }
}

public class TomFans implements Fans {

    @Override
    public void receiveMessage(String message) {
        System.out.println("Tom收到了私信："+message);
    }
}

客户端：

public class Client{

    public static void main(String[] args) {
        Blogger blogger = new 优快云();
        Fans jackFans = new JackFans();
        Fans tomFans = new TomFans();
        blogger.addFans(jackFans);
        blogger.addFans(tomFans);
        blogger.sendMessage("优快云发布了《关于社区整顿的通知》");
        blogger.removeFans(jackFans);
        blogger.sendMessage("优快云发布了《关于博客发布调整的通知》");

    }
}

运行结果如下：

案例二

这个案例依旧是实现上述逻辑，只不过我们使用JDK提供的接口去实现，过程如下。

定义被观察者具体实现类：

import java.util.Observable;

public class 优快云 extends Observable {

    @Override
    public void notifyObservers(Object arg) {
        //修改状态为可以群发
        setChanged();
        //调用父类的notifyObservers 群发消息
        super.notifyObservers(arg);
    }
}

定义观察者具体实现类：

import java.util.Observable;
import java.util.Observer;

public class TomFans implements Observer {

    @Override
    public void update(Observable o, Object arg) {
        System.out.println("Tom收到了私信："+arg);
    }
}

import java.util.Observable;
import java.util.Observer;

public class JackFans implements Observer {

    @Override
    public void update(Observable o, Object arg) {
        System.out.println("Jack收到了私信："+arg);
    }
}

客户端：

import java.util.Observable;
import java.util.Observer;

public class Client{

    public static void main(String[] args) {
        Observable csdn = new 优快云();
        Observer tomFans = new TomFans();
        Observer jackFans = new JackFans();
        csdn.addObserver(tomFans);
        csdn.addObserver(jackFans);
        csdn.notifyObservers("《关于整顿社区的通知》");
        csdn.deleteObserver(tomFans);
        csdn.notifyObservers("《关于更新优快云社区的通知》");
    }
}

运行结果如下：

有了JDK提供的接口去实现，整体代码结构更简洁和方便了！

案例三

这个案例依旧是上述逻辑，只不过我们这边使用Spring提供的封装事件的监听去实现，这边省去了搭建Spring框架的流程，直接看核心代码就行！

ApplicationEvent和Listener实际上就是Spring基于观察者模式设计的发布-订阅事件模型。

ApplicationEvent ：自定义的事件对象，用于表示具体的事件。

具体代码如下：

import org.springframework.context.ApplicationEvent;

public class 优快云 extends ApplicationEvent {

    private String message;

    public 优快云(Object source,String message) {
        super(source);
        this.message = message;
    }

    public String getMessage(){
        return this.message;
    }

    public void setMessage(String message){
        this.message = message;
    }

}

ApplicationListener：事件监听器接口，用于监听特定事件：

import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class JackFans implements ApplicationListener<优快云> {
    @Override
    public void onApplicationEvent(优快云 event) {
        System.out.println("Jack收到私信："+event.getMessage());
    }
}


import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class TomFans implements ApplicationListener<优快云> {
    @Override
    public void onApplicationEvent(优快云 event) {
        System.out.println("Tom收到私信："+event.getMessage());
    }
}

单元测试：

ApplicationContext：Spring上下文，用于广播ApplicationEvent，并通知相关的ApplicationListener。

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;

import javax.annotation.Resource;

@SpringBootTest
class ObserverApplicationTests {

    @Resource
    private ApplicationContext applicationContext;

    @Test
    void contextLoads() {
        优快云 csdn = new 优快云(this,"发布了《关于整顿社区的通知》");
        applicationContext.publishEvent(csdn);
    }

}

运行结果如下：