Spring系列第54篇：集成junit

于 2024-04-18 16:28:14 发布
阅读量562 收藏 17
点赞数 27
分类专栏： 程序员 文章标签： spring junit sqlserver
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84009837/article/details/137926639
版权

}

}

2.2、同时运行多个测试用例

可以一个测试类中写多个测试方法，每个方法上加上@Test注解就可以了，然后通过JUnitCore来执行就可以，下面代码中我们写2个方法对MathUtils中的max和min方法都进行测试，我们故意将执行结果和期望结果搞成不一致的，运行下面代码，然后看看运行结果。

package com.javacode2018.junit.demo2;

import com.javacode2018.junit.demo1.MathUtils;

import org.junit.Assert;

import org.junit.Test;

import org.junit.runner.JUnitCore;

import org.junit.runner.Result;

import org.junit.runner.manipulation.Ordering;

import org.junit.runner.notification.Failure;

public class MathUtilsTest2 {

@Test

public void max() throws Exception {

int result = MathUtils.max(1, 2, 3);

//判断测试结果和我们期望的结果是否一致

Assert.assertEquals(result, 1);

}

@Test

public void min() throws Exception {

int result = MathUtils.min(1, 2, 3);

//判断测试结果和我们期望的结果是否一致

Assert.assertEquals(result, 3);

}

public static void main(String[] args) {

Result result = JUnitCore.runClasses(MathUtilsTest2.class);

System.out.println(“失败用例个数:” + result.getFailures().size());

for (Failure failure : result.getFailures()) {

System.out.println(failure);

}

System.out.println(“运行测试用例个数:” + result.getRunCount());

System.out.println(“运行测试用例总耗时(ms):” + result.getRunTime());

System.out.println(“测试用例是否都成功了：” + result.wasSuccessful());

}

}

运行输出如下，运行了2个用例，失败了2个，测试的详细信息都被输出了

失败用例个数:2

max(com.javacode2018.junit.demo2.MathUtilsTest2): expected:<3> but was:<1>

min(com.javacode2018.junit.demo2.MathUtilsTest2): expected:<1> but was:<3>

运行测试用例个数:2

运行测试用例总耗时(ms):11

测试用例是否都成功了：false

2.3、使用断言

什么是断言？

断言是用来判断程序的运行结果和我们期望的结果是不是一致的，如果不一致，会抛出异常，断言中有3个信息比较关键

1、被测试的数据

2、期望的数据

3、抛出异常

断言提供的方法将被测试的数据和期望的数据进行对比，如果不一样的时候，将抛出异常，程序可以捕获这个异常，这样就可以知道测试失败了。

junit中的org.junit.Assert类中提供了大量静态方法，用来判断被测试的数据和期望的数据是否一致，不一致，将抛出异常，这里随便列几个大家看一下吧

//判断condition如果不是true，将抛出异常，异常的提示信息是message

public static void assertTrue(String message, boolean condition)

//判断expected和actual是否相等，如果不相等，将抛出异常

public static void assertEquals(Object expected, Object actual)

用法，如：

int result = MathUtils.max(1, 2, 3);

//判断测试结果和我们期望的结果是否一致

Assert.assertEquals(result, 1);

2.4、测试套件：批量运行测试用例

到目前为止，我们还只能一次运行一个测试类，如下

JUnitCore.runClasses(MathUtilsTest2.class)

但是在实际项目中，我们可能会有很多测试类，需要批量运行。

比如我们有下面2个测试类

MathUtilsTest3001.java

package com.javacode2018.junit.demo3;

import com.javacode2018.junit.demo1.MathUtils;

import org.junit.Assert;

import org.junit.Test;

public class MathUtilsTest3001 {

@Test

public void max() throws Exception {

int result = MathUtils.max(1, 2, 3);

//判断测试结果和我们期望的结果是否一致

Assert.assertEquals(result, 3);

}

@Test

public void min() throws Exception {

int result = MathUtils.min(1, 2, 3);

//判断测试结果和我们期望的结果是否一致

Assert.assertEquals(result, 1);

}

}

