JUnit4-Result.java 源代码 解读与分析

以下是涉及到的知识点
1. 原子类
2. CopyOnWriteArrayList 写时复制
3. 序列化的控制
方式1：实现Externalizable接口(代替Serializable)–**重载**writeExternal(ObjectOutput out)方法和readExternal(ObjectInput in)方法
方式2 : 在要序列化的对象上**添加**readObject(ObjectInputStream in), writeObject(ObjectOutputStream out), readResolve等方法。

作用域

    private final AtomicInteger count;  //测试个数    private final AtomicInteger ignoreCount;//被忽略的测试个数    private final CopyOnWriteArrayList<Failure> failures; //测试异常    private final AtomicLong runTime; //运行时间    private final AtomicLong startTime; //开始时间

这里使用原子类，AtomicInteger或者AtomicLong，保证对这些变量访问时的线程安全。

//AtomicInteger 的常用方法int addAndGet(int delta)  // 原值基础上增加deltaint decrementAndGet()  // 自减后取值int incrementAndGet() // 自增后取值int get() //取得当前值int set(val) //设置指定值//以下是先取值，然后操作int getAndAdd(int delta)int getAndIncrement()int getAndDecrement()

CopyOnWriteArrayList 是一种写时复制的容器，就是容器在写时，先拷贝原数组到新数组中，在新数组中进行写入操作，最后修改引用指向新数组。在写时还是要有锁的，不过读取的时候就不需要加锁了。在多线程情况下，同步读和写，读到的还是原来的内容(引用的修改还没有完成的话)。这样也能够保证线程安全。如下是，set, add, get方法的源码

public class CopyOnWriteArrayList<E>    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {    public E set(int index, E element) {        final ReentrantLock lock = this.lock;        lock.lock();        try {            Object[] elements = getArray();            E oldValue = get(elements, index);            if (oldValue != element) {                int len = elements.length;                Object[] newElements = Arrays.copyOf(elements, len);                newElements[index] = element;                setArray(newElements);            } else {                // Not quite a no-op; ensures volatile write semantics                setArray(elements);            }            return oldValue;        } finally {            lock.unlock();        }    }    public boolean add(E e) {        final ReentrantLock lock = this.lock;        lock.lock();        try {            Object[] elements = getArray();            int len = elements.length;            Object[] newElements = Arrays.copyOf(elements, len + 1);            newElements[len] = e;            setArray(newElements);            return true;        } finally {            lock.unlock();        }    }    private E get(Object[] a, int index) {        return (E) a[index];    }    public E get(int index) {        return get(getArray(), index);    }}

内置的监听器

Listener是Result的私有内部类, 通知者中的第一个监听器就是它，用于测试时的实时统计。
由于Listener的外围类Result的作用域是线程安全访问的，所以Listener是线程安全的，有@RunListener.ThreadSafe注解，就不用再额外封装到SynchronizedRunListener中了。

public class JUnitCore {    public Result run(Runner runner) {        Result result = new Result();        RunListener listener = result.createListener();        notifier.addFirstListener(listener);        try {            notifier.fireTestRunStarted(runner.getDescription());            runner.run(notifier);            notifier.fireTestRunFinished(result);        } finally {            removeListener(listener);        }        return result;    }}

