Hibernate之单元测试利器JUnit

最新推荐文章于 2021-05-12 23:21:33 发布

原创最新推荐文章于 2021-05-12 23:21:33 发布 · 2k 阅读

0 ·

CC 4.0 BY-SA版权

java 同时被 3 个专栏收录

40 篇文章

订阅专栏

hibernate基础学习

12 篇文章

订阅专栏

hibernate

10 篇文章

订阅专栏

本文介绍了单元测试的重要性，理解其定义和作用，以及JUnit作为Java单元测试工具的强大功能，包括忽略未完成测试、Fixture、限时测试、异常测试和参数化测试等。通过JUnit，可以更有效地管理和执行单元测试，提高代码质量。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

单元测试

作为一名程序员，我们必须要对自己编写的代码负责，我们不仅要保证它能通过编译，正常地运行，而且要满足

需求和设计预期的效果。而单元测试正是验证代码行为是否满足预期的有效手段之一。

定义的理解：

我们在编写大型程序的时候，需要写成千上万个方法或函数，这些函数的功能可能很强大，但我们在程序中只用

到该函数的一小部分功能，并且经过调试可以确定，这一小部分功能是正确的。但是，我们同时应该确保每一个函数

都完全正确，因为如果我们今后如果对程序进行扩展，用到了某个函数的其他功能，而这个功能有bug的话，那绝对

是一件非常郁闷的事情。所以说，每编写完一个函数之后，都应该对这个函数的方方面面进行测试，这样的测试我们

称之为单元测试。

作用：

站在程序员的角度来说，枯燥的单元测试是会带来一定的工作量的，但好处也是显然的。好处体现在两方面：一

是，可以提高你的自信，自己提前发现问题总比提心吊胆的等着测试人员找你要好。二是，有利于提高自己的声望。

因为做了单元测试，所以设计出来的代码质量会相对的高，这无疑有利于提高自己的声望。就这两点来说，即使公司

没有要求做单元测试，程序员自己也应当去做。

单元测试是一种提高软件质量非常有效的方法，在现代的敏捷软件开发方法论里，都非常强调单元测试的重要

性。为什么呢？因为对于多次的迭代开发，我们需要通过测试来看是否新的迭代对于原有的功能是否有影响。还有就

是，我们可能需要做重构，通过单元测试我们能发现重构后的代码是否对原有的功能进行了改变，而这是我们做重构

后所不希望看到的。

弊端：

1.测试用例的维护成本比较的高。往往对其维护的工作量并不比被测代码的开发量小，对于这一点我们需要有足够的

认识。

2.程序员操作起来比较枯燥繁琐。

JUnit：

因为单元测试很重要，所以我们必须去解决它的弊端，让它更好的发挥作用，这时候就需要我们的利器JUnit出马

了。JUnit 是 Java社区中知名度最高的单元测试工具。麻雀虽小，五脏俱全。JUnit 设计的非常小巧，但是功能却非常

强大。Martin Fowler 如此评价JUnit：在软件开发领域，从来就没有如此少的代码起到了如此重要的作用。它大大简化

了开发人员执行单元测试的难度，特别是 JUnit 4 使用 Java 5中的注解（annotation）使测试变得更加简单。JUnit 使这

一切变得简单艺术起来。

基本功能：

一：忽略测试某些尚未完成的方法。

如果你在写程序前做了很好的规划，那么哪些方法是什么功能都应该实现定下来。因此，即使该方法尚未完成，

他的具体功能也是确定的，这也就意味着你可以为他编写测试用例。但是，如果你已经把该方法的测试用例写完，但

该方法尚未完成，那么测试的时候一定是“失败”。这种失败和真正的失败是有区别的，因此JUnit提供了一种方法来区

别他们，那就是在这种测试函数的前面加上@Ignore标注，这个标注的含义就是“某些方法尚未完成，暂不参与此次测

试”。这样的话测试结果就会提示你有几个测试被忽略，而不是失败。一旦你完成了相应函数，只需要把@Ignore标注

删去，就可以进行正常的测试。

二：Fixture

Fixture的含义就是“在某些阶段必然被调用的代码”。例如： @Before 和 @After ，我们来看看他们是否适合完成

如下功能：有一个类是负责对大文件（超过 500 兆）进行读写，他的每一个方法都是对文件进行操作。换句话说，在