MathUtilsTest3002.java

package com.javacode2018.junit.demo3;

import com.javacode2018.junit.demo1.MathUtils;

import org.junit.Assert;

import org.junit.Test;

import org.junit.runner.JUnitCore;

import org.junit.runner.Result;

import org.junit.runner.notification.Failure;

public class MathUtilsTest3002 {

@Test

public void max() throws Exception {

int result = MathUtils.max(100, 99, 200);

//判断测试结果和我们期望的结果是否一致

Assert.assertEquals(result, 200);

}

@Test

public void min() throws Exception {

int result = MathUtils.min(1, -1, 10);

//判断测试结果和我们期望的结果是否一致

Assert.assertEquals(result, -1);

}

}

现在我们希望同时运行上面2个测试类，我们可以这么做，创建一个AllTest.java类，注意这个类上有2个注解比较特殊，都是junit提供的，@RunWith表示这是一个测试套件类，需要批量运行测试类，具体要运行哪些测试类呢，通过@Suite.SuiteClasses来指定

package com.javacode2018.junit.demo3;

import org.junit.runner.RunWith;

import org.junit.runners.Suite;

@RunWith(Suite.class)

@Suite.SuiteClasses({MathUtilsTest3001.class, MathUtilsTest3002.class})

public class AllTest {

}

下面来个启动类，将AllTest传递给JUnitCore.runClasses

package com.javacode2018.junit.demo3;

import com.javacode2018.junit.demo1.MathUtilsTest;

import com.javacode2018.junit.demo2.MathUtilsTest2;

import org.junit.runner.JUnitCore;

import org.junit.runner.Result;

import org.junit.runner.notification.Failure;

public class Demo3TestRunner {

public static void main(String[] args) {

//@1：传入AllTest

Result result = JUnitCore.runClasses(AllTest.class);

System.out.println(“失败用例个数:” + result.getFailures().size());

for (Failure failure : result.getFailures()) {

System.out.println(failure);

}

System.out.println(“运行测试用例个数:” + result.getRunCount());

System.out.println(“运行测试用例总耗时(ms):” + result.getRunTime());

System.out.println(“测试用例是否都成功了：” + result.wasSuccessful());

}

}

运行输出

失败用例个数:0

运行测试用例个数:4

运行测试用例总耗时(ms):12

测试用例是否都成功了：true

测试套件中不仅可以包含基本的测试类，而且可以包含其它的测试套件，这样可以很方便的分层管理不同模块的单元测试代码，比如下面代码，Module2Test和Module2Test都是测试套件

@RunWith(Suite.class)

@Suite.SuiteClasses({Test1.class, Test2.class})

public class Module2Test {

}

@RunWith(Suite.class)

@Suite.SuiteClasses({Test1.class, Test2.class})

public class Module2Test {

}

@RunWith(Suite.class)

@Suite.SuiteClasses({Module2Test.class, Module2Test.class, Test3.java})

public class AllTest {

}

//运行AllTest

JUnitCore.runClasses(AllTest.class);

2.5、Junit常用注解

1）@Test注解

@Test：将一个普通方法修饰成一个测试方法

@Test(excepted=xx.class)：xx.class 表示异常类，表示测试的方法抛出此异常时，认为是正常的测试通过的

@Test(timeout = 毫秒数)：测试方法执行时间是否符合预期

2）@BeforeClass

会在所有的方法执行前被执行，static 方法 （全局只会执行一次，而且是第一个运行）

3）@AfterClass

会在所有的方法执行之后进行执行，static 方法 （全局只会执行一次，而且是最后一个运行）

4）@Before

会在每一个测试方法被运行前执行一次

5）@After

会在每一个测试方法运行后被执行一次

6）@Ignore

所修饰的测试方法会被测试运行器忽略

7）@RunWith

可以更改测试运行器 org.junit.runner.Runner

下面的案例，基本上用到了上面所有的注解，大家结合输出理解一下。