    @RunListener.ThreadSafe    private class Listener extends RunListener {        @Override        public void testRunStarted(Description description) throws Exception {            startTime.set(System.currentTimeMillis());        }        @Override        public void testRunFinished(Result result) throws Exception {            long endTime = System.currentTimeMillis();            runTime.addAndGet(endTime - startTime.get());        }        @Override        public void testFinished(Description description) throws Exception {            count.getAndIncrement();        }        @Override        public void testFailure(Failure failure) throws Exception {            failures.add(failure);        }        @Override        public void testIgnored(Description description) throws Exception {            ignoreCount.getAndIncrement();        }        @Override        public void testAssumptionFailure(Failure failure) {            // do nothing: same as passing (for 4.5; may change in 4.6)        }    }

序列化和反序列化还原

由于Result方法中有readObject, writeObject, readResolve方法，那么在序列化Result时, ObjectInputStream.readObject(result) 时，会自动调用result中自定义的readOjbect和readResolve方法，ObjectOutputStream.writeObject(result), 会自动调用result中的writeObject方法，进行对象的序列化。
在实现了Serializable接口的对象中，添加这几个方法，用于对序列化控制。在对象writeObject中，可以调用defaultWriteObject()来选择执行默认的writeObject()方法。同样defaultReadObject()执行默认的readObject()。这样我们可以在原先序列化的基础上进行扩展。
Result 将需要序列化的作用域引入到了私有嵌套类SerializedForm中，用于帮助Result的序列化。

public class Result implements Serializable {    private SerializedForm serializedForm;    private Result(SerializedForm serializedForm) {    }    private void writeObject(ObjectOutputStream s) throws IOException {        SerializedForm serializedForm = new SerializedForm(this);        serializedForm.serialize(s);    }    private void readObject(ObjectInputStream s)            throws ClassNotFoundException, IOException {        serializedForm = SerializedForm.deserialize(s);    }    private Object readResolve()  {        return new Result(serializedForm);    }    private static class SerializedForm implements Serializable {        public SerializedForm(Result result) {                }        private SerializedForm(ObjectInputStream.GetField fields) throws IOException {            fCount = (AtomicInteger) fields.get("fCount", null);        }        public void serialize(ObjectOutputStream s) throws IOException {        }        public static SerializedForm deserialize(ObjectInputStream s)                throws ClassNotFoundException, IOException {        }    }}

如下，是一个测试。正常情况下transient瞬时量是不会被序列化的，但是通过对序列化的控制，我们仍能够将其序列化保存。

/** * 序列化控制 * 序列化 & 反序列化还原 * @author live * Create on 17-8-12 */public class SerializedDemo implements Serializable {    private static final long serialVersionUID = 1L;    private final String name;    private transient String tran;    private SerializedForm serializedForm;    public SerializedDemo(String name, String tran) {        this.name = name;        this.tran = tran;    }    public SerializedDemo(SerializedForm serializedForm) {        this.name = serializedForm.name;        this.tran = serializedForm.tran;    }    private void writeObject(ObjectOutputStream outputStream) throws IOException {        System.out.println("Hello, This is in the writeObject Function.");        SerializedForm form = new SerializedForm(this);        form.serialize(outputStream);    }    private void readObject(ObjectInputStream inputStream) throws ClassNotFoundException, IOException {        System.out.println("Hello, This is in the readObject Function.");        serializedForm = SerializedForm.deserialize(inputStream);    }    private Object readResolve() {        System.out.println("This is in the readResolve Function.");        return new SerializedDemo(serializedForm);    }    @Override    public String toString() {        return String.format("{name:%s, tran:%s}", name, tran);    }    private static class SerializedForm implements Serializable {        private final String name;        private final String tran;        public SerializedForm(SerializedDemo demo) {            this.name = demo.name;            this.tran = demo.tran;        }        public SerializedForm(ObjectInputStream inputStream) throws ClassNotFoundException, IOException{            ObjectInputStream.GetField fields = inputStream.readFields();            name = (String) fields.get("name", "null");            //tran = (String) fields.get("tran", "null");            tran =  (String)inputStream.readObject();        }        public void serialize(ObjectOutputStream outputStream) throws IOException {            ObjectOutputStream.PutField fields = outputStream.putFields();            fields.put("name", this.name);            outputStream.writeFields();            //fields.put("tran", this.tran);            outputStream.writeObject(tran);        }        public static SerializedForm deserialize(ObjectInputStream inputStream) throws ClassNotFoundException, IOException {            return new SerializedForm(inputStream);        }    }    public static void main(String[] args) throws ClassNotFoundException, IOException {        final String fileName = "SerializedDemo.out";        SerializedDemo serializedDemo = new SerializedDemo("序列化与反序列化还原", "瞬时量");        ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(fileName));        outputStream.writeObject(serializedDemo);        outputStream.close();        ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(fileName));        SerializedDemo deSerializedDemo = (SerializedDemo) inputStream.readObject();        //        System.out.println(serializedDemo);        System.out.println(deSerializedDemo);    }}

完整代码

import java.io.IOException;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;import java.io.ObjectStreamClass;import java.io.ObjectStreamField;import java.io.Serializable;import java.util.ArrayList;import java.util.Collections;import java.util.List;import java.util.concurrent.CopyOnWriteArrayList;import java.util.concurrent.atomic.AtomicInteger;import java.util.concurrent.atomic.AtomicLong;import org.junit.runner.notification.Failure;import org.junit.runner.notification.RunListener;/** * A <code>Result</code> collects and summarizes information from running multiple tests. * All tests are counted -- additional information is collected from tests that fail. * * @since 4.0 */public class Result implements Serializable {    private static final long serialVersionUID = 1L;    private static final ObjectStreamField[] serialPersistentFields =            ObjectStreamClass.lookup(SerializedForm.class).getFields();    private final AtomicInteger count;    private final AtomicInteger ignoreCount;    private final CopyOnWriteArrayList<Failure> failures;    private final AtomicLong runTime;    private final AtomicLong startTime;    /** Only set during deserialization process. */    private SerializedForm serializedForm;    public Result() {        count = new AtomicInteger();        ignoreCount = new AtomicInteger();        failures = new CopyOnWriteArrayList<Failure>();        runTime = new AtomicLong();        startTime = new AtomicLong();    }    private Result(SerializedForm serializedForm) {        count = serializedForm.fCount;        ignoreCount = serializedForm.fIgnoreCount;        failures = new CopyOnWriteArrayList<Failure>(serializedForm.fFailures);        runTime = new AtomicLong(serializedForm.fRunTime);        startTime = new AtomicLong(serializedForm.fStartTime);    }    /**     * @return the number of tests run     */    public int getRunCount() {        return count.get();    }    /**     * @return the number of tests that failed during the run     */    public int getFailureCount() {        return failures.size();    }    /**     * @return the number of milliseconds it took to run the entire suite to run     */    public long getRunTime() {        return runTime.get();    }    /**     * @return the {@link Failure}s describing tests that failed and the problems they encountered     */    public List<Failure> getFailures() {        return failures;    }    /**     * @return the number of tests ignored during the run     */    public int getIgnoreCount() {        return ignoreCount.get();    }    /**     * @return <code>true</code> if all tests succeeded     */    public boolean wasSuccessful() {        return getFailureCount() == 0;    }    private void writeObject(ObjectOutputStream s) throws IOException {        SerializedForm serializedForm = new SerializedForm(this);        serializedForm.serialize(s);    }    private void readObject(ObjectInputStream s)            throws ClassNotFoundException, IOException {        serializedForm = SerializedForm.deserialize(s);    }    private Object readResolve()  {        return new Result(serializedForm);    }    @RunListener.ThreadSafe    private class Listener extends RunListener {        @Override        public void testRunStarted(Description description) throws Exception {            startTime.set(System.currentTimeMillis());        }        @Override        public void testRunFinished(Result result) throws Exception {            long endTime = System.currentTimeMillis();            runTime.addAndGet(endTime - startTime.get());        }        @Override        public void testFinished(Description description) throws Exception {            count.getAndIncrement();        }        @Override        public void testFailure(Failure failure) throws Exception {            failures.add(failure);        }        @Override        public void testIgnored(Description description) throws Exception {            ignoreCount.getAndIncrement();        }        @Override        public void testAssumptionFailure(Failure failure) {            // do nothing: same as passing (for 4.5; may change in 4.6)        }    }    /**     * Internal use only.     */    public RunListener createListener() {        return new Listener();    }    /**     * Represents the serialized output of {@code Result}. The fields on this     * class match the files that {@code Result} had in JUnit 4.11.     */    private static class SerializedForm implements Serializable {        private static final long serialVersionUID = 1L;        private final AtomicInteger fCount;        private final AtomicInteger fIgnoreCount;        private final List<Failure> fFailures;        private final long fRunTime;        private final long fStartTime;        public SerializedForm(Result result) {            fCount = result.count;            fIgnoreCount = result.ignoreCount;            fFailures = Collections.synchronizedList(new ArrayList<Failure>(result.failures));            fRunTime = result.runTime.longValue();            fStartTime = result.startTime.longValue();        }        @SuppressWarnings("unchecked")        private SerializedForm(ObjectInputStream.GetField fields) throws IOException {            fCount = (AtomicInteger) fields.get("fCount", null);            fIgnoreCount = (AtomicInteger) fields.get("fIgnoreCount", null);            fFailures = (List<Failure>) fields.get("fFailures", null);            fRunTime = fields.get("fRunTime", 0L);            fStartTime = fields.get("fStartTime", 0L);        }        public void serialize(ObjectOutputStream s) throws IOException {            ObjectOutputStream.PutField fields = s.putFields();            fields.put("fCount", fCount);            fields.put("fIgnoreCount", fIgnoreCount);            fields.put("fFailures", fFailures);            fields.put("fRunTime", fRunTime);            fields.put("fStartTime", fStartTime);            s.writeFields();        }        public static SerializedForm deserialize(ObjectInputStream s)                throws ClassNotFoundException, IOException {            ObjectInputStream.GetField fields = s.readFields();            return new SerializedForm(fields);        }    }}