JUnit源码分析（二）——观察者模式

    我们知道JUnit支持不同的使用方式：swt、swing的UI方式，甚至控制台方式，那么对于这些不同的UI我们如何提供统一的接口供它们获取测试过程的信息（比如出现的异常信息，测试成功，测试失败的代码行数等等）？我们试想一下这个场景，当一个error或者exception产生的时候，测试能够马上通知这些UI客户端：发生错误了，发生了什么错误，错误是什么等等。显而易见，这是一个订阅-发布机制应用的场景，应当使用观察者模式。那么什么是观察者模式呢？

观察者模式(Observer)

Observer是对象行为型模式之一

1.意图：定义对象间的一种一对多的依赖关系，当一个对象的状态发现改变时，所有依赖于它的对象都得到通知并被自动更新

2.适用场景：
1）当一个抽象模型有两个方面，其中一个方面依赖于另一个方面，通过观察者模式将这两者封装在不同的独立对象当中，以使它们可以独立的变化和复用
2）当一个对象改变时，需要同时改变其他对象，并且不知道其他对象的具体数目
3）当一个对象需要引用其他对象，但是你又不想让这个对象与其他对象产生紧耦合的时候

3.UML图：
                 
   Subject及其子类维护一个观察者列表，当需要通知所有的Observer对象时调用Nitify方法遍历Observer集合，并调用它们的update方法更新。而具体的观察者实现Observer接口（或者抽象类），提供具体的更新行为。其实看这张图，与Bridge有几分相似，当然两者的意图和适用场景不同。

4.效果：
1）目标和观察者的抽象耦合,目标仅仅与抽象层次的简单接口Observer松耦合，而没有与具体的观察者紧耦合
2）支持广播通信
3）缺点是可能导致意外的更新，因为一个观察者并不知道其他观察者，它的更新行为也许将导致一连串不可预测的更新的行为

5.对于观察者实现需要注意的几个问题：
1）谁来触发更新？最好是由Subject通知观察者更新，而不是客户，因为客户可能忘记调用Notify
2)可以通过显式传参来指定感兴趣的更新
3）在发出通知前，确保Subject对象状态的一致性，也就是Notify操作应该在最后被调用
4）当Subject和Observer的依赖关系比较复杂的时候，可以通过一个更新管理器来管理它们之间的关系，这是与中介者模式的结合应用。


    讨论完观察者模式，那我们来看JUnit是怎么实现这个模式的。在junit.framework包中我们看到了一个Observer接口——TestListener，看看它的代码：

<!---->package junit.framework;

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

    接口清晰易懂，就是一系列将测试过程的信息传递给观察者的操作。具体的子类将接受这些信息，并按照它们的方式显示给用户。
     比如，我们看看swing的UI中的TestRunner，它将这些信息显示在一个swing写的UI界面上：

<!---->    public void startTest(Test test) {
        showInfo("Running: "+test);
    }

    public void addError(Test test, Throwable t) {
        fNumberOfErrors.setText(Integer.toString(fTestResult.errorCount()));
        appendFailure("Error", test, t);
    }
    public void addFailure(Test test, Throwable t) {
        fNumberOfFailures.setText(Integer.toString(fTestResult.failureCount()));
        appendFailure("Failure", test, t);
    }
    public void endTest(Test test) {
        setLabelValue(fNumberOfRuns, fTestResult.runCount());
        fProgressIndicator.step(fTestResult.wasSuccessful());
    }

可以看到，它将错误信息，异常信息保存在List或者Vector集合内，然后显示在界面上：

<!---->private void showErrorTrace() {
        int index= fFailureList.getSelectedIndex();
        if (index == -1)
            return;
    
        Throwable t= (Throwable) fExceptions.elementAt(index);
        if (fTraceFrame == null) {
            fTraceFrame= new TraceFrame();
            fTraceFrame.setLocation(100, 100);
           }
        fTraceFrame.showTrace(t);
        fTraceFrame.setVisible(true);
    }
    private void showInfo(String message) {
        fStatusLine.setFont(PLAIN_FONT);
        fStatusLine.setForeground(Color.black);
        fStatusLine.setText(message);
    }
    private void showStatus(String status) {
        fStatusLine.setFont(BOLD_FONT);
        fStatusLine.setForeground(Color.red);
        fStatusLine.setText(status);
    }

