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) // 原值基础上增加delta
int 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);
}
}
}
扫一扫
1001
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