package com.javacode2018.junit.demo4;

import com.javacode2018.junit.demo1.MathUtils;

import org.junit.*;

import org.junit.runner.JUnitCore;

import org.junit.runner.Result;

import org.junit.runner.notification.Failure;

import java.util.concurrent.TimeUnit;

public class MathUtilsTest4 {

@BeforeClass

public static void bc() {

System.out.println(“@BeforeClass”);

System.out.println(“-----------------”);

}

@AfterClass

public static void ac() {

System.out.println(“@AfterClass”);

}

@Before

public void bf() {

System.out.println(“@Before:” + this);

}

@After

public void af() {

System.out.println(“@After:” + this);

System.out.println(“##################”);

}

@Test

public void max() throws Throwable {

System.out.println(“max():” + this);

int result = MathUtils.max(1, 2, 3);

//判断测试结果和我们期望的结果是否一致

Assert.assertEquals(result, 3);

}

@Test

public void min() throws Exception {

System.out.println(“min():” + this);

int result = MathUtils.min(1, 2, 3);

//判断测试结果和我们期望的结果是否一致

Assert.assertEquals(result, 1);

}

//方法运行时间超过了timeout，表示测试用例运行失败

@Test(timeout = 1000)

public void timeOutTest() throws InterruptedException {

System.out.println(“timeOutTest():” + this);

TimeUnit.SECONDS.sleep(2000);

}

//方法若未抛出expected指定的异常，表示测试用例运行失败

@Test(expected = NullPointerException.class)

public void expectedTest() {

System.out.println(“expectedTest():” + this);

new RuntimeException(“异常不匹配”);

}

@Test

@Ignore

public void ignoredMethod() {

System.out.println(“我是被忽略的方法”);

}

public static void main(String[] args) {

Result result = JUnitCore.runClasses(MathUtilsTest4.class);

System.out.println(“-----------------”);

System.out.println(“运行测试用例个数:” + result.getRunCount());

System.out.println(“失败用例个数:” + result.getFailures().size());

for (Failure failure : result.getFailures()) {

System.out.println(failure);

}

System.out.println(“运行测试用例总耗时(ms):” + result.getRunTime());

System.out.println(“测试用例是否都成功了：” + result.wasSuccessful());

}

}

运行结果如下

@BeforeClass

@Before:com.javacode2018.junit.demo4.MathUtilsTest4@78e03bb5

timeOutTest():com.javacode2018.junit.demo4.MathUtilsTest4@78e03bb5

@After:com.javacode2018.junit.demo4.MathUtilsTest4@78e03bb5

##################

@Before:com.javacode2018.junit.demo4.MathUtilsTest4@48533e64

max():com.javacode2018.junit.demo4.MathUtilsTest4@48533e64

@After:com.javacode2018.junit.demo4.MathUtilsTest4@48533e64

##################

@Before:com.javacode2018.junit.demo4.MathUtilsTest4@7e0b37bc

min():com.javacode2018.junit.demo4.MathUtilsTest4@7e0b37bc

@After:com.javacode2018.junit.demo4.MathUtilsTest4@7e0b37bc

##################

@Before:com.javacode2018.junit.demo4.MathUtilsTest4@1a93a7ca

expectedTest():com.javacode2018.junit.demo4.MathUtilsTest4@1a93a7ca

@After:com.javacode2018.junit.demo4.MathUtilsTest4@1a93a7ca

##################

@AfterClass

运行测试用例个数:4

失败用例个数:3

timeOutTest(com.javacode2018.junit.demo4.MathUtilsTest4): test timed out after 1000 milliseconds

max(com.javacode2018.junit.demo4.MathUtilsTest4): hah

expectedTest(com.javacode2018.junit.demo4.MathUtilsTest4): Expected exception: java.lang.NullPointerException

运行测试用例总耗时(ms):1018

测试用例是否都成功了：false

从输出中可以看出

  • @BeforeClass和@AfterClass标注的方法只会运行一次

