从 SpringBoot 单元测试到 Junit 监听器
从 SpringBoot 单元测试到 Junit 监听器
Junit 是怎么启动的
首先我们来Debug看看跑单测时线程栈的入口是什么
下面是 Idea 编译器copy的调用信息 （我认为应该就是线程栈信息）
t1:25, FirstDemo (cn.hyperchain.junitTest)
invoke0:-1, NativeMethodAccessorImpl (jdk.internal.reflect)
invoke:62, NativeMethodAccessorImpl (jdk.internal.reflect)
invoke:43, DelegatingMethodAccessorImpl (jdk.internal.reflect)
invoke:564, Method (java.lang.reflect)
runReflectiveCall:50, FrameworkMethod$1 (org.junit.runners.model)
run:12, ReflectiveCallable (org.junit.internal.runners.model)
invokeExplosively:47, FrameworkMethod (org.junit.runners.model)
evaluate:17, InvokeMethod (org.junit.internal.runners.statements)
evaluate:73, RunBeforeTestExecutionCallbacks (org.springframework.test.context.junit4.statements)
evaluate:83, RunAfterTestExecutionCallbacks (org.springframework.test.context.junit4.statements)
evaluate:75, RunBeforeTestMethodCallbacks (org.springframework.test.context.junit4.statements)
evaluate:86, RunAfterTestMethodCallbacks (org.springframework.test.context.junit4.statements)
evaluate:84, SpringRepeat (org.springframework.test.context.junit4.statements)
runLeaf:325, ParentRunner (org.junit.runners)
runChild:251, SpringJUnit4ClassRunner (org.springframework.test.context.junit4)
runChild:97, SpringJUnit4ClassRunner (org.springframework.test.context.junit4)
run:290, ParentRunner$3 (org.junit.runners)
schedule:71, ParentRunner$1 (org.junit.runners)
runChildren:288, ParentRunner (org.junit.runners)
access$000:58, ParentRunner (org.junit.runners)
evaluate:268, ParentRunner$2 (org.junit.runners)
evaluate:61, RunBeforeTestClassCallbacks (org.springframework.test.context.junit4.statements)
evaluate:70, RunAfterTestClassCallbacks (org.springframework.test.context.junit4.statements)
run:363, ParentRunner (org.junit.runners)
run:190, SpringJUnit4ClassRunner (org.springframework.test.context.junit4)
run:137, JUnitCore (org.junit.runner)
startRunnerWithArgs:68, JUnit4IdeaTestRunner (com.intellij.junit4)
startRunnerWithArgs:47, IdeaTestRunner$Repeater (com.intellij.rt.execution.junit)
prepareStreamsAndStart:242, JUnitStarter (com.intellij.rt.execution.junit)
main:70, JUnitStarter (com.intellij.rt.execution.junit)
图片中线程栈最底层的入口是 JUnitStarter``com.intellij.rt.execution.junit main方法作为入口。不过我想这一点也是应该的，应该说是任何Java程序的入口都应该是一个类的mian方法。
上文中的JUnitStarter``com.intellij.rt.execution.junit 其实是 类/包名 的体系。
关于JUnitStarter可以前往GitHub看看实现
下面截取一部分代码，就看看main方法的实现方式
public static void main(String[] args) throws IOException {
Vector argList = new Vector();
for (int i = 0; i < args.length; i++) {
String arg = args[i];
argList.addElement(arg);
}
final ArrayList listeners = new ArrayList();
final String[] name = new String[1];
String agentName = processParameters(argList, listeners, name);
if (!JUNIT5_RUNNER_NAME.equals(agentName) && !canWorkWithJUnitVersion(System.err, agentName)) {
System.exit(-3);
}
if (!checkVersion(args, System.err)) {
System.exit(-3);
}
String[] array = new String[argList.size()];
argList.copyInto(array);
int exitCode = prepareStreamsAndStart(array, agentName, listeners, name[0]);
System.exit(exitCode);
}
...
private static int prepareStreamsAndStart(String[] args,
final String agentName,
ArrayList listeners,
String name) {
try {
IdeaTestRunner testRunner = (IdeaTestRunner)getAgentClass(agentName).newInstance();
if (ourCommandFileName != null) {
if (!"none".equals(ourForkMode) || ourWorkingDirs != null && new File(ourWorkingDirs).length() > 0) {
final List newArgs = new ArrayList();
newArgs.add(agentName);
newArgs.addAll(listeners);
return new JUnitForkedSplitter(ourWorkingDirs, ourForkMode, newArgs)
.startSplitting(args, name, ourCommandFileName, ourRepeatCount);
}
}
return IdeaTestRunner.Repeater.startRunnerWithArgs(testRunner, args, listeners, name, ourCount, true);
}
catch (Exception e) {
e.printStackTrace(System.err);
return -2;
}
}
结合上面的main方法可以看出应该还是走的反射+invoke的方式，给了idea相关的版本，junit的版本，test的类信息已经的执行方法名称
第三步
IdeaTestRunner. Repeater 详见GitHub
class Repeater {
public static int startRunnerWithArgs(IdeaTestRunner testRunner,
String[] args,
ArrayList listeners,
String name,
int count,
boolean sendTree) {
testRunner.createListeners(listeners, count);
if (count == 1) {
return testRunner.startRunnerWithArgs(args, name, count, sendTree);
}
else {
if (count > 0) {
boolean success = true;
int i = 0;
while (i++ < count) {
//核心代码
final int result = testRunner.startRunnerWithArgs(args, name, count, sendTree);
if (result == -2) {
return result;
}
success &= result == 0;
sendTree = false;
}
return success ? 0 : -1;
}
else {
boolean success = true;
while (true) {
//核心代码
int result = testRunner.startRunnerWithArgs(args, name, count, sendTree);
if (result == -2) {
return -1;
}
success &= result == 0;
if (count == -2 && !success) {
return -1;
}
}
}
}
}
}
感觉有点太慢了我们直接一点 进入 org.junit.runner.JUnitCore 这个类是可以在IDE上看到源码的，之前两个类是不能的所以附上了GitHub的链接地址。
org.junit.runner.JUnitCore#run 方法如下
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;
}
Junit Test 对象反射获取
当然这里还是太慢了，要论证反射获取对象，我们快进到 BlockJUnit4ClassRunner#createTest 以及 TestClass#getOnlyConstructor
BlockJUnit4ClassRunner#createTest
/**
* Returns a new fixture for running a test. Default implementation executes
* the test class's no-argument constructor (validation should have ensured
* one exists).
*/
/**
*返回运行测试的新夹具。 默认实现执行
*测试类的无参数构造函数（验证应该已经确保
*一个存在）。
*/
protected Object createTest() throws Exception {
//因为这里是直接 Constructor.newInstance() 所以是间接的说明了构造函数必须是无参的！
return getTestClass().getOnlyConstructor().newInstance();
}
TestClass#getOnlyConstructor
/**
* Returns the only public constructor in the class, or throws an {@code
* AssertionError} if there are more or less than one.
*/
/**
*返回类中唯一的公共构造函数，或抛出{@code
* AssertionError}如果有多于或少于一个。
*/
public Constructor<?> getOnlyConstructor() {
Constructor<?>[] constructors = clazz.getConstructors();
//顺带从源码层面说明了一个单测类的构造函数是只能有一个！
Assert.assertEquals(1, constructors.length);
return constructors[0];
}
综上所述，一个单测类必须是只有一个无参构造函数的。 写到这里顺带再带上debug源码的另外一个成果
FrameworkMethod#validatePublicVoidNoArg
public void validatePublicVoidNoArg(boolean isStatic, List<Throwable> errors) {
validatePublicVoid(isStatic, errors);
if (method.getParameterTypes().length != 0) {
errors.add(new Exception("Method " + method.getName() + " should have no parameters"));
}
}
所以在Junit的反射执行方法时会进行一系列的类信息，方法信息的校验，例如上述的执行方法必须是一个无参的执行方法。
对象反射获取于Spring容器顺序
如下是我的测试代码
@RunWith(SpringRunner.class)
@SpringBootTest
@Slf4j
public class FirstDemo {
@Autowired
private TokenWebConfigurer configurer;
static {
log.info("类加载时期");
}
{
log.info("反射获取对象时期");
}
@Test
public void t1(){
Validator validator = configurer.getValidator();
System.out.println(validator);
}
}
在我们看到结果截图之前，我们应该也可以想到，应该是先打印出两端语句在启动容器的
看到这里，对Junit的启动过程应该有一点简单的了解，先是IDE在获取鼠标点击事件后，获取我们要执行的方法，类型和一些启动参数，交由IDE内嵌的一个Junit插件启动执行一个main方法，所以应该是另外启动了一个java进程
下面是我再执行Junit过程执行jps命令的情况,其中 JUnitStarter 就是一个新的java 进程 Junit启动的。（诚不欺我）
➜ ~ jps
40178 Jps
31863 RemoteMavenServer
343
33162 Launcher
40173 Launcher
40174 JUnitStarter
至于 IDE 获取获取点击方法事件获取参数，可以看看如下截图，其实我们所有操作都是启动一个java进程的，里面就启动java进程的参数，看到这里我不禁感慨自己在这方面的基础还是太菜了，很多还是不太懂。如果修改了类信息，和方法名称就会报错咯。
Junit 的监听器 结合Spring的使用方式
首先我们可以看看 如何实现RunListener一个JUnit Listener示例老外写的，可以翻译一波。
我们也可以模仿一下就是首先编写我们的Junit监听器。
public class MyJunitListener extends RunListener {
@Override
public void testRunStarted(Description description) throws Exception {
System.out.println("Number of tests to execute: " + description.testCount());
}
@Override
public void testRunFinished(Result result) throws Exception {
System.out.println("Number of tests executed: " + result.getRunCount());
}
@Override
public void testStarted(Description description) throws Exception {
System.out.println("Starting: " + description.getMethodName());
}
@Override
public void testFinished(Description description) throws Exception {
System.out.println("Finished: " + description.getMethodName());
}
@Override
public void testFailure(Failure failure) throws Exception {
System.out.println("Failed: " + failure.getDescription().getMethodName());
}
@Override
public void testAssumptionFailure(Failure failure) {
System.out.println("Failed: " + failure.getDescription().getMethodName());
}
@Override
public void testIgnored(Description description) throws Exception {
System.out.println("Ignored: " + description.getMethodName());
}
}
介绍的文章中提及到的是继承于BlockJUnit4ClassRunner，但是集成了SpringBoot体系，我们就使用Spring提供的运行容器SpringJUnit4ClassRunner
public class MyJunitRunnerContiner extends SpringJUnit4ClassRunner {
public MyJunitRunnerContiner(Class<?> clazz) throws InitializationError {
super(clazz);
}
@Override
public void run(RunNotifier notifier){
notifier.addListener(new MyJunitListener());
notifier.fireTestRunStarted(getDescription());
super.run(notifier);
}
}
最后将单测中的@RunWith(SpringRunner.class)替换为目标启动容器@RunWith(MyJunitRunnerContiner.class)
@RunWith(MyJunitRunnerContiner.class)
@SpringBootTest
@Slf4j
public class FirstDemo {
@Autowired
private TokenWebConfigurer configurer;
static {
log.info("类加载时期");
}
{
log.info("反射获取对象时期");
}
@Test
public void t1(){
Validator validator = configurer.getValidator();
System.out.println(validator);
}
}
最终结果如下，成功运行如下
但是好像运用场景比较少，这也是同事之前问的一个相关问题，我上网找到的一个解决方案。处理了单元测试前后想做一些增强，例如单测失败不通过发邮件什么的，执行成功就打包。。。 大家就单丰富知识面看个开心好了