设计模式学习01----之观察者模式

简介: 设计模式对阅读源码的重要性不言而喻,所以,我准备一边阅读源码一边学习设计模式。今天从观察者模式开始学起。

设计模式对阅读源码的重要性不言而喻,所以,我准备一边阅读源码一边学习设计模式。今天从观察者模式开始学起。


定义和结构


观察者(Observer)模式又称发布-订阅模式,发布者发布消息,订阅者接受消息,《设计模式》中给出的定义是:定义了对象之间的一对多依赖,当一个对象改变状态时,它的所有依赖者都会收到通知并自动更新。

观察者模式类图

3577185fc649c729117a0056848e3833_SouthEast.png

观察者模式的组成部分:

1. 抽象目标角色(Subject):目标角色知道它的观察者,可以有任意多个观察者观察同一个目标。并且提供注册和删除观察者对象的接口。目标角色往往由抽象类或者接口实现。

2. 抽象观察者角色(Observer):为那些在目标发生改变时需要获得通知的对象定义一个更新接口。抽象观察者角色主要有抽象类或者接口实现。‘

3. 具体目标角色(Concrete Subject):将有关状态存入各个Concrete Observer 对象。当它的状态发生改变时,向它的各个观察者发出通知。

4. 具体观察者角色(Concete Observer):存储有关状态,这些状态应与目标的状态保持一致。实现Observer的更新接口以使自身状态与目标的状态保持一致。在本角色内也可以维护一个指向Concrete Subject对象的引用。


应用场景

对一个对象状态的更新,需要其他对象同步更新,而且其他对象的数量动态可变。

对象仅需要将自己的更新通知给其他对象而不需要知道其他对象的细节。

在junit中的应用实例

TestListener在junit中充当抽象观察者角色(Observer),其定义了四个update 方法。

public interface TestListener {
    /**
     * An error occurred.
     */
    public void addError(Test test, Throwable t);
    /**
     * A failure occurred.
     */
    public void addFailure(Test test, AssertionFailedError t);  
    /**
     * A test ended.
     */
    public void endTest(Test test); 
    /**
     * A test started.
     */
    public void startTest(Test test);
}


ResultPrinter类在junit中充当具体观察者角色(Concete Observer)。

public class ResultPrinter implements TestListener {
    //省略无关代码
    ......
/**
     * @see junit.framework.TestListener#addError(Test, Throwable)
     */
    public void addError(Test test, Throwable t) {
        getWriter().print("E");
    }
    /**
     * @see junit.framework.TestListener#addFailure(Test, AssertionFailedError)
     */
    public void addFailure(Test test, AssertionFailedError t) {
        getWriter().print("F");
    }
    /**
     * @see junit.framework.TestListener#endTest(Test)
     */
    public void endTest(Test test) {
    }
    /**
     * @see junit.framework.TestListener#startTest(Test)
     */
    public void startTest(Test test) {
        getWriter().print(".");
        if (fColumn++ >= 40) {
            getWriter().println();
            fColumn= 0;
        }
    }
    // 省略无关代码
    .....
}


TestResult 在junit中充当的是目标角色。由于junit功能简单,所以junit中只有一个具体目标角色

public class TestResult extends Object {
     //这个是用来存放测试Failures的集合
    protected Vector fFailures;
    //这个是用来存放测试Errors的集合
    protected Vector fErrors;
    //这个就是用来存放注册进来的观察者的集合
    protected Vector fListeners;
    protected int fRunTests;
    private boolean fStop;
    public TestResult() {
        fFailures= new Vector();
        fErrors= new Vector();
        fListeners= new Vector();
        fRunTests= 0;
        fStop= false;
    }
    /**
     * Adds an error to the list of errors. The passed in exception
     * caused the error.
     */
    public synchronized void addError(Test test, Throwable t) {
        fErrors.addElement(new TestFailure(test, t));
         //下面就是通知各个观察者的addError方法
        for (Enumeration e= cloneListeners().elements(); e.hasMoreElements(); ) {
            ((TestListener)e.nextElement()).addError(test, t);
        }
    }
    /**
     * Adds a failure to the list of failures. The passed in exception
     * caused the failure.
     */
    public synchronized void addFailure(Test test, AssertionFailedError t) {
        fFailures.addElement(new TestFailure(test, t));
         //下面就是通知各个观察者的addFailure方法
        for (Enumeration e= cloneListeners().elements(); e.hasMoreElements(); ) {
            ((TestListener)e.nextElement()).addFailure(test, t);
        }
    }
    /**
     * Registers a TestListener
     * 注册一个观察者
     */
    public synchronized void addListener(TestListener listener) {
        fListeners.addElement(listener);
    }
    /**
     * Unregisters a TestListener
     * 删除一个观察者
     */
    public synchronized void removeListener(TestListener listener) {
        fListeners.removeElement(listener);
    }
    /**
     * Returns a copy of the listeners.
     * 返回一个观察者集合的拷贝,当然是为了防止对观察者集合的非法方式操作
     * 可以看到所有使用观察者集合的地方都通过它
     */
    private synchronized Vector cloneListeners() {
        return (Vector)fListeners.clone();
    }
    /**
     * Informs the result that a test was completed.
     */
    public void endTest(Test test) {
        for (Enumeration e= cloneListeners().elements(); e.hasMoreElements(); ) {
            ((TestListener)e.nextElement()).endTest(test);
        }
    }
//省略无关代码
....    
}


