设计模式—观察者模式

发布时间:2023年12月17日

观察者模式(Observer Pattern)是一种行为型设计模式,它定义了一种一对多的依赖关系,使得当一个对象的状态发生变化时,所有依赖于它的对象都会得到通知并自动更新。

在观察者模式中,有两个核心角色:

  1. Subject(主题):也称为被观察者或可观察对象,它是具有状态的对象,当其状态发生变化时,会通知所有的观察者。

  2. Observer(观察者):也称为订阅者或观察者,它定义了一个接口,用于接收主题的通知,并进行相应的处理。

观察者模式的工作原理如下:

  1. 主题维护一个观察者列表,用于存储所有订阅该主题的观察者。

  2. 当主题的状态发生变化时,会遍历观察者列表,依次调用每个观察者的更新方法。

  3. 观察者收到通知后,根据主题的状态进行相应的处理。

观察者模式的优点包括:

  • 解耦性:主题和观察者之间是松耦合的,它们可以独立地进行扩展和修改,互不影响。

  • 可扩展性:可以方便地增加新的观察者,以及在不修改主题代码的情况下增加新的主题。

  • 易于维护:由于主题和观察者之间的关系是明确的,代码的维护和调试相对容易。

举个例子:被观察者=新闻,观察者有“播放新闻”和“打印新闻”,当有新的新闻产生时,立刻播放和打印新闻。(建议尽量面向抽象编程、接口编程)

先定义观察者和被观察者的抽象类。

/**
 * 观察者抽象
 */
public abstract class Observer {

    /**
     * 处理新闻内容
     * @param msg
     */
    public abstract void handle(String msg);

    /**
     * 观察者的身份
     * @return
     */
    public abstract String identity();
}
/**
 * 被观察者抽象
 */
public abstract class Subject {

    /**
     * 观察者列表
     */
    public List<Observer> observerList;

    /**
     * 加入观察者
     * @param observer
     */
    public abstract void register(Observer observer);

    /**
     * 剔除观察者
     * @param observer
     */
    public abstract void cancel(Observer observer);

    /**
     * 通知内容
     * @param msg
     */
    public abstract void notice(String msg);
}

再定义新闻类,继承了被观察者抽象类,表示自己是某个具有实际业务含义的被观察者。

public class News extends Subject {

    public News() {
        this.observerList = new ArrayList<>();
    }

    @Override
    public void register(Observer observer) {
        this.observerList.add(observer);
    }

    @Override
    public void cancel(Observer observer) {
        for (Observer ob : this.observerList) {
            if (ob.identity().equals(observer.identity())) {
                this.observerList.remove(ob);
            }
        }
    }

    @Override
    public void notice(String msg) {
        for (Observer ob : this.observerList) {
            ob.handle(msg);
        }
    }
}

定义播放新闻类和打印新闻类,表示具体的观察者。

public class PlayNews extends Observer {

    Logger logger = LoggerFactory.getLogger(PlayNews.class);

    @Override
    public void handle(String msg) {
        logger.info("播放新闻:{}", msg);
    }

    @Override
    public String identity() {
        return "play";
    }
}


public class PrintNews extends Observer {

    Logger logger = LoggerFactory.getLogger(PrintNews.class);

    @Override
    public void handle(String msg) {
        logger.info("打印新闻:{}", msg);
    }

    @Override
    public String identity() {
        return "print";
    }
}

测试一下:

public class Test {

    public static void main(String[] args) {
        News news = new News();
        PlayNews playNews = new PlayNews();
        PrintNews printNews = new PrintNews();
        news.register(playNews);
        news.register(printNews);
        news.notice("油价微涨1元");

        news.cancel(playNews);
        news.notice("油价暴跌1分");
    }
}

个人理解:

1、观察者模式类似于发布-订阅,需要被观察者发出信息让观察者去处理,但是又与发布-订阅模式不同,观察者与被观察者是直接联系,互相有感知,中间没有第三方角色存在,而发布-订阅模式中,发布者与订阅者之间有第三方角色存在,比如kafka中,生产者发送消息到 topic,消费者从topic获取消息,而不是生产者直接发消息给消费者,更多地是体现发布者与订阅者之间的相互无感知,解耦,以及异步机制。

2、观察者模式的亮点在于它的“加入观察者”、“剔除观察者”思想,适合那些观察者随时可变的场景,否则就没什么特点可言了,还不如策略模式。

文章来源:https://blog.csdn.net/dgh112233/article/details/134958116
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。