调用每一个方法之前，我们都要打开一个大文件并读入文件内容，这绝对是一个非常耗费时间的操作。如果我们使

用 @Before 和 @After ，那么每次测试都要读取一次文件，效率及其低下。这里我们所希望的是在所有测试一开始读

一次文件，所有测试结束之后释放文件，而不是每次测试都读文件。 JUnit 的作者显然也考虑到了这个问题，它给出

了 @BeforeClass和 @AfterClass 两个 Fixture 来帮我们实现这个功能。从名字上就可以看出，用这两个 Fixture 标注的函

数，只在测试用例初始化时执行 @BeforeClass 方法，当所有测试执行完毕之后，执行 @AfterClass 进行收尾工作。在

这里要注意一下，每个测试类只能有一个方法被标注为 @BeforeClass 或 @AfterClass ，并且该方法必须是 Public

和 Static 的。

三、限时测试。

如果测试的时候遇到死循环，你的脸上绝对不会露出笑容。因此，对于那些逻辑很复杂，循环嵌套比较深的程

序，很有可能出现死循环，因此一定要采取一些预防措施。限时测试是一个很好的解决方案。我们给这些测试函数设

定一个执行时间，超过了这个时间，他们就会被系统强行终止，并且系统还会向你汇报该函数结束的原因是因为超

时，这样你就可以发现这些 Bug 了。要实现这一功能，只需要给 @Test 标注加一个参数即

可， @Test(timeout = 1000 )

四、测试异常

JAVA 中的异常处理也是一个重点，因此你经常会编写一些需要抛出异常的函数。那么，如果你觉得一个函数应该

抛出异常，但是它没抛出，这算不算 Bug 呢？这当然是 Bug ，并 JUnit 也考虑到了这一点，来帮助我们找到这种 Bug 。

例如，我们写的计算器类有除法功能，如果除数是一个 0 ，那么必然要抛出“除 0 异常”。因此，我们很有必要对这些

进行测试。代码如下：

 <span style="font-size:18px;">  @Test(expected  =  ArithmeticException. class )
    public   void  divideByZero()  {
 calculator.divide( 0 ); 
   } </span>

如上述代码所示，我们需要使用@Test标注的expected属性，将我们要检验的异常传递给他，这样JUnit框架就能自

动帮我们检测是否抛出了我们指定的异常。

五、参数化测试。

你可能遇到过这样的函数，它的参数有许多特殊值，或者说他的参数分为很多个区域。为了简化类似的测

试， JUnit4 提出了“参数化测试”的概念，只写一个测试函数，把这若干种情况作为参数传递进去，一次性的完成测

试。代码如下：

import   static  org.junit.Assert.assertEquals;
 import  org.junit.Test;
 import  org.junit.runner.RunWith;
 import  org.junit.runners.Parameterized;
 import  org.junit.runners.Parameterized.Parameters;
 import  java.util.Arrays;
 import  java.util.Collection;
 @RunWith(Parameterized. class )
 
 public   class  SquareTest  {
      private   static  Calculator calculator  =   new  Calculator();
      private   int  param;
      private   int  result;
 
     @Parameters
      public   static  Collection data()  {
          return  Arrays.asList( new  Object[][] {
                  { 2 ,  4 } ,
                  { 0 ,  0 } ,
                  {－ 3 ,  9 } ,
         } );
     } 
 // 构造函数，对变量进行初始化 
 
      public  SquareTest( int  param,  int  result)  {
          this .param  =  param;
 
          this .result  =  result;
     } 
 
     @Test
      public   void  square()  {
         calculator.square(param);
         assertEquals(result, calculator.getResult());
     } 
 }

六、打包测试。

通过前面的介绍我们可以感觉到，在一个项目中，只写一个测试类是不可能的，我们会写出很多很多个测试类。

可是这些测试类必须一个一个的执行，也是比较麻烦的事情。鉴于此， JUnit 为我们提供了打包测试的功能，将所有

需要运行的测试类集中起来，一次性的运行完毕，大大的方便了我们的测试工作。具体代码如下：

import  org.junit.runner.RunWith;
 import  org.junit.runners.Suite;
 @RunWith(Suite. class )
 
 @Suite.SuiteClasses( {
 
         CalculatorTest. class ,
 
         SquareTest. class 
 
         } )
 public   class  AllCalculatorTests  {
 
 }