  • 每个@Test标注的方法运行之前会先运行@Before标注的方法，然后运行@Test标注的这个方法，之后再运行@After

  • 从this的输出看出，每个@Test运行的时候，当前类的实例都会重新创建一个新的

  • 不论@Test标注的方法是否异常，@AfterClass、@After标注的方法都会执行，且异常会被淹没，输出中看不到异常信息

2.6、参数化测试

Junit 4 引入了一个新的功能参数化测试。

参数化测试允许开发人员使用不同的值反复运行同一个测试，你将遵循 5 个步骤来创建参数化测试。

  • 用 @RunWith(Parameterized.class) 来注释 test 类。

  • 创建一个由 @Parameters 注释的公共的静态方法，它返回一个对象的集合(数组)来作为测试数据集合。

  • 创建一个公共的构造函数，它接受和一行测试数据相等同的东西。

  • 为每一列测试数据创建一个实例变量。

  • 用实例变量作为测试数据的来源来创建你的测试用例。

可能大家看了上面的理解，还是比较迷糊。

比如我们com.javacode2018.junit.demo1.MathUtils#max测试下面几组数组

1,2,3

100,99,80

30,-1,100

我们可以这么写

package com.javacode2018.junit.demo5;

import com.javacode2018.junit.demo1.MathUtils;

import org.junit.Assert;

import org.junit.Test;

import org.junit.runner.JUnitCore;

import org.junit.runner.Result;

import org.junit.runner.RunWith;

import org.junit.runner.notification.Failure;

import org.junit.runners.Parameterized;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

@RunWith(Parameterized.class)

public class MathUtilsTest5 {

public static class TestData {

int[] testData;//测试数据

int expectedValue;//预期的结果

public TestData(int[] testData, int expectedValue) {

this.testData = testData;

this.expectedValue = expectedValue;

}

@Override

public String toString() {

return “TestData{” +

“testData=” + Arrays.toString(testData) +

“, expectedValue=” + expectedValue +

‘}’;

}

}

private TestData testData;

@Parameterized.Parameters

public static List initTestData() {

System.out.println(“initTestData()”);

//key：期望的结果，value：max方法需要测试的数据

List result = new ArrayList<>();

result.add(new TestData(new int[]{1, 2, 3}, 3));

result.add(new TestData(new int[]{100, 99, 80}, 100));

result.add(new TestData(new int[]{30, -1, 100}, 100));

return result;

}

public MathUtilsTest5(TestData testData) {

System.out.println(“MathUtilsTest5构造器:” + testData);

this.testData = testData;

}

@Test

public void maxTest() throws Throwable {

System.out.println(this.hashCode() + “,maxTest():” + this.testData);

int result = MathUtils.max(this.testData.testData);

//判断测试结果和我们期望的结果是否一致

Assert.assertEquals(this.testData.expectedValue, result);

System.out.println(“###################”);

}

public static void main(String[] args) {

Result result = JUnitCore.runClasses(MathUtilsTest5.class);

System.out.println(“-----------------”);

System.out.println(“运行测试用例个数:” + result.getRunCount());

System.out.println(“失败用例个数:” + result.getFailures().size());

for (Failure failure : result.getFailures()) {

System.out.println(failure);

}

System.out.println(“运行测试用例总耗时(ms):” + result.getRunTime());

System.out.println(“测试用例是否都成功了：” + result.wasSuccessful());

}

}

为了方便大家理解代码的运行过程，代码中添加了很多日志输出，运行结果如下，结合代码和输出，理解很容易

initTestData()

MathUtilsTest5构造器:TestData{testData=[1, 2, 3], expectedValue=3}

721748895,maxTest():TestData{testData=[1, 2, 3], expectedValue=3}

###################

MathUtilsTest5构造器:TestData{testData=[100, 99, 80], expectedValue=100}

463345942,maxTest():TestData{testData=[100, 99, 80], expectedValue=100}

###################

MathUtilsTest5构造器:TestData{testData=[30, -1, 100], expectedValue=100}

195600860,maxTest():TestData{testData=[30, -1, 100], expectedValue=100}

###################

运行测试用例个数:3

失败用例个数:0

运行测试用例总耗时(ms):12

测试用例是否都成功了：true

3、Spring集成junit

spring集成junit比较简单，下面我们来个案例感受一下。

3.1、加入maven配置

org.springframework

spring-test

5.2.6.RELEASE

junit

junit

4.13

3.2、来个spring的入口配置类

package com.javacode2018.springjunit;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

@Configuration

public class MainConfig {

@Bean

public String name() {

return “路人甲java”;

}

@Bean

public int age() {

return 30;

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

img

最后

现在其实从大厂招聘需求可见，在招聘要求上有高并发经验优先，包括很多朋友之前都是做传统行业或者外包项目，一直在小公司，技术搞的比较简单，没有怎么搞过分布式系统，但是现在互联网公司一般都是做分布式系统。

所以说，如果你想进大厂，想脱离传统行业，这些技术知识都是你必备的，下面自己手打了一份Java并发体系思维导图，希望对你有所帮助。

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

@Configuration

public class MainConfig {

@Bean

public String name() {

return “路人甲java”;

}

@Bean

public int age() {

return 30;

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-C8S9Toxd-1713428882910)]

[外链图片转存中…(img-3PN8fNi9-1713428882911)]

[外链图片转存中…(img-lhuNegqL-1713428882911)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

img

最后

现在其实从大厂招聘需求可见，在招聘要求上有高并发经验优先，包括很多朋友之前都是做传统行业或者外包项目，一直在小公司，技术搞的比较简单，没有怎么搞过分布式系统，但是现在互联网公司一般都是做分布式系统。

所以说，如果你想进大厂，想脱离传统行业，这些技术知识都是你必备的，下面自己手打了一份Java并发体系思维导图，希望对你有所帮助。

[外链图片转存中…(img-ti75TyRr-1713428882911)]

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

2401_84009837
关注
  • 27
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
构建微服务：Spring boot 入门篇
【CSDN】
06-19 342
什么是Spring Boot Spring Boot 是由 Pivotal 团队提供的全新框架，其设计目的是用来简化新 Spring 应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。用我的话来理解，就是 Spring Boot 其实不是什么新的框架，它默认配置了很多框架的使用方式，就像 Maven 整合了所有的 Jar 包，Spring Boot 整合了所有的框架。 使用Spring Boot有什么好处 其实就是简单、快速、方便！平时如果我..
Spring Boot入门(26)：让邮件飞：Spring Boot邮件发送实现攻略
**My Coding Family**
08-23 3176
滚雪球零基础学Spring Boot，从零到一，讲解非常详细，就等你来学啦！
Spring集成junit
security_linsho的博客
04-15 899
首先，我们要了解的是，基本上在利用spring开发的时候基本上每个测试类都会有如下问题 这两行代码又是少不了的，因为一行是加载配置文件（配置类），一行是获得对象，所以这两行都是少不了的，整合junit就是为了解决这个问题 上述问题的解决思路： Spring集成junit步骤： 第一步：导入spring集成Junit坐标 我们先去MAVEN的依赖关系去看一看，发现里面没有spring-test的jar包，因为spring-test就是spirng集成Junit的包 现在我们导入
Spring整合Junit的使用
LeslieLau的博客
02-06 659
今天来讲讲Spring整合junit的使用 我们在编写完Spring的代码后，往往需要测试代码的正确性，这个时候就需要用到单元测试了。我们这里使用的版本是junit4. 一个程序的入口是main方法，但是junit中不存在main方法，是因为junit内部的原理是它自己内部就有个main方法，运行扫描带@Test注解的方法，然后反射调用该方法，完成测试。 调用Spring框架的测试代码: @Tes...
Spring集成Junit
qq_52666017的博客
07-29 100
Spring集成Junit 1.1 原始Junit测试Spring的问题 在测试类中，每个测试方法都有以下两行代码： ApplicationContext app = new ClassPathXmlApplicationContext("bean.xml"); IAccountService as = app.getBean("accountService",IAccountService.class); 这两行代码
spring集成junit
健康平安的活着的专栏
01-03 432
一.spring 集成junit的步骤 1.导入spring集成junit的坐标 2.使用@Runwith注解替换原来的运行期 3.使用@ContextConfiguration制定配置文件或者配置类 4.使用@Autowired注入需要测试的对象 5.创建测试方法进行测试 二.案例操作 本案例是在前面两篇博客创建项目的基础上，进行的操作。 2.1 pom文件的配置 <!-- 引入spring的依赖包 --> <dependency>
Spring集成MyBatis完整示例
m0_68850571的博客
04-22 412
目录 一、新建一个基于Maven的Web项目 二、创建数据库与表 三、添加依赖包 四、新建POJO实体层 五、新建MyBatis SQL映射层 六、完成Spring整合MyBatis配置 七、创建服务层 八、JUnit测试服务类 九、加载Spring容器与获得容器对象 十、简单MVC控制器封装 十一、完成图书管理功能 11.1、定义BookController控制器 11.2、图书列表与删除 11.3、新增图书功能 11.4、编辑图书功能 11.5、首页与样式
面渣逆袭：Spring三十五问，四万字+五十图详解
q66562636的博客
05-13 241
基础 1.Spring是什么？特性？有哪些模块？ Spring Logo 一句话概括：Spring 是一个轻量级、非入侵式的控制反转 (IoC) 和面向切面 (AOP) 的框架。 2003年，一个音乐家Rod Johnson决定发展一个轻量级的Java开发框架，Spring作为Java战场的龙骑兵渐渐崛起，并淘汰了EJB这个传统的重装骑兵。 Spring重要版本 到了现在，企业级开发的标配基本就是Spring5+Spring Boot 2+JDK 8 Spring有哪些特性...
SpringBoot 系列教程(七十八)：Spring Boot整合Memcached缓存
Thinkingcao的专栏
01-07 853
一、前言 最近花了点时间研究了一下Memcached缓存框架，首先先感叹一下，这个框架是真的轻量级，当我下载下来之后轻量级到让我大吃一惊，他的安装包只有300多KB，哇，真是太轻量级了；然后稍微研究了一下这个Memcached框架的简单用法，发现这个也是一个存储键/值 对的HashMap，下面先介绍一下关于Memcached的相关概念，然后带着大家学习一下基本的缓存增删改查用法； 二、什么是Mem...
Spring-集成Junit
weixin_47286156的博客
10-04 334
Spring学习笔记目录 使用配置数据源的项目继续练习 目录思路集成步骤代码示例导入坐标运行结果使用全注解的配置文件运行结果 思路 让SpringJunit负责创建Spring容器，但是需要将配置文件的名称告诉它。 将需要进行测试Bean直接在测试类中进行注入。 集成步骤 ①导入spring集成Junit的坐标 ②使用@Runwith注解替换原来的运行（现在测试要由spring找到test进行测试） ③使用@ContextConfiguration指定配置文件或配置类（指定配置文件是谁） ④使用@Autow
Spring 集成 Junit
不语冰
11-08 191
1.引入依赖 &lt;!-- https://mvnrepository.com/artifact/org.springframework/spring-test --&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework&lt;/groupId&gt; &lt;artifactId&gt;spring-test&l...
spring 整合 JUnit
最新发布
一切总会归于平淡
11-14 649
大家好，本篇博客我们通过spring来整合JUnitt单元测试框架。
WebLogicWorkshop8.1单元测试指南：集成JUnit与实战应用
在"对WebLogicWorkshop8.1应用程序进行单元测试"这篇文章中，作者详尽地介绍了如何在火龙果软件工程技术中心开发的WebLogicPlatform 8.1环境中有效地利用JUnit进行单元测试。该文章主要针对的是希望将JUnit集成到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值