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);
    }

}