而Junit中的目标对象(Subject）就是TestResult对象，它有添加观察者的方法：

<!---->/**
     * Registers a TestListener
     */
    public synchronized void addListener(TestListener listener) {
        fListeners.addElement(listener);
    }

而通知观察者又是怎么做的呢？请看这几个方法，都是循环遍历观察者列表，并调用相应的更新方法：

<!---->/**
     * 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));
        for (Enumeration e = fListeners.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));
        for (Enumeration e = fListeners.elements(); e.hasMoreElements();) {
            ((TestListener) e.nextElement()).addFailure(test, t);
        }
    }

    /**
     * Registers a TestListener
     */
    public synchronized void addListener(TestListener listener) {
        fListeners.addElement(listener);
    }

    /**
     * Informs the result that a test was completed.
     */
    public synchronized void endTest(Test test) {
        for (Enumeration e = fListeners.elements(); e.hasMoreElements();) {
            ((TestListener) e.nextElement()).endTest(test);
        }
    }

使用这个模式后带来的好处：
1)上面提到的Subject与Observer的抽象耦合，使JUnit可以支持不同的使用方式
2）支持了广播通信，目标对象不关心有多少对象对自己注册，它只是通知注册的观察者

最后，我实现了一个简单的ConsoleRunner，在控制台执行JUnit,比如我们写了一个简单测试：

<!---->package junit.samples;

import junit.framework.*;

/**
 * Some simple tests.
 * 
 */
public class SimpleTest extends TestCase {
    protected int fValue1;

    protected int fValue2;

    public SimpleTest(String name) {
        super(name);
    }

    public void setUp() {
        fValue1 = 2;
        fValue2 = 3;
    }

    public void testAdd() {
        double result = fValue1 + fValue2;
        assert(result == 5);
    }


    public void testEquals() {
        assertEquals(12, 12);
        assertEquals(12L, 12L);
        assertEquals(new Long(12), new Long(12));

        assertEquals("Size", 12, 12);
        assertEquals("Capacity", 12.0, 11.99, 0.01);
    }
}

使用ConsoleRunner调用这个测试，代码很简单，不多做解释了：

<!---->package net.rubyeye.junit.framework;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;

import junit.framework.Test;
import junit.framework.TestListener;
import junit.framework.TestResult;
import junit.samples.SimpleTest;
//实现观察者接口
public class ConsoleRunner implements TestListener {

    private TestResult fTestResult;

    private Vector fExceptions;

    private Vector fFailedTests;

    private List fFailureList;

    public ConsoleRunner() {
        fExceptions = new Vector();
        fFailedTests = new Vector();
        fFailureList = new ArrayList();
    }

    public void endTest(Test test) {
        System.out.println("测试结束：");
        String message = test.toString();
        if (fTestResult.wasSuccessful())
            System.out.println(message + " 测试成功!");
        else if (fTestResult.errorCount() == 1)
            System.out.println(message + " had an error");
        else
            System.out.println(message + " had a failure");

        for (int i = 0; i < fFailureList.size(); i++) {
            System.out.println(fFailureList.get(i));
        }
        for (int i = 0; i < fFailedTests.size(); i++) {
            System.out.println(fFailureList.get(i));
        }
        for (int i = 0; i < fExceptions.size(); i++) {
            System.out.println(fFailureList.get(i));
        }

        System.out.println("------------------------");
    }

    public void startTest(Test test) {
        System.out.println("开始测试:" + test);
    }

    public static TestResult createTestResult() {
        return new TestResult();
    }

    private String truncateString(String s, int length) {
        if (s.length() > length)
            s = s.substring(0, length) + "";
        return s;
    }

    public void addError(Test test, Throwable t) {
        System.out.println(fTestResult.errorCount());
        appendFailure("Error", test, t);
    }

    public void addFailure(Test test, Throwable t) {
        System.out.println(fTestResult.failureCount());
        appendFailure("Failure", test, t);
    }

    private void appendFailure(String kind, Test test, Throwable t) {
        kind += ": " + test;
        String msg = t.getMessage();
        if (msg != null) {
            kind += ":" + truncateString(msg, 100);
        }
        fFailureList.add(kind);
        fExceptions.addElement(t);
        fFailedTests.addElement(test);
    }

    public void go(String args[]) {
        Method[] methods = SimpleTest.class.getDeclaredMethods();

        for (int i = 0; i < methods.length; i++) {
            //取所有以test开头的方法
            if (methods[i].getName().startsWith("test")) {
                Test test = new SimpleTest(methods[i].getName());
                fTestResult = createTestResult();
                fTestResult.addListener(ConsoleRunner.this);
                //执行测试
                test.run(fTestResult);
            }
        }

    }

    public static void main(String args[]) {
        new ConsoleRunner().go(args);
    }

}

dennis 2007-04-05 17:19 发表评论