在junit中是通过TestRunner来将观察者的各角色建立真正联系的。

public class TestRunner extends BaseTestRunner {
    private ResultPrinter fPrinter;
    public TestRunner(ResultPrinter printer) {
        fPrinter= printer;
    }
    public TestResult doRun(Test suite, boolean wait) {
        TestResult result= createTestResult();
        // 在此处注册的
        result.addListener(fPrinter);
        long startTime= System.currentTimeMillis();
        suite.run(result);
        long endTime= System.currentTimeMillis();
        long runTime= endTime-startTime;
        fPrinter.print(result, runTime);
        pause(wait);
        return result;
    }
}


引用

https://blog.csdn.net/ai92/article/details/375691

https://blog.csdn.net/swengineer/article/details/6268244


相关文章
|
设计模式 监控 Java
Kotlin - 改良设计模式 - 观察者模式
Kotlin - 改良设计模式 - 观察者模式
299 3
|
11月前
|
设计模式 缓存 Java
Java设计模式(二):观察者模式与装饰器模式
本文深入讲解观察者模式与装饰器模式的核心概念及实现方式,涵盖从基础理论到实战应用的全面内容。观察者模式实现对象间松耦合通信,适用于事件通知机制;装饰器模式通过组合方式动态扩展对象功能,避免子类爆炸。文章通过Java示例展示两者在GUI、IO流、Web中间件等场景的应用,并提供常见陷阱与面试高频问题解析,助你写出灵活、可维护的代码。
|
9月前
|
设计模式 消息中间件 传感器
Java 设计模式之观察者模式:构建松耦合的事件响应系统
观察者模式是Java中常用的行为型设计模式,用于构建松耦合的事件响应系统。当一个对象状态改变时,所有依赖它的观察者将自动收到通知并更新。该模式通过抽象耦合实现发布-订阅机制,广泛应用于GUI事件处理、消息通知、数据监控等场景,具有良好的可扩展性和维护性。
658 8
|
设计模式 存储 供应链
前端必须掌握的设计模式——观察者模式
观察者模式(Observer Pattern)是一种行为型设计模式,实现了一种订阅机制。它包含两个角色:**观察者**(订阅消息、接收通知并执行操作)和**被观察者**(维护观察者列表、发送通知)。两者通过一对多的关系实现解耦,当被观察者状态改变时,会通知所有订阅的观察者。例如,商店老板作为被观察者,记录客户的需求并在商品到货时通知他们。前端应用中,如DOM事件注册、MutationObserver等也体现了这一模式。
|
设计模式 监控 Java
Kotlin教程笔记(52) - 改良设计模式 - 观察者模式
Kotlin教程笔记(52) - 改良设计模式 - 观察者模式
|
设计模式 消息中间件 存储
【设计模式】【行为型模式】观察者模式(Observer)
一、入门 什么是观察者模式? 观察者模式(Observer Pattern)是一种行为设计模式,它定义了对象之间的一对多依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都会收到通知并自动更新。
544 9
|
设计模式 消息中间件 存储
设计模式:观察者模式
观察者模式属于行为型设计模式,用于建立对象间的一对多依赖关系。当主题(Subject)状态变化时,所有依赖的观察者(Observer)会自动收到通知并更新。
|
设计模式 消息中间件 搜索推荐
Java 设计模式——观察者模式:从优衣库不使用新疆棉事件看系统的动态响应
【11月更文挑战第17天】观察者模式是一种行为设计模式,定义了一对多的依赖关系,使多个观察者对象能直接监听并响应某一主题对象的状态变化。本文介绍了观察者模式的基本概念、商业系统中的应用实例,如优衣库事件中各相关方的动态响应,以及模式的优势和实际系统设计中的应用建议,包括事件驱动架构和消息队列的使用。
368 6
|
设计模式 监控 Java
Kotlin教程笔记(52) - 改良设计模式 - 观察者模式
Kotlin教程笔记(52) - 改良设计模式 - 观察者模式
164 1
|
设计模式 监控 Java
Kotlin教程笔记(52) - 改良设计模式 - 观察者模式
Kotlin教程笔记(52) - 改良设计模式 - 观察者模式
151 3

热门文章

最新文章