Am98
Am98

Mockito

常用注解

@Mock 模拟 创建一个对象，但无法进行实际操作
@InjectMocks 注射 用于mock时插入相应的依赖项
@Captor 捕获 用于捕获方法的参数值，来用于进一步做断言验证
@Spy 间谍 创建一个真实对象并监视这个对象

常用方法

doReturn() 返回 doReturn(值).when(条件);
doThrow() 抛异常 doThrow(异常).when(条件);
doAnswer() 回复 doAnswer(值).when(条件);
doNothing() 无操作 doNothing().when(条件);
doCallRealMethod() 使用真实方法操作 doCallRealMethod().when(对象).delete();

你需要对传递给方法的参数执行一些操作，例如，添加一些值，进行一些计算，甚至修改它们doAnswer给你提供了在方法被调用的瞬间执行的Answer接口，这个接口允许你通过InvocationOnMock参数与参数交互。另外，answer方法的返回值将是mocked方法的返回值。

initMocks						【初始化】MockitoAnnotations.initMocks(this);
assertThat						【断言】assertThat(实际值, is(理想值));
when							  【定义返回值】when(操作).thenReturn(值).thenReturn(值)

Mockito 中文文档 ( 2.23.4 )

本文档参考hehonghui/mockito-doc-zh项目，如有侵权，请联系删除

Mockito框架官方地址mockito，文档地址。

Mockito库能够Mock对象、验证结果以及打桩(stubbing)。

该文档您也可以通过http://mockito.org获取到。所有文档都保存在javadocs中，因为它能够保证文档与源代码的一致性。这样也能够让离线的用户从IDE直接访问到文档。这样一来也能够激励Mockito开发者在每次写代码、每次提交时更新对应的文档。

目录

  1. 迁移到Mockito 2.0
    0.1 Mockito支持Android
    0.2 免配置内联mock making
  2. 验证某些行为
  3. 如何做一些测试桩 (Stub)
  4. 参数匹配器 (matchers)
  5. 验证函数的确切、最少、从未调用次数
  6. 通过打桩为无返回值函数抛出异常
  7. 验证执行执行顺序
  8. 确认交互(interaction)操作没有在mock对象上执行
  9. 查找多余的调用
  10. 简化mock对象的创建 - @Mock注解
  11. 为连续的调用打桩 (迭代器风格的打桩)
  12. 通过回调方式来打桩
  13. doReturn()、doThrow()、doAnswer()、doNothing()、doCallRealMethod()系列方法
  14. 监控真实对象
  15. 修改没有测试桩的调用的默认返回值 ( 1.7版本之后 )
  16. 为下一步的断言捕获参数 (1.8版本之后)
  17. 真实的局部模拟对象(mocks) (1.8版本之后)
  18. 重置mocks对象 (1.8版本之后)
  19. 故障排查与验证框架的使用 (1.8版本之后)
  20. 行为驱动开发的别名 (1.8版本之后)
  21. 可序列化的mocks(1.8.1版本之后)
  22. 新的注解 : @Captor,@Spy,@InjectMocks (1.8.3版本之后)
  23. 带超时的验证 (1.8.5版本之后)
  24. 自动实例化被@Spies, @InjectMocks注释的字段以及构造函数注入 (1.9.0版本之后)
  25. 单行测试桩 (1.9.0版本之后)
  26. 验证被忽略的测试桩 (1.9.0版本之后)
  27. mock详情 (2.2.x中改进)
  28. 真实实例的委托调用 (1.9.5版本之后)
  29. MockMaker API (1.9.5版本之后)
  30. BDD风格的验证 (1.10.0版本之后)
  31. 监视 或 模拟 抽象类 (1.10.12版本加入，在2.7.13 和 2.7.14版特征得到增强))
  32. Mockito的模拟对象 可以通过 classloaders 序列化/反序列化(1.10.0版本之后)
  33. Deep stubs 更好的泛型支持 (1.10.0版本之后)
  34. Mockito JUnit 规则 (1.10.17版本之后)
  35. 开启和关闭插件的开关 (1.10.15版本之后)
  36. 自定义验证失败消息 (2.1.0版本之后)
  37. Java8 Lambda匹配器的支持 (2.1.0版本之后)
  38. Java8 自定义Answer的支持 (2.1.0版本之后)
  39. 元信息和泛型信息保留 (2.1.0版本之后)
  40. Mocking final类型，枚举和final方法 (2.1.0版本之后)
  41. “严格的”Mocktio能提高生产效率并使测试用例更清晰(2.+版本之后)
  42. 框架集成的高级公开API (2.10.+版本之后)
  43. 集成新的API: 监听验证开始(verification start)事件(2.11.+版本之后)
  44. 集成新的API: 测试框架支持MockitoSession(2.15.+版本之后)
  45. org.mockito.plugins.InstantiatorProvider泄露内部API所以被org.mockito.plugins.InstantiatorProvider2替代(2.15.4版本之后)
  46. JUnit5+的扩展
  47. 新的Mockito.lenient()和MockSettings.lenient()方法(2.20.0版本之后)

0. 迁移到Mockito 2.0

为了持续提升Mockito以及更进一步的提升单元测试体验,我们希望你升级到Mockito 2.0.Mockito遵循语意化的版本控制，除非有非常大的改变才会变化主版本号。在一个库的生命周期中,为了引入一系列有用的特性，修改已存在的行为或者API等重大变更是在所难免的。因此，我们希望你能够爱上 Mockito 2.0!

重要变更 :

  • Mockito从Hamcrest中解耦，自定义的matchers API也发生了改变,查看ArgumentMatcher 的基本原理以及迁移指南。

跟着我们的示例来mock 一个List,因为大家都知道它的接口（例如add(),get(), clear()）。不要mock一个真实的List类型,使用一个真实的实例来替代。

0.1. Mockito支持Android

在2.6.1版本，我们提供了”原生的“Android支持。通过在项目中新增”mockito-android“库依赖，就能得到支持。这个工件发布到同一个Mockito组织，并且可以按照以下方式导入Android:

  repositories {
   jcenter()
 }
 dependencies {
   testCompile "org.mockito:mockito-core:+"
   androidTestCompile "org.mockito:mockito-android:+"
 }

通过在“testCompile”范围中使用“mockito-core”工件，可以在常规VM上继续运行相同的单元测试，如上所示。请注意，由于Android VM的限制，您不能在Android上使用内联模拟生成器。如果您在Android上遇到模拟的问题，请在官方问题跟踪器上打开一个issue。一定要提供您正在使用的Android版本和项目的依赖项。

0.2. 免配置内联mock making

从2.7.6版本开始，我们提供”mockito-inline“ artifact，它支持内联的mock making而不需要配置MockMaker的扩自文件。使用方式，用”mockito-inline“替换”mockito-core“：

 
 repositories {
   jcenter()
 }
 dependencies {
   testCompile "org.mockito:mockito-inline:+"
 }

注意，这个artifact可能会停止维护，当内联mock making特性被集成到默认的mock maker里时。
查看更多关于内联mock making，查看39章

1. 验证某些行为

 // 静态导入会使代码更简洁
 import static org.mockito.Mockito.*;

 // mock creation 创建mock对象
 List mockedList = mock(List.class);

 //using mock object 使用mock对象
 mockedList.add("one");
 mockedList.clear();

 //verification 验证
 verify(mockedList).add("one");
 verify(mockedList).clear();

一旦mock对象被创建了，mock对象会记住所有的交互动作。然后你就可以选择性的验证你感兴趣的交互动作。

2. 如何做一些测试桩 (Stub)

 // 你可以mock具体的类,不仅只是接口
 LinkedList mockedList = mock(LinkedList.class);

 // 测试桩
 when(mockedList.get(0)).thenReturn("first");
 when(mockedList.get(1)).thenThrow(new RuntimeException());

 // 输出“first”
 System.out.println(mockedList.get(0));

 // 抛出异常
 System.out.println(mockedList.get(1));

 // 因为get(999) 没有打桩，因此输出null
 System.out.println(mockedList.get(999));

 //虽然能验证被打桩对象的调用情况，但这通常写起来很啰嗦
 //如果你关注get(0)的返回值，那么其他地方就会中断（通常在verify()执行之前）
 //如果你不关注get(0)的返回值，那么它就不应该被打桩。不相信？看下面例子。
 verify(mockedList).get(0);
  • 默认情况下，所有的函数都有返回值。mock函数会适当的返回null，原始类型/原始类型的包装类，一个空的集合，例如int/Integer返回0、boolean/Boolean返回false；
  • 打桩动作可以被覆写 : 例如常见的打桩动作可以用于公共的配置，然后在测试函数中能够重新打桩。请注意，覆写测试桩函数是一种潜在的代码异味，它指出打桩动作太多了；
  • 一旦测试桩函数被调用，该函数将会一直返回固定的值；
  • 最后一个打桩动作是很重要的 - 当你用相同参数为一个方法做多次打桩时。换句话说：打桩的顺序很重要，但是这很少有意义，例如，当为完全相同的方法调用打桩，或者当使用参数匹配器时，等等。

3. 参数匹配器 (matchers)

Mockito以自然的java风格来验证参数值: 使用equals()函数。有时，当需要额外的灵活性时你可能需要使用参数匹配器，也就是argument matchers :


 // 使用内置的anyInt()参数匹配器来打桩
 when(mockedList.get(anyInt())).thenReturn("element");

 // 使用自定义的参数匹配器来打桩( 在isValid()函数中返回你自己的匹配器实现 )
 when(mockedList.contains(argThat(isValid()))).thenReturn("element");

 // 输出“element”
 System.out.println(mockedList.get(999));

 // 你也可以用参数匹配器来验证
 verify(mockedList).get(anyInt());
 
 //参数匹配器也能用Java 8 Lambda风格编写
 verify(mockedList).add(argThat(someString -> someString.length() > 5));

参数匹配器使验证和打桩变得更灵活。点击这里或这里查看更多内置的匹配器以及自定义参数匹配器或者hamcrest 匹配器的示例。

如果仅仅是获取自定义参数匹配器的信息，查看ArgumentMatcher类文档即可。

为了合理的使用复杂的参数匹配，使用原生风格的equals()匹配器，偶尔也用下anyX()匹配器，会使得测试代码更简洁、简单。有时，会迫使你重构代码以使用equals()匹配或者实现equals()函数来帮助你进行测试。

同时建议你阅读第15章节或者ArgumentCaptor类文档。ArgumentCaptor是一个能够捕获参数值的特殊参数匹配器。

参数匹配器的注意点 :

如果你使用了参数匹配器, 那么所有参数都要用匹配器。

示例 : ( 该示例展示了如何多次应用于测试桩函数的验证 )

verify(mock).someMethod(anyInt(), anyString(), eq("third argument"));
// 上述代码是正确的,因为eq()也是一个参数匹配器

verify(mock).someMethod(anyInt(), anyString(), "third argument");
// 上述代码是错误的,因为所有参数必须由匹配器提供，而参数"third argument"并非由参数匹配器提供，因此会抛出异常

像anyObject(), eq()这样的匹配器函数不会返回匹配器。它们会在内部将匹配器记录到一个栈当中，并且返回一个假的值，通常为null。这样的实现是由于被Java编译器强加的静态类型安全检查。结果就是你不能在验证或者测试桩函数之外使用anyObject(), eq()函数。

4. 验证函数的确切、最少、从未调用的次数

 //使用mock对象
 mockedList.add("once");

 mockedList.add("twice");
 mockedList.add("twice");

 mockedList.add("three times");
 mockedList.add("three times");
 mockedList.add("three times");

 // 下面的两个验证函数效果一样,因为verify默认验证的就是times(1)
 verify(mockedList).add("once");
 verify(mockedList, times(1)).add("once");

 // 验证具体的执行次数
 verify(mockedList, times(2)).add("twice");
 verify(mockedList, times(3)).add("three times");

 // 使用never()进行验证,never相当于times(0)
 verify(mockedList, never()).add("never happened");

 // 使用atLeast()/atMost()进行验证
 verify(mockedList, atLeastOnce()).add("three times");
 verify(mockedList, atLeast(2)).add("five times");
 verify(mockedList, atMost(5)).add("three times");

verify函数默认验证的是执行了times(1)，也就是某个测试函数是否执行了1次.因此，times(1)通常被省略了。

5. 通过打桩为无返回值函数抛出异常

doThrow(new RuntimeException()).when(mockedList).clear();

// 调用这句代码会抛出运行时异常
mockedList.clear();

关于doThrow|doAnswer 等函数族的信息请阅读第十二章节。

6. 验证执行执行顺序

 // A. 一个方法必须以指定顺序执行的模拟的对象
 List singleMock = mock(List.class);

 //使用这个模拟的对象
 singleMock.add("was added first");
 singleMock.add("was added second");

 // 为该mock对象创建一个inOrder验证器
 InOrder inOrder = inOrder(singleMock);

 // 确保add函数首先执行的是add("was added first"),然后才是add("was added second")
 inOrder.verify(singleMock).add("was added first");
 inOrder.verify(singleMock).add("was added second");

 // B .验证多个mock对象的必须以指定顺序被调用
 List firstMock = mock(List.class);
 List secondMock = mock(List.class);

 //使用多个模拟的对象
 firstMock.add("was called first");
 secondMock.add("was called second");

 // 创建inOrder对象，将需要验证的模拟对象传进来
 InOrder inOrder = inOrder(firstMock, secondMock);

 // 下面将会确认第一个模拟对象会在第二个模拟对象前被调用
 inOrder.verify(firstMock).add("was called first");
 inOrder.verify(secondMock).add("was called second");

 // Oh, and A + B can be mixed together at will

验证执行顺序是非常灵活的 - 你不需要一个一个的验证所有交互,只需要验证你感兴趣的对象即可。
另外，你可以仅通过那些需要验证顺序的mock对象来创建InOrder对象。

7. 确认交互(interaction)操作没有在mock对象上执行

 // 使用Mock对象 - 只有 mockOne发生了交互
 mockOne.add("one");

 // 普通验证
 verify(mockOne).add("one");

 // 验证一个模拟对象没有执行某个方法
 verify(mockOne, never()).add("two");

 // 验证其他mock对象没有交互
 verifyZeroInteractions(mockTwo, mockThree);

8. 查找多余的调用

//using mocks
mockedList.add("one");
mockedList.add("two");

verify(mockedList).add("one");

// 下面的验证将会失败
verifyNoMoreInteractions(mockedList);

一些做了很多经典的、期望-执行-测试风格的模拟的用户，可能倾向于经常使用verifyNoMoreInteractions()，甚至在每个测试函数中都用。但是verifyNoMoreInteractions()并不建议在每个测试函数中都使用。verifyNoMoreInteractions()在交互测试套件中只是一个便利的验证，它的作用是当你需要验证是否存在冗余调用时。滥用它将导致测试代码的可维护性降低。你可以阅读这篇文档来了解更多相关信息。

也可以看看never()，它更加明确，并且很好地传达了意图。

9. 简化mock对象的创建 - @Mock注解

  • 最小化重复的创建代码
  • 使测试类的代码可读性更高
  • 使验证错误更易于阅读，因为字段名可用于标识mock对象
public class ArticleManagerTest {

   @Mock private ArticleCalculator calculator;
   @Mock private ArticleDatabase database;
   @Mock private UserProvider userProvider;

   private ArticleManager manager;

注意！ 下面这句代码需要在运行测试函数之前被调用,一般放到测试类的基类或者test runner中:

 MockitoAnnotations.initMocks(testClass);

你可以使用内置的runner: MockitoJUnitRunner runner 或者一个rule : MockitoRule。关于JUnit5的测试案例，查看45章节关于JUnit扩展的描述。
关于mock注解的更多信息可以阅读MockitoAnnotations文档。

10. 为连续的调用打桩 (迭代器风格的打桩)

有时我们需要为同一个函数调用的不同的返回值/异常做测试桩。典型的运用案例就是对迭代器的模拟。
原始版本的Mockito并没有这个特性来促进模拟行为更简单，例如，可以使用Iterable或者简单的集合来替换迭代器。这些方法提供了更自然的方式，在一些场景中为连续的调用做测试桩会很有用。示例如下 ：

 when(mock.someMethod("some arg"))
   .thenThrow(new RuntimeException())
   .thenReturn("foo");

 // 第一次调用 : 抛出运行时异常
 mock.someMethod("some arg");

 // 第二次调用 : 输出"foo"
 System.out.println(mock.someMethod("some arg"));

 // 后续调用 : 也是输出"foo"
 System.out.println(mock.someMethod("some arg"));

另外，连续调用的另一种更简短的版本 :

// 第一次调用时返回"one",第二次返回"two",第三次返回"three"
 when(mock.someMethod("some arg"))
   .thenReturn("one", "two", "three");

注意：如果替代了“.thenReturn()"的调用，多个使用相同匹配器或参数的打桩动作，那么每个打桩动作都会覆盖之前的动作：

 //All mock.someMethod("some arg") calls will return "two"
 when(mock.someMethod("some arg"))
   .thenReturn("one");
 when(mock.someMethod("some arg"))
   .thenReturn("two");

11. 通过回调方式来打桩

允许通过泛型Answer接口进行打桩。

在最初的Mockito里也没有这个具有争议性的特性。我们建议使用thenReturn() 或thenThrow()来打桩。这两种方法足够用于测试或者测试驱动开发。
如果你需要用泛型Answer接口来打桩，下面是个例子：

 when(mock.someMethod(anyString())).thenAnswer(new Answer() {
     Object answer(InvocationOnMock invocation) {
         Object[] args = invocation.getArguments();
         Object mock = invocation.getMock();
         return "called with arguments: " + args;
     }
 });

 // 输出 : "called with arguments: foo"
 System.out.println(mock.someMethod("foo"));

12. doReturn()|doThrow()| doAnswer()|doNothing()|doCallRealMethod()系列方法

通过when(Object)为无返回值的函数打桩有不同的方法,因为编译器不喜欢void函数在括号内…

当你想为void函数打桩来跑出一个异常时，使用doThrow()方法:

doThrow(new RuntimeException()).when(mockedList).clear();

// 下面的代码会抛出运行时异常
mockedList.clear();

当你调用doThrow(), doAnswer(), doNothing(), doReturn() and doCallRealMethod() 这些函数时，可以在适当的位置调用when()函数. 当你需要下面这些功能时这是必须的:

  • 测试void函数
  • 在受监控的对象上测试函数
  • 同一个函数多次打桩，为了在测试过程中改变mock对象的行为。

但是在调用when()函数时你可以选择是否调用这些上述这些函数。

阅读更多关于这些方法的信息:

  • doReturn(Object)
  • doThrow(Throwable)
  • doThrow(Class)
  • doAnswer(Answer)
  • doNothing()
  • doCallRealMethod()

13. 监控真实对象

你可以为真实对象创建多个监控(spy)对象。当使用这个spy对象时，真实的方法会被调用（除非它的函数被stub了）。尽量少使用spy对象，使用时也需要小心形式，例如spy对象可以用来处理遗留代码。

监控一个真实的对象可以与“局部mock对象”概念结合起来。在1.8之前，mockito的监控功能并不是真正的局部mock对象。原因是我们认为局部mock对象的实现方式并不好。在某些时候，我们发现了使用局部mock对象的合法用例。（第三方接口、临时重构遗留代码，完整的文章在这里 ）

List list = new LinkedList();
List spy = spy(list);

//可选的，你可以为某些函数打桩:
when(spy.size()).thenReturn(100);

//通过spy对象调用真实对象的函数
spy.add("one");
spy.add("two");

//打印第一个元素"one"
System.out.println(spy.get(0));

//size()函数被打桩了,因此这里打印的是100
System.out.println(spy.size());

//可选的，你可以做校验
verify(spy).add("one");
verify(spy).add("two");

理解监控真实对象非常重要！

有时，在监控对象上使用when(Object)来进行打桩是不可能或者不切实际的。因此，当使用监控对象时请考虑doReturn|Answer|Throw()函数族来进行打桩。例如 :

List list = new LinkedList();
List spy = spy(list);

//不可能 : 当调用spy.get(0)时会调用真实对象的get(0)函数，此时会发生IndexOutOfBoundsException异常（因为真实list对象还是空的）
when(spy.get(0)).thenReturn("foo");

//你必须使用doReturn()来打桩
doReturn("foo").when(spy).get(0);

Mockito并不会代理传递来的真实对象，实际上它会拷贝一份真实对象。因此如果你保留了真实对象并且与之交互，不要期望从监控对象得到正确的结果。当你在监控对象上调用一个没有被stub的函数时，并不会调用真实对象的对应函数，你不会在真实对象上看到任何效果。

注意final方法，Mockito不能mock final方法，所以底线是：当你监视真实对象，你尝试在fianl方法上打桩，那么会有问题。同样，你也不能验证这些方法。

14. 修改没有测试桩的调用的默认返回值 ( 1.7版本之后 )

你可以创建mock对象，用指定策略来作为它的返回值。这是一个高级特性，通常来说，你不需要写这样的测试。无论如何，它对于遗留系统来说是很有用处的。

当你没有为函数调用打桩时，你可以指定一个默认的answer。

Foo mock = mock(Foo.class, Mockito.RETURNS_SMART_NULLS);
Foo mockTwo = mock(Foo.class, new YourOwnAnswer());

关于RETURNS_SMART_NULLS更多的信息请查看 :
RETURNS_SMART_NULLS文档 。

15. 为下一步的断言捕获参数 (1.8版本之后)

Mockito以java代码风格的形式来验证参数值 : 即通过使用equals()函数。这也是我们推荐用于参数匹配的方式，因为这样会使得测试代码更简单、简洁。在某些情况下，当验证交互之后要检测真实的参数值时这将变得有用。例如 ：

ArgumentCaptor<Person> argument = ArgumentCaptor.forClass(Person.class);
//参数捕获
verify(mock).doSomething(argument.capture());
//使用equal断言
assertEquals("John", argument.getValue().getName());

警告 : 我们建议在验证时使用ArgumentCaptor，而不是在打桩时。在打桩时使用ArgumentCaptor会降低测试代码的可读性，因为captor是在断言(又称为 验证/then)代码块之外创建的。另外，它可以降低本地化的缺点，因为如果测试桩函数没有被调用，那么参数就不会被捕获。

总之，ArgumentCaptor与自定义的参数匹配器相关(可以查看ArgumentMatcher类的文档 )。这两种技术都能用于检测外部传递到Mock对象的参数。然而，使用ArgumentCaptor在以下的情况下更合适 :

  • 自定义不能被重用的参数匹配器
  • 你仅需要断言参数值

打桩时用自定义参数匹配器更好点ArgumentMatcher。

16. 真实的局部模拟对象(mocks) (1.8版本之后)

在内部通过邮件进行了无数争辩和讨论后，最终 Mockito 决定支持部分mock，早前我们不支持是因为我们认为局部mocks会让代码变得糟糕。然而，我们发现了局部mocks真正合理的用法。详情点这

在 Mockito 1.8 之前，spy() 方法并不会产生真正的局部mocks，而这无疑会让一些开发者困惑。更详细的内容可以看：这里 或 Java 文档

    //你能spy()方法创建局部模拟的对象:
    List list = spy(new LinkedList());

    //局部mock能力是可选的
    Foo mock = mock(Foo.class);
    //确保这个真实调用是'安全的'
    //如果真实调用抛了异常或者依赖对象的特殊状态，那么就会有麻烦。（对象被mock，状态可能跟预期不一样。)
    when(mock.someMethod()).thenCallRealMethod();

一如既往，你应该阅读局部mock的注意事项：面向对象编程通过把复杂系统拆分成独立个体来减少整体的复杂度，尤其是，SRPy对象。那局部mock是怎么遵循这个规范的呢？事实上它并没有遵循这个规范……局部mock通常意味着复杂性被移动到同一个对象的不同方法中，在大多数情况下，这不会是你想要的应用架构方式。

然而，在一些特殊的情况下局部mocks是方便的：处理不能轻易修改的代码（第三方接口，临时重构的遗留代码等）。然而，在新的测试驱动和架构优秀的代码上，我是不会使用局部mocks的。

17. 重置mocks对象 (1.8版本之后)

聪明的 Mockito 使用者很少会用到这个特性，因为他们知道这是出现糟糕测试单元的信号。通常情况下你不会需要重设你的mocks，只需要为每个测试方法重新创建一个mocks就可以了。

请考虑实现简单、小并且专注的测试方法，而不是冗长的、特殊的测试用例，来代替reset()。首先可能出现的代码异味的地方就是测试方法中间的 reset() 方法。这可能意味着你已经过度测试了。请倾听测试方法的声音：请让我们小巧的，而且专注在单一的行为上。在 Mockito 邮件列表中就有好几个和这个有关的讨论。

添加 reset() 方法的唯一原因是让它能与容器注入的mocks协作。详情看 issue 55 或 FAQ。

别自己给自己找麻烦，reset() 方法在测试方法中间确实是代码异味。

   List mock = mock(List.class);
   when(mock.size()).thenReturn(10);
   mock.add(1);

   reset(mock);
   //在此刻，mock对象遗忘了所有的interactions & stubbing

18. 故障排查与验证框架的使用 (1.8版本之后)

首先，如果出现了任何问题，我建议你先看 Mockito FAQ。

万一有问题，你可以把问题提交到 Mockito 的邮件列表中。

然后，如果你一直正确的使用Mocktio，你应该知道Mockito的检查机制。对此有疑惑的话不妨看看 validateMockitoUsage() 的文档说明。

19.行为驱动开发的别名 (1.8版本之后)

用行为驱动开发的风格来写测试用例，会使用//given //when //then 注解作为测试方法的基础部分。这正是我们编写测试的方式，我们热情地鼓励您这样做！

你可以在这开始学习有关 BDD 的知识

问题是：当前打桩API中，‘when’的规范角色没有很好的集成到//given //when //then注释中。这是因为测试打桩属于测试中的given部分，而且不是测试中的when部分。因此 BDDMockito 类介绍了一个别名，使你的测试桩方法调用 BDDMockito.given(Object) 方法。现在它可以很好地和BDD风格的测试中的given部分进行交互。

测试用例看起来会是这样子:

 import static org.mockito.BDDMockito.*;

 Seller seller = mock(Seller.class);
 Shop shop = new Shop(seller);

 public void shouldBuyBread() throws Exception {
   //given
   given(seller.askForBread()).willReturn(new Bread());

   //when
   Goods goods = shop.buyBread();

   //then
   assertThat(goods, containBread());
 }

20. 可序列化的mocks(1.8.1版本之后)

模拟的对象是可以被序列化的。有了这个特性，你就可以在要求依赖项是可序列化的地方，使用模拟对象。

警告：这个特性应该在单元测试中少用。

实现这个特性是为了DBB规范的一个特例：有一个不可靠的外部依赖。在web环境下，来自外部依赖的对象为了在不同层之间传递，会被序列化。

用MockSettings.serializable():创建一个可序列化的mock对象:

   List serializableMock = mock(List.class, withSettings().serializable());

假设所有普通的序列化要求都被类满足了，模拟的对象是能被序列化的。

让一个真实的侦查对象可序列化需要多一些努力，因为 spy(…) 方法没有接收 MockSettings 参数的重载版本。不过不用担心，你几乎不可能用到这。

 List<Object> list = new ArrayList<Object>();
 List<Object> spy = mock(ArrayList.class, withSettings()
                 .spiedInstance(list)
                 .defaultAnswer(CALLS_REAL_METHODS)
                 .serializable());

21. 新的注解 : @Captor,@Spy,@InjectMocks (1.8.3版本之后)

V1.8.3 带来的新注解在某些场景下可能会很实用:

@Captor 简化 ArgumentCaptor 的创建 - 当需要捕获的参数是一个令人讨厌的泛型类，而且你想避免编译时警告。

@Spy - 你可以用它代替 spy(Object) 方法

@InjectMocks - 自动将模拟或监视的对象注入到被测试对象中。

需要注意的是 @InjectMocks 也能与 @Spy 一起使用，这就意味着 Mockito会在测试中，将mocks对象注入局部mock对象中。这变得很复杂，所以你还是应该少用局部mock。参考16点关于局部mock的介绍。

所有新的注解都是只在MockitoAnnotations.initMocks(Object)被处理。就像@Mock注解，你能用内置runner(MockitoJUnitRunner 或 规则: MockitoRule)来开启。
所有新的注解都是只在[MockitoAnnotations.initMocks(Object)]

22. 带超时的验证 (1.8.5版本之后)

允许带超时的验证。这使得一个验证会等待一段特定的时间，以获得想要的交互，而不是还没有发生事件就立即失败(即超时时间到了才会失败)。在并发条件下的测试这会很有用。

这个特性应该少被使用 - 找到更好的方法去测试多线程系统。

还没有实现和 InOrder 验证协作。

例子：

   //someMethod()执行时间不少于100ms才会结束
   //校验通过时马上会马上结束(可能不会等到100ms)
   verify(mock, timeout(100)).someMethod();
   //上一行例子是下面这行代码的别名:
   verify(mock, timeout(100).times(1)).someMethod();

   //someMethod()在100ms内执行了2次就会马上通过
   verify(mock, timeout(100).times(2)).someMethod();

   //等效: someMethod()在100ms内执行了2次就会马上通过
   verify(mock, timeout(100).atLeast(2)).someMethod();

23. 自动实例化被@Spies, @InjectMocks注释的字段以及构造函数注入 (1.9.0版本之后)

Mockito 现在会通过构造器注入、setter注入 或字段注入方式，尽可能初始化带有 @Spy 和 @InjectMocks 注解的字段。

为了利用这个特性，你需要使用 MockitoAnnotations.initMocks(Object), MockitoJUnitRunner 或 MockitoRule。

请在InjectMocks的javadoc查看更多的使用技巧和注入规范

 //旧的写法:
 @Spy BeerDrinker drinker = new BeerDrinker();
 //新的写法:
 @Spy BeerDrinker drinker;

 //@InjectMocks注解也可以这么用:
 @InjectMocks LocalPub;

24. 单行测试桩 (1.9.0版本之后)

Mockito 现在允许在打桩时创建模拟对象。主要是，它允许通过一行代码来创建一个测试桩。这对保持代码的整洁很有用。举例来说，在测试字段初始化时，有些简单的测试桩可以被创建并赋值到字段上，例如：

 public class CarTest {
   Car boringStubbedCar = when(mock(Car.class).shiftGear()).thenThrow(EngineNotStarted.class).getMock();

 @Test public void should... {}

25. 验证被忽略的测试桩 (1.9.0版本之后)

Mockito 现在允许为了更好的验证而忽略已有的测试桩。与 verifyNoMoreInteractions() 方法或验证 inOrder() 方法组合使用，有时很有用。帮助避免多余的测试桩调用校验 - 显然我们不会对验证测试桩感兴趣。

警告，ignoreStubs() 可能会导致 verifyNoMoreInteractions(ignoreStubs(…)) 方法的过度使用。谨记在心，Mockito 没有推荐在每一个测试中用 verifyNoMoreInteractions() 方法，原因在 verifyNoMoreInteractions(Object…)的Java 文档中有。

一些例子：

 verify(mock).foo();
 verify(mockTwo).bar();

 //忽略所有已经打桩的方法:
 verifyNoMoreInvocations(ignoreStubs(mock, mockTwo));

 //创建 InOrder 将会忽略打桩信息
 InOrder inOrder = inOrder(ignoreStubs(mock, mockTwo));
 inOrder.verify(mock).foo();
 inOrder.verify(mockTwo).bar();
 inOrder.verifyNoMoreInteractions();

更好的例子和更多的细节都可以在 Java 文档的 ignoreStubs(Object…) 部分看到。

26. mock详情 (2.2.x中改进)

Mockito 提供API来查看mock对象的详情。这些API对高级用户和mock框架整合者很有用。

   //识别特定的对象是一个mock对象或者是spy对象:
   Mockito.mockingDetails(someObject).isMock();
   Mockito.mockingDetails(someObject).isSpy();

   //获取mock对象的详情信息，包括它的类型或默认的answer:
   MockingDetails details = mockingDetails(mock);
   details.getMockCreationSettings().getTypeToMock();
   details.getMockCreationSettings().getDefaultAnswer();

   //获取mock对象的执行器(invocations)和打桩信息(stubbings):
   MockingDetails details = mockingDetails(mock);
   details.getInvocations();
   details.getStubbings();

   //打印所有的交互(including stubbing, unused stubs)
   System.out.println(mockingDetails(mock).printInvocations());

更多信息请查看MockingDetails的java文档.

27. 真实实例的委托调用 (Since 1.9.5)

代理调用对间谍或局部mock的对象有用的，这些对象用常规 spy API很难去mock或spy。从 Mockito 的 1.10.11 版本开始， delegate 有可能和 mock 的类型相同也可能不同。如果不是同一类型，delegate 类型需要提供一个匹配方法否则就会抛出一个异常。可能用到这个特性的案例:

  • 带有 interface 的 final 类
  • 已经自定义代理的对象
  • 带有 finalize 方法的特殊对象，就是避免执行2次。

和常规 spy 的不同:

  • 标准的 spy (spy(Object)) 包含被监视实例的所有状态信息，方法在 spy 对象上被调用。被监视的对象只在 mock
    创建时被用来拷贝状态信息。如果你通过标准 spy 调用一个方法，这个 spy 会调用其内部的其他方法记录这次操作，
    以便后面验证使用。等效于存根 (stubbed)操作。

  • 代理方式的 mock 只是简单的把所有方法委托给 delegate。delegate 一直被当成它所代理的方法使用。如果你调用委托的mock对象上的方法，它会调用其内部的其他方法，这些调用不会被记录，打桩动作 在这里也不会生效。委托方式的Mock 相对于标准的 spy 来说功能弱了很多，不过在标准 spy 不能被创建的时候这还是很有用。

更多信息可以看这里 AdditionalAnswers.delegatesTo(Object).

28. MockMaker API (Since 1.9.5)

为了满足用谷歌Android用户的需求，Mockito 现在提供一个扩展点，允许替换代理生成引擎。默认情况下，Mockito 使用 Byte Buddy 创建动态代理。

这个扩展点是为想要扩展 Mockito 功能的高级用户准备的。比如，我们现在就可以在 dexmaker 的帮助下使用 Mockito
测试 Android。

更多的细节，原因和示例请看 MockMaker 的文档。

29. BDD 风格的验证 (Since 1.10.0)

开始验证时，使用then关键字可以开启 Behavior Driven Development (BDD) 风格的验证。

 given(dog.bark()).willReturn(2);

 // when
 ...

 then(person).should(times(2)).ride(bike);

更多信息请查阅 BDDMockito.then(Object) .

30. 监视 或 模拟 抽象类 (1.10.12版本加入，在2.7.13 和 2.7.14版特征得到增强))

现在可以方便的 spy 一个抽象类。注意，过度使用 spy 或许意味着代码的设计上有问题。(see spy(Object)).

之前，spying 只可以用在实例对象上。而现在新的 API 可以使用构造函数来创建一个 mock 实例。这对 mock
一个抽象类来说是很重要的，这样使用者就不必再提供一个抽象类的实例了。目前的话只支持无参构造函数，
如果你认为这样还不够的话欢迎向我们反馈。

 //方便的API，新增重载的spy()方法:
 SomeAbstract spy = spy(SomeAbstract.class);

 //模拟抽象方法，监视接口默认方法(只有在2.7.13后才可用)
 Function function = spy(Function.class);

 //健壮的 API，通过配置构造器:
 OtherAbstract spy = mock(OtherAbstract.class, withSettings()
    .useConstructor().defaultAnswer(CALLS_REAL_METHODS));

 //模拟构造器带参数的抽象类(只有在2.7.14后才可用)
 SomeAbstract spy = mock(SomeAbstract.class, withSettings()
   .useConstructor("arg1", 123).defaultAnswer(CALLS_REAL_METHODS));

 //模拟非静态内部抽象类:
 InnerAbstract spy = mock(InnerAbstract.class, withSettings()
    .useConstructor().outerInstance(outerInstance).defaultAnswer(CALLS_REAL_METHODS));

更多信息请见 MockSettings.useConstructor() .

31. Mockito的模拟对象 可以通过 classloaders 序列化/反序列化 (Since 1.10.0)

Mockito 通过 classloader 引入序列化。和其他形式的序列化一样，所有 mock 层的对象类型都要可序列化，
包括 answers。因为序列化模式需要大量的工作，所以这是一个可选配置。

// 常规的 serialization
mock(Book.class, withSettings().serializable());

// 通过 classloaders 序列化
mock(Book.class, withSettings().serializable(ACROSS_CLASSLOADERS));

更多信息请查看 MockSettings.serializable(SerializableMode).

32. Deep stubs 更好的泛型支持 (Since 1.10.0)

深度打桩模式 现在可以更好的查找类的泛型信息。这就意味着像这样的类
不必去 mock 它的行为就可以使用。

class Lines extends List<Line> {
     // ...
 }

 lines = mock(Lines.class, RETURNS_DEEP_STUBS);

 //现在 Mockito 知道这是Line类型，而不是Object
 Line line = lines.iterator().next();

请注意，大多数情况下 mock 返回一个 mock 对象是错误的。

33. Mockito JUnit rule (Since 1.10.17)

Mockito 现在提供一个 JUnit 的 rule。目前为止，有两种方法可以初始化 fields ，这些fields使用了 Mockito 提供的注解比如
@Mock, @Spy, @InjectMocks 等等。

  • 用 @RunWith(@MockitoJUnitRunner.class) 标注 JUnit 测试类
  • 在 @Before 方法中调用 MockitoAnnotations.initMocks(Object)

现在你可以选择使用一个 rule:

 @RunWith(YetAnotherRunner.class)
 public class TheTest {
     @Rule public MockitoRule mockito = MockitoJUnit.rule();
     // ...
 }

更多信息到这里查看 MockitoJUnit.rule().

34. 开启和关闭插件的开关 (Since 1.10.15)

这是一个测试特性，可以控制一个 mockito-plugin 开启或者关闭。详情请查看 PluginSwitch

35. 自定义验证失败信息 (Since 2.1.0)

允许声明一个在验证失败时输出的自定义消息
示例:

 // 在验证失败时，会打印自定义的消息
 verify(mock, description("This will print on failure")).someMethod();

 // 任何验证模式下都能使用这种方式
 verify(mock, times(2).description("someMethod should be called twice")).someMethod();

36. Java 8 Lambda匹配器的支持 (Since 2.1.0)

你可以在参数匹配器(ArgumentMatcher)上使用Java 8 lambda表达式，来减少对参数捕获器(ArgumentCaptor)的依赖。如果你需要验证mock对象上方法调用的输入是正确的，那么你需要正常使用参数捕获器来找到使用过的操作数，并且之后对它们做断言。对于复杂的例子这是有用的，当然它也很啰嗦。

写一个lambda来表示匹配关系是很容易的。你方法的参数使用argThat进行连接时，参数将作为强类型对象传给参数匹配器，所以通过这种方式能做任何事情。

例如:

 // 验证一个list只添加了某些长度的字符串(字符串长度小于5)
 // 注意 - 这种写法只有在Java 8下能编译通过
 verify(list, times(2)).add(argThat(string -> string.length() < 5));

 // Java 7 等效的 - 不太整洁
 verify(list, times(2)).add(argThat(new ArgumentMatcher(){
     public boolean matches(String arg) {
         return arg.length() < 5;
     }
 }));

 // Java 8 下，更复杂的例子 - 你可以通过函数式指定复杂的验证行为
 verify(target, times(1)).receiveComplexObject(argThat(obj -> obj.getSubObject().get(0).equals("expected")));

 // lambda的方式也可以被用到：定义不同入参下，mock对象的行为
 // in this case if the input list was fewer than 3 items the mock returns null
 when(mock.someMethod(argThat(list -> list.size()<3))).thenReturn(null);

37. Java 8 自定义Answer的支持 (Since 2.1.0)

Answer接口只有一个方法，Java 8 使用lambda表达式来实现它非常简单。你越需要使用方法调用的参数，就越需要对来自InvocationOnMock的参数进行类型转换。

例如:


 // answer每次都返回12
 doAnswer(invocation -> 12).when(mock).doSomething();

 // 用参数里的一个值作为返回值 - 转换成你想要的正确类型 
 //- 在这个例子里，把第二个字符串类型的参数的长度，作为返回值。
 //随着参数的增长，这很快就会变得冗长。
 doAnswer(invocation -> ((String)invocation.getArgument(1)).length())
     .when(mock).doSomething(anyString(), anyString(), anyString());

方便起见，现在我们可以定义这样的answer/actions，用被调用方法的参数作为answer/actions中lambda的入参。即使在Java 7和更低版本，自定义基于类型化接口的answers也能减少样板代码。在特定场景，这种方法使测试使用了回调的方法更加容易。answer() 和 answerVoid()方法可以创建answer对象。它们依赖的相关answer接口在org.mockito.stubbing包下，Answer接口最多支持5个参数。

例如:


 //例如，将要被模拟的接口有一个这样的方法:
 void execute(String operand, Callback callback);

 //这个例子的回调函数有一个方法，测试类会依赖这个回调的执行
 void receive(String item);

 // Java 8 - style 1
 doAnswer(AdditionalAnswers.answerVoid((operand, callback) -> callback.receive("dummy"))
     .when(mock).execute(anyString(), any(Callback.class));

 // Java 8 - style 2 - 假设AdditionAnswers已经静态导入
 doAnswer(answerVoid((String operand, Callback callback) -> callback.receive("dummy"))
     .when(mock).execute(anyString(), any(Callback.class));

 // Java 8 - style 3 - 被模拟的方法是测试类的静态成员
 private static void dummyCallbackImpl(String operation, Callback callback) {
     callback.receive("dummy");
 }

 doAnswer(answerVoid(TestClass::dummyCallbackImpl)
     .when(mock).execute(anyString(), any(Callback.class));

 // Java 7
 doAnswer(answerVoid(new VoidAnswer2() {
     public void answer(String operation, Callback callback) {
         callback.receive("dummy");
     }})).when(mock).execute(anyString(), any(Callback.class));

 // 用answer() 方法返回一个值是可能的，
 // 并且有返回值版本的函数式接口也是如此，
 // 如果模拟的接口有一个这样的方法:
 boolean isSameString(String input1, String input2);

 // Java 8 - 这种方式是可以被模拟的
 doAnswer(AdditionalAnswers.answer((input1, input2) -> input1.equals(input2))))
     .when(mock).execute(anyString(), anyString());

 // Java 7
 doAnswer(answer(new Answer2() {
     public String answer(String input1, String input2) {
         return input1 + input2;
     }})).when(mock).execute(anyString(), anyString());

38. 元数据和泛型信息保留 (Since 2.1.0)

Mockito 现在会保留mock方法和类上的注解信息，也会保留泛型的元信息。以前，mock类型不保存类上的注解信息除非注解被显示地继承，并且不保存方法上的注解信息。因此，下面的情况现在是有效的:


 @MyAnnotation
  class Foo {
    List<String> bar() { ... }
  }

  Class<?> mockType = mock(Foo.class).getClass();
  assert mockType.isAnnotationPresent(MyAnnotation.class);
  assert mockType.getDeclaredMethod("bar").getGenericReturnType() instanceof ParameterizedType;

使用 Java 8，Mockito 现在也保存类型注解(type annotations)。这是默认行为，如果有可选择的MockMaker被使用，这种行为可能不会持续。

39. 模拟final类型，枚举 和 final方法 (Since 2.1.0)

Mockito 现在对模拟final类和方法提供一个孵化中的，可选的的支持。这是一个极好的改进，说明了Mockito永恒的追求：提高测试体验。我们的志向是：Mockito要支持final类和方法。以前，它们被认为是不可模拟的，阻止用户去模拟的。我们已经开始讨论怎么使这个特性被默认支持。当前，这个特性仍然是可选的，我们等待社区里更多的反馈。

这个可选的mock maker，它使用Java instrumentation API和子类两者结合的方式，而不是创建一个新的类来代表这个mock对象。通过这种方式，使模拟final类和方法成为了可能。

这个mock maker默认是关闭的，因为它是基于完全不同的模拟机制，这种机制需要社区更多的反馈。它能通过mockito的扩展机制来被激活，只要在classpath上创建一个文件/mockito-extensions/org.mockito.plugins.MockMaker，文件包含mock-maker-inline这个值。

方便起见，Mockito团队提供了一个artifact，这个artifact里mock maker已经配置好。在项目中引入mockito-inline artifact来代替mockito-core artifact。注意，等到对final类和方法的模拟功能集成到默认的mock maker后，这个artifact可能会停止。

关于这个mock maker几个需要注意的点是:

  • 模拟final类和枚举的mock配置是不兼容的:
  • 显示的序列化支持 withSettings().serializable()
  • 特殊接口 withSettings().extraInterfaces()
  • 一些方法不能被模拟
  • java.*包下的方法
  • 原生方法
  • 这个mock maker被设计成围绕着Java Agent运行时的附件(attachment)；这个要求一个兼容的JVM，JVM是JDK的一部分(或Java 9的虚拟机)。当运行在Java 9之前没JDK的虚拟机上，可以在JVM启动时，通过-javaagent参数，手动添加Byte Buddy的jar包。

如果你对这个特性的细节感兴趣，请阅读org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker的java文档。

40. “严格的”Mocktio能提高生产效率并使测试用例更清晰(2.+版本之后)

为什么“严格的”Mockito能使你的生产率更好，并使你的测试更整洁，看:

  • 通过JUnit Rules来开启严格打桩 - MockitoRule.strictness(Strictness) with Strictness.STRICT_STUBS
  • 通过Junit Runner来开启严格打桩 - MockitoJUnitRunner.StrictStubs
  • 如果你不能使用runner/rule(例如使用TestNG)来开启严格打桩 - MockitoSession
  • 通过MockitoJUnitRunner发现非必要测试桩
  • 打桩参数不匹配的警告，记录在MockitoHint中

Mockito默认是一个“宽松的”模拟框架。mock对象可以做交互，而不用事设置期望的行为。这是有意设计的，它通过强制用户明确地表达他们想要 打桩/验证的内容来提高测试的质量。它也非常直观的，易于使用，并且和“given”，“when”，“then”整洁的测试代码模板完美融合在一起。这也是区别于过去其他的经典模拟框架，过去的框架默认都是严格的。

默认是“宽松的”，有时让Mockito的测试用例难于被debug。有些情况下，配置错误的打桩强制用户使用调试器执行测试用例。理想状况下，测试用例失败是显而易见的结果，并且不需要调试器来定位根本原因。从2.1版本开始，Mockito拥有一些新的特性，这些特性推动框架走向“严格性”。我们想让Mockito提供出色的调试能力，同时也不丢失它核心的模拟风格，针对直观性，清晰性和整洁的测试代码进行优化。

帮助 Mockito！尝试这些新的特性，给我们反馈，加入GitHub issue 769关于Mockito严格性的讨论。

41. 框架集成的高级公开API (2.10.+版本之后)

在2017的夏天，我们觉得Mockito应该为高级框架集成提供更好的API。这个新的API不是为了写单元测试的用户。它旨在用于需要用一些定制逻辑扩展或包装Mockito的其他测试工具和模拟框架。在设计期间和实现过程中(issue 1110)，我们开发和改变了下列公开API的元素：

  • 新的 MockitoPlugins - 使框架集成者能够访问默认的Mockito插件。当需要实现自定义插件(例如MockMaker)，并且将某些行为委托给默认Mockito的实现。
  • 新的 MockSettings.build(Class) - 创建模拟配置的不可变的视图，供Mockito稍后使用。使用InvocationFactory创建invocations 或 当实现自定义MockHandler时，视图将非常有用。
  • 新的 MockingDetails.getMockHandler() - 其他框架可能使用这个mock处理器，以编程方式对mock对象模拟调用。
  • 新的 MockHandler.getMockSettings() - 用于获取创建模拟对象的配置。
  • 新的 InvocationFactory - 提供创建调用对象实例的方法。有益于需要以编程方式模拟在mock对象上的方法调用的框架集成。
  • 新的 MockHandler.getInvocationContainer() - 提供获取没有方法的调用容器对象(makrer接口)。容器需要隐藏它内部的实现机制，并且避免将其泄露给公共API。
  • 改变Stubbing接口 - Stubbing现在继承自 Answer 接口。它是向后兼容的，因为Stubbing接口不是一个可扩展的(看@NotExtensible注解)。这个改变对用户来说是无感的。
  • InternalMockHandler标记为过期的 - 为了适应API变化，我们需要标记这个接口成过期的。这个接口一直记录为内部的，我们没有证据证明它被社区使用。这个弃用行为应该对用户完成无感。
  • NotExtensible - 公共的注释，指示用户不应该对提供给定类型的自定义实现。帮助框架集成者和我们的用户理解怎么去安全的使用Mockito API。

你有反馈吗？请在issue 1110里留言。

42. 集成新的API: 监听验证开始(verification start)事件(2.11.+版本之后)

Spring Boot等框架集成需要公共API来处理双代理用例(issue 1191)。我们新增的:

  • 新的 VerificationStartedListener 和 VerificationStartedEvent 使框架集成者替换模拟对象以进行验证。主要的驱动用例是Spring Boot的集成。详情请看VerificationStartedListener的java文档。
  • 新的公共方法MockSettings.verificationStartedListeners(VerificationStartedListener…)允许在mock创建时，提供验证启动的监听器。
  • 新的方便的方法MockingDetails.getMock()被添加，用来使MockingDetails API更加完整。我们发现这个方法在实例化时非常有用。

43. 集成新的API: 测试框架支持MockitoSession(2.15.+版本之后)

MockitoSessionBuilder and MockitoSession得到增强，以便通过测试框架集成实现重用(例如MockitoRule对于JUnit一样)。

  • MockitoSessionBuilder.initMocks(Object…) 允许传入多个测试类的实例，用来初始化被Mockito注解(例如@Mock)注释的字段。当测试使用多个(例如内嵌的)测试类实例时，这个方法对高级框架集成非常有用(例如 JUnit Jupiter)。
  • MockitoSessionBuilder.name(String)允许将名称从测试框架传递到MockitoSession，当使用Strictness.WARN时，MockitoSession将用于打印警告。
  • MockitoSessionBuilder.logger(MockitoSessionLogger)使定制，用于完成模拟时产生的提示/告警 的logger成为了可能(对于测试和连接JUnit Jupiter等测试框架提供的报告功能很有用)。
  • MockitoSession.setStrictness(Strictness)允许在一次性情况下，改变一个MockitoSession的严格性。例如，它可以为一个类下的所有测试用例设置一个默认的严格性，但是也可以改变单个或几个测试用例的严格性。
  • 添加MockitoSession.finishMocking(Throwable)用于避免因多个竞争的失败而可能出现的混乱。当提供的失败用例不是null时，它会关闭某些检查。

44. org.mockito.plugins.InstantiatorProvider泄露内部API所以被org.mockito.plugins.InstantiatorProvider2替代(2.15.4版本之后)

InstantiatorProvider返回了一个内部API。因此它被启用并且被[InstantiatorProvider2][InstantiatorProvider2]替代。旧的调用者提供商将继续工作，但是它被推荐切换到新的API。

[InstantiatorProvider2https://static.javadoc.io/org.mockito/mockito-core/2.23.4/org/mockito/plugins/InstantiatorProvider2.html

45. JUnit5+的扩展

想要和JUnit Jupiter(JUnit5+)集成，可以使用org.mockito:mockito-junit-jupiter artifact。有关集成使用的更多信息，请查阅MockitoExtension的Java文档。

46. 新的Mockito.lenient()和MockSettings.lenient()方法(2.20.0版本之后)

在Mockito2早期开始，就有严格打桩的特性。它非常有用，因为它驱动更整洁的测试用例和提供生产率。严格打桩上报非必要的桩点，检查打桩参数不匹配 并且使测试用例更DRY(Strictness.STRICT_STUBS)。这需要权衡：在某些情况，你可能从严格打桩得到错误的否定。为了补救这种情况，你可以将特定打桩配置为宽松的，而所有其他的打桩和mocks使用严格打桩:

 lenient().when(mock.foo()).thenReturn("ok");

如果你想在给定的mock对象的所有打桩都是宽松的，你可以按照下面的方式配置mock对象:

 Foo mock = Mockito.mock(Foo.class, withSettings().lenient());

查阅lenient()更多的信息。开启一个GitHub的issue来讨论，让我们知道你是怎么发现这个新特性。

字段摘要

类型 字段以及描述
static Answer< Object > CALLS_REAL_METHODS
用于mock(Class, Answer)的可选参数Answer

字段详情

**CALLS_REAL_METHODS**
public static final Answer CALLS_REAL_METHODS

用于mock(Class, Answer)的可选参数Answer

Answer可以用于定义unstubbed invocations的返回值.

这个Answer接口对于legacy code非常有用. 当使用这个接口的时候, unstubbed methods会被实现.
这是一种通过调用默认方法来创建partial mock对象的方式。

通常，你将要阅读mock的部分警告：Object oriented programming is more less tackling complexity by dividing the complexity into separate, specific, , SRPy objects.
partial mock是如果适应这种模式的呢？好吧！它不仅仅是，partial mock通常意味着复杂性在同一个对象中移动到不同的方法.在大多数情况下，这不是你想要的设计你的应用的方式。

然而，当partial mocks派上用场同样也有少许情况:处理你不易改变的代码（第三方接口，legacy code的临时重构）.我将不使用partial mocks用于新的、测试驱动以及设计不错的代码。


例如：

Foo mock = mock(Foo.class, CALLS_REAL_METHODS);

// this calls the real implementation of Foo.getSomething()
value = mock.getSomething();

when(mock.getSomething()).thenReturn(fakeValue);

// now fakeValue is returned
value = mock.getSomething();

方法摘要

Modifier and Type Method and Description
static VerificationAfterDelay after(long millis)
给定的时间后进行验证
static VerificationMode atLeast(int minNumberOfInvocations)
至少进行minNumberOfInvocations次验证
static VerificationMode atLeastOnce()
至少进行一次验证
static VerificationMode atMost(int maxNumberOfInvocations)
最多进行maxNumberOfInvocations次验证
static VerificationMode calls(int wantedNumberOfInvocations)
允许顺序进行non-greedy验证

方法详情

after

  public static VerificationAfterDelay after(long millis)

在给定的时间后进行验证。它会为了预期的效果进行等待一段时间后进行验证，而不是因为没发生而立即失败。这可能对于测试多并发条件非常有用。

after()等待整个周期的特点不同于timeout()，而timeout()一旦验证通过就尽快停止，例如：当使用times(2)可以产生不同的行为方式，可能通过后过会又失败。这种情况下，timeout只要times(2)通过就会通过，然后after执行完整个周期时间，可能会失败，也意味着times(2)也失败。

感觉这个方法应该少使用——找到更好的方法测试你的多线程系统。

对尚未实现的工作进行验证。


  //passes after 100ms, if someMethod() has only been called once at that time.

  verify(mock, after(100)).someMethod();<br>
  //above is an alias to:

  verify(mock, after(100).times(1)).someMethod();

  //passes if someMethod() is called *exactly* 2 times after the given timespan
  verify(mock, after(100).times(2)).someMethod();

  //passes if someMethod() has not been called after the given timespan

  verify(mock, after(100).never()).someMethod();

  //verifies someMethod() after a given time span using given verification mode
  //useful only if you have your own custom verification modes.
  verify(mock, new After(100, yourOwnVerificationMode)).someMethod();

参照Mockito类的javadoc帮助文档中的例子

Parameters:

  • millis - - time span in milliseconds

Returns:

  • verification mode

atLeast

  public static VerificationMode atLeast(int minNumberOfInvocations)

允许至少进行x次验证。例如：

  verify(mock, atLeast(3)).someMethod("some arg");

参照Mockito类的javadoc帮助文档中的例子

Parameters:

  • minNumberOfInvocations - invocations的最小次数

Returns:

  • verification mode

atLeastOnce

  public static VerificationMode atLeastOnce()

至少进行一次一次验证。例如:

  verify(mock, atLeastOnce()).someMethod("some arg");

atLeast(1)的别名.
参照Mockito类的javadoc帮助文档中的例子

Returns:

  • verification mode

atMost

  public static VerificationMode atMost(int maxNumberOfInvocations)

至多进行x次验证. 例如:

  verify(mock, atMost(3)).someMethod("some arg");

参照Mockito类的javadoc帮助文档中的例子

Parameters::

  • maxNumberOfInvocations - invocations的最大次数

Returns:

  • verification mode

calls

  public static VerificationMode calls(int wantedNumberOfInvocations)

允许顺序进行non-greedy验证. 例如:

  inOrder.verify( mock, calls( 2 )).someMethod( "some arg" );
  • 如果这个方法调用3次不会失败，不同于times(2)
  • 不会标记第三次验证，不同于atLeast(2)
这个verification mode只能用于顺序验证.

Parameters::

  • wantedNumberOfInvocations - 验证的次数

Returns:

  • verification mode

继承org.mockito.Matchers的方法

any

  public static <T> T any()<br><br>

匹配任何值，包括null

anyObject()的别名

参照Matchers类的javadoc帮助文档中的例子

这是: anyObject() and any(java.lang.Class)的别名

Returns:

  • null

any

  public static <T> T any(Class<T> clazz)

匹配任何对象，包括null

这个方法不进行给定参数的类型检查，它就是为了避免代码中的强制转换(Casting)。然而这可能会改变（类型检查可以添加）将来的主要版本。

参照Matchers类的javadoc帮助文档中的例子

这是: anyObject() and any(java.lang.Class)的别名

Returns:

  • null

anyBoolean

  public static boolean anyBoolean()

任何boolean类型或非空(non-null)的Boolean.

参照Matchers类的javadoc帮助文档中的例子

Returns:

  • false

anyByte

  public static byte anyByte()

任何byte类型变量或非空(non-null)Byte.

参照Matchers类的javadoc帮助文档中的例子

Returns:

  • 0

anyChar

  public static char anyChar()

任何char类型变量或非空(non-null)的Character.

参照Matchers类的javadoc帮助文档中的例子

Returns:

  • 0

anyCollection

public static Collection anyCollection()

任何非空(non-null)的Collection.

参照Matchers类的javadoc帮助文档中的例子

Returns:

  • 空Collection.

anyCollectionOf

public static < T > Collection < T > anyCollectionOf(Class<T> clazz)

通用友好的别名anyCollection()。为了保持代码清洁，通过@SuppressWarnings(“unchecked”)来进行替代编译器警告。

任何非空(non-null)Collection.

这个方法不进行给定参数的类型检查，它就是为了避免代码中的强制转换(Casting)。然而这可能会改变（类型检查可以添加）将来的主要版本。

参照Matchers类的javadoc帮助文档中的例子

Parameters

  • clazz - 类型属于Collection类型避免类型转换(Casting)

Returns:

  • 空Collection.

anyDouble

  public static double anyDouble()

任何double类型或非空(non-null)的Double.

参照Matchers类的javadoc帮助文档中的例子

Returns:

anyFloat

  public static float anyFloat()

任何float类型或非空(non-null)Float.

参照Matchers类的javadoc帮助文档中的例子

Returns:

anyInt

  public static int anyInt()

任何int或非空(non-null)Integer.

参照Matchers类的javadoc帮助文档中的例子

Returns:

anyList

public static List anyList()

任何非空(non-null)List.

参照Matchers类的javadoc帮助文档中的例子

Returns:

  • 空List.

anyListOf

public static < T >  List < T > anyListOf(Class< T > clazz)

通用友好的别名anyList()。为了保持代码清洁，通过@SuppressWarnings(“unchecked”)来进行替代编译器警告。

任何非空(non-null)List.

这个方法不进行给定参数的类型检查，它就是为了避免代码中的强制转换(Casting)。然而这可能会改变（类型检查可以添加）将来的主要版本。

参照Matchers类的javadoc帮助文档中的例子

Parameters:

  • clazz - 类型属于List类型避免类型转换(Casting)

Returns:

  • 空List.

anyLong

  public static long anyLong()

任何long类型或非空(non-null)Long.

参照Matchers类的javadoc帮助文档中的例子

Returns:

anyMap

public static Map anyMap()

任何非空(non-null)Map.

参照Matchers类的javadoc帮助文档中的例子

Returns:

  • 空Map.

anyMapOf

public static < K,V> Map < K,V> anyMapOf(Class< K> keyClazz, Class< V> valueClazz)

通用友好的别名anyMap()。为了保持代码清洁，通过@SuppressWarnings(“unchecked”)来进行替代编译器警告。

任何非空(non-null)Map.

这个方法不进行给定参数的类型检查，它就是为了避免代码中的强制转换(Casting)。然而这可能会改变（类型检查可以添加）将来的主要版本。

参照Matchers类的javadoc帮助文档中的例子

Parameters:

  • keyClazz - map key类型避免类型强制转换(Casting)
  • valueClazz - value类型避免类型强制转换(Casting)

Returns:

  • 空Map.

anyObject

public static < T> T anyObject()

匹配任何事物, 包含null.

这是: any()和any(java.lang.Class)的别名

参照Matchers类的javadoc帮助文档中的例子

Returns:

  • empty null.

anySet**

public static <a href="http://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true">Set</a> anySet()

任何非空(non-null)Set.

参照Matchers类的javadoc帮助文档中的例子

Returns:

  • 空Set.

anySetOf

public static < T> Set < T> anySetOf(Class< T> clazz)

通用友好的别名anySet()。为了保持代码清洁，通过@SuppressWarnings(“unchecked”)来进行替代编译器警告。

任何非空(non-null)Set.

这个方法不进行给定参数的类型检查，它就是为了避免代码中的强制转换(Casting)。然而这可能会改变（类型检查可以添加）将来的主要版本。

参照Matchers类的javadoc帮助文档中的例子

Parameters:

  • clazz - 类型属于Set为了避免类型强制转换(Casting)

Returns:

  • 空Set.

anyShort

  public static short anyShort()

任何short类型或非空(non-null)Short.

参照Matchers类的javadoc帮助文档中的例子

Returns:

anyString

  public static String anyString()

任何非空(non-null)String

参照Matchers类的javadoc帮助文档中的例子

Returns:

  • 空String (“”).

anyVararg

  public static < T> T anyVararg()

任何vararg类型, 即任何参数(arguments)的number和values

例如:


  //verification:
  mock.foo(1, 2);
  mock.foo(1, 2, 3, 4);
  verify(mock, times(2)).foo(anyVararg());

  //stubbing:
  when(mock.foo(anyVararg()).thenReturn(100);

  //prints 100
  System.out.println(mock.foo(1, 2));
  //also prints 100<
  System.out.println(mock.foo(1, 2, 3, 4));

参照Matchers类的javadoc帮助文档中的例子

Returns:

  • null.

argThat

public static < T> T argThat(ArgumentMatcher < T> matcher)

允许创建自定义的参数匹配模式.这个API在2.0中已经改变,请阅读ArgumentMatcher基础指南。

在实现自定义参数匹配模式前，理解使用的场景和non-trivial参数的可用选项是非常重要的。这种方式下，你可以在给定的情况下选择最好的方法来设计制造高质量的测试(清洁和维护).请阅读ArgumentMatcher文档学习方法和例子。

在极少数情况下，当参数是基本数据类型(primitive)时，你必须使用相关的intThat()、floatThat()等方法。这些方法在进行自动拆箱(auto-unboxing)时可以避免NullPointerException异常。

参照ArgumentMatcher类的javadoc帮助文档中的例子

Parameters:

  • matcher - 取决于选择的参数匹配模式(argument matches)

Returns:

  • null.

booleanThat

public static boolean booleanThat(ArgumentMatcher < Boolean> matcher)

允许创建自定义的Boolean类型参数匹配模式(Boolean argument matchers).

参照Matchers类的javadoc帮助文档中的例子

Parameters:

  • matcher - 取决于选择的参数匹配模式(argument matches)
    Returns:

  • false.

byteThat

public static byte byteThat(ArgumentMatcher < Byte> matcher)

允许创建自定义的Byte类型参数匹配模式(Byte argument matchers)

参照Matchers类的javadoc帮助文档中的例子

Parameters:

  • matcher - 取决于选择的参数匹配模式(argument matches)

Returns:

charThat

public static char charThat(ArgumentMatcher < Character> matcher)

允许创建自定义的Character类型参数匹配模式(Character argument matchers)

参照Matchers类的javadoc帮助文档中的例子

Parameters:

  • matcher - 取决于选择的参数匹配模式(argument matches)

Returns:

contains

  public static String contains(String substring)

String参数包含给定的substring字符串.

参照Matchers类的javadoc帮助文档中的例子

Parameters:

  • substring - substring字符串.

Returns:

  • 空String (“”).

description函数

public static VerificationMod description(String description)

添加验证失败时要输出的文字内容


verify(mock, description("This will print on failure")).someMethod("some arg");

Parameters:

输出的文字内容

Returns:

验证模式

Since:

  • 2.0.0

doAnswer函数

public static Stubber doAnswer(Answer answer)

当你想要测试一个无返回值的函数时，可以使用一个含有泛型类Answer参数的doAnswer()函数。为无返回值的函数做测试桩与when(Objecy)方法不同，因为编译器不喜欢在大括号内使用void函数。


doAnswer(new Answer() {
      public Object answer(InvocationOnMock invocation) {
          Object[] args = invocation.getArguments();
          Mock mock = invocation.getMock();
          return null;
      }})
  .when(mock).someMethod();

参照Mockito类的javadoc帮助文档中的例子

Parameters:

测试函数的应答内容

Returns:

测试方法的测试桩

doCallRealMethod函数

public static Stubber doCallRealMethod()

如果你想调用某一个方法的真实实现请使用doCallRealMethod()。

像往常一样你需要阅读局部的mock对象警告:面向对象编程通过将复杂的事物分解成单独的、具体的、SRPY对象来减少对复杂事件的处理。
局部模拟是如何符合这种范式的呢。？局部模拟通常情况下是指在对象相同的情况下那些复杂的事物被移动另一个不同的方法中。在大多数情况下，并没有按照你所希望的方式来设计你的应用。

然而，使用局部mock对象也会有个别情况:有些代码你并不能非常容易的改变(3rd接口,临时遗留代码的重构等)，但是我对于新的、测试驱动及良好设计的代码不会使用局部mock对象。

同样在javadoc中spy(Object)阅读更多关于partial mocks的说明.推荐使用Mockito.spy()来创建局部mock对象原因是由于你负责构建对象并传值到spy()中，它只管保证被调用。


Foo mock = mock(Foo.class);
   doCallRealMethod().when(mock).someVoidMethod();

   // this will call the real implementation of Foo.someVoidMethod()
   // 调用Foo.someVoidMethod()的真实现
   mock.someVoidMethod();

参照Mockito类的javadoc帮助文档中的例子

Returns:

测试方法的测试桩

Since:

  • 1.9.5

doNothing函数

public static Stubber doNothing()

使用doNothing()函数是为了设置void函数什么也不做。需要注意的是默认情况下返回值为void的函数在mocks中是什么也不做的但是，也会有一些特殊情况。

1.测试桩连续调用一个void函数


doNothing().
   doThrow(new RuntimeException())
   .when(mock).someVoidMethod();

   //does nothing the first time:
   //第一次才能都没做
   mock.someVoidMethod();

   //throws RuntimeException the next time:
   //一下次抛出RuntimeException
   mock.someVoidMethod();

2.当你监控真实的对象并且你想让void函数什么也不做：


List list = new LinkedList();
   List spy = spy(list);

   //let's make clear() do nothing
   doNothing().when(spy).clear();

   spy.add("one");

   //clear() does nothing, so the list still contains "one"
   spy.clear();

参照Mockito类的javadoc帮助文档中的例子

Returns:

stubber - 测试方法的测试桩

doReturn函数

public static Stubber doReturn(Object toBeReturned)

在某些特殊情况下如果你无法使用when(Object)可以使用doReturn()函数

注意：对于测试桩推荐使用when(Object)函数，因为它是类型安全的并且可读性更强(特别是在测试桩连续调用的情况下)

都有哪些特殊情况下需要使用doReturn()

1.当监控真实的对象并且调用真实的函数带来的影响时：

List list = new LinkedList();
   List spy = spy(list);

   //Impossible: real method is called so spy.get(0) throws IndexOutOfBoundsException (the list is yet empty)
   
   // 不能完成的：真实方法被调用所以spy.get(0)抛出IndexOutOfBoundsException(list仍是空的)
   when(spy.get(0)).thenReturn("foo");

   //You have to use doReturn() for stubbing:
   //你应用使用doReturn()函数
   doReturn("foo").when(spy).get(0);
  1. 重写一个前exception-stubbing：

when(mock.foo()).thenThrow(new RuntimeException());

   //Impossible: the exception-stubbed foo() method is called so RuntimeException is thrown.
    // 不能完成的：exception-stubbed foo()被调用抛出RuntimeException异常
   when(mock.foo()).thenReturn("bar");

   //You have to use doReturn() for stubbing:
   //你应用使用doReturn()函数
   doReturn("bar").when(mock).foo();

上面的情况展示了Mockito’s的优雅语法。注意这些情况并不常见。监控应该是分散的并且重写exception-stubbing也不常见。更何况对于指出测试桩并复写测试桩是一种潜在的代码嗅觉

参照Mockito类的javadoc帮助文档中的例子

Parameters:

toBeReturned - 当测试桩函数被调用时要被返回的对象

Returns:

stubber - 测试方法的测试桩

doThrow函数

public static Stubber doThrow(Class toBeThrown)

当你想测试void函数中指定类的抛出异常时使用doThrow()

当每一个函数被调用时一个新的异常实例将会被创建

为无返回值的函数做测试桩与when(Objecy)方法不同，因为编译器不喜欢在大括号内使用void函数。

doThrow(RuntimeException.class).when(mock).someVoidMethod();

Parameters:

测试方法被调用时返回的对象

Returns:

测试方法的测试桩

Since:

  • 1.9.0

doThrow函数

public static Stubber doThrow(Throwable toBeThrown)

当测试一个void函数的异常时使用doThrow()

测试void函数需要与使用when(Object)不同的方式，因为编译器不喜欢大括号内有void函数

Example:

doThrow(RuntimeException.class).when(mock).someVoidMethod();

Parameters:

测试方法被调用时返回的对象

Returns:

测试方法的测试桩

Since:

  • 1.9.0

ignoreStubs函数

public static Object[] ignoreStubs(Object... mocks)

忽略对验证函数的测试，当与verifyNoMoreInteractions()成对出现或是验证inOrder()时是很有用的。避免了在测试时的多余验证，实际上我们对验证测试一点也不感兴趣。

警告,ignoreStubs()可能会导致verifyNoMoreInteractions(ignoreStubs(...))的过度使用。考虑到Mockito并不推荐使用verifyNoMoreInteractions()函数轰炸每一个测试，这其中的原由在文档verifyNoMoreInteractions(Object…)部分已经说明：换句话说在mocks中所有* stubbed * 的函数都被标记为 * verified * 所以不需要使用这种方式。

该方法改变了input mocks！该方法只是为了方便返回 imput mocks 。

忽略测试也会被忽略掉验证inOrder,包括InOrder.verifyNoMoreInteractions()，看下面第二个示例：

Example:

//mocking lists for the sake of the example (if you mock List in real you will burn in hell)
  List mock1 = mock(List.class), mock2 = mock(List.class);

  //stubbing mocks:
  when(mock1.get(0)).thenReturn(10);
  when(mock2.get(0)).thenReturn(20);

  //using mocks by calling stubbed get(0) methods:
  
  // 调用stubbed get(0)使用mocks
  System.out.println(mock1.get(0)); //prints 10
  System.out.println(mock2.get(0)); //prints 20

  //using mocks by calling clear() methods:
  // 调用clear()使用mocks
  mock1.clear();
  mock2.clear();

  //verification:
  
  // 验证
  verify(mock1).clear();
  verify(mock2).clear();

  //verifyNoMoreInteractions() fails because get() methods were not accounted for.
  
  // verifyNoMoreInteractions()会失败，因为get()未关联账号
  
  try { verifyNoMoreInteractions(mock1, mock2); } catch (NoInteractionsWanted e);

  //However, if we ignore stubbed methods then we can verifyNoMoreInteractions()
  //如要我们忽略测试函数我可以这样verifyNoMoreInteractions()
  
  verifyNoMoreInteractions(ignoreStubs(mock1, mock2));

  //Remember that ignoreStubs() *changes* the input mocks and returns them for convenience.

忽略测试可以用于verification in order:

List list = mock(List.class);
  when(mock.get(0)).thenReturn("foo");

  list.add(0);
  System.out.println(list.get(0)); //we don't want to verify this
  list.clear();

  InOrder inOrder = inOrder(ignoreStubs(list));
  inOrder.verify(list).add(0);
  inOrder.verify(list).clear();
  inOrder.verifyNoMoreInteractions();

Parameters:

将被改变的input mocks

Returns:

和传入参数一样的mocks

Since:

1.9.0

inOrder函数

public static InOrder inOrder(Object... mocks)

创建InOrder对象验证 mocks in order

InOrder inOrder = inOrder(firstMock, secondMock);

inOrder.verify(firstMock).add("was called first");
inOrder.verify(secondMock).add("was called second");

验证in order是很灵活的。你可以只验证你感兴趣的，并不需要一个一个验证所有的交互。同样你也可以创建InOrder对象只在相关in-order的验证中进行传值。

InOrder 验证是’greedy’.你很难每一个都注意到。你可以在Mockito wiki pages页搜索’greedy’获取更多信息。

Mockito 1.8.4版本你能以order-sensitive方式调用verifyNoMoreInvocations()，阅读更多InOrder.verifyNoMoreInteractions()

参照Mockito类的javadoc帮助文档中的例子

Parameters:

in order中被修改的mocks

Returns:

in order中被用于验证的InOrder对象

mock函数

public static T mock(Class classToMock)

对给定的类或接口创建mock对象

Parameters:

需要mock的类或接口

Returns:

mock对象

mock函数

public static T mock(Class classToMock, Answer defaultAnswer)

根据它对交互的回应指明策略创建mock对象。这个是比较高级特性并且你不需要它写多少测试代码。但是对于legacy系统这是非常有用的。

这个是默认answer，所以当你不想测试函数时你可以使用它。


Foo mock = mock(Foo.class, RETURNS_SMART_NULLS);
Foo mockTwo = mock(Foo.class, new YourOwnAnswer());

参照Mockito类的javadoc帮助文档中的例子

Parameters:

  • 需要mock的类或接口

  • 未测试函数的默认answer

Returns:

mock对象

mock函数

public static T mock(Class classToMock, MockSettings mockSettings)

没有标准的设置来创建mock对象

配置点的数目对mock的扩大有影响，所以我们在没有越来越多重载Mockito.mock()的情况下需要一种更流利的方式来介绍一种新的配置方式。即MockSettings.


Listener mock = mock(Listener.class, withSettings()
     .name("firstListner").defaultBehavior(RETURNS_SMART_NULLS));
   );

使用它时需要小心一些并且不要常用。在什么情况下你的测试会不需要标准配置的mocks?在测试代码下太复杂以至于不需要标准配置的mocks?你有没有重构测试代码来让它更加容易测试？

也可以参考withSettings()

参照Mockito类的javadoc帮助文档中的例子

Parameters:

  • 需要mock的类或接口
  • mock配置

Returns:

  • mock对象

mock

@Deprecated

@已过期

public static T mock(Class classToMock, ReturnValues returnValues)

已过期，请使用mock(Foo.class, defaultAnswer);

已过期，请使用mock(Foo.class, defaultAnswer);

见mock(Class, Answer)

为什么会过期？为了框架更好的一致性与交互性用Answer替换了ReturnValues。Answer接口很早就存在框架中了并且它有和ReturnValues一样的责任。没有必要维护两个一样的接口。

针对它的返回值需要指明策略来创建mock对象。这个是比较高级特性并且你不需要它写多少测试代码。但是对于legacy系统这是非常有用的。

明显地，当你不需要测试方法时可以使用这个返回值。

Foo mock = mock(Foo.class, Mockito.RETURNS_SMART_NULLS);
Foo mockTwo = mock(Foo.class, new YourOwnReturnValues());

参照Mockito类的javadoc帮助文档中的例子

Parameters:

  • 需要mock的类或接口
  • 未测试方法默认返回值

Returns:

  • mock对象

mock

public static T mock(Class classToMock, String name)

指明mock的名字。命名mock在debug的时候非常有用。名字会在所有验证错误中使用。需要注意的是对于使用太多mock或者collaborators的复杂代码命名mock并不能解决问题。如果你使用了太多的mock，为了更加容易测试/调试 你需要对其进行重构而不是对mock命名。

如果你使用了@Mock注解，意味着你的mock已经有名字了！

@Mock使用字段名称作为mock名字Read more

参照Mockito类的javadoc帮助文档中的例子

Parameters:

  • 需要mock的类或接口
  • mock的名字

Returns:

  • mock对象

mockingDetails函数

public static MockingDetails mockingDetails(Object toInspect)

对于Mockito的关联信息返回MockingDetails实例可以用于检查某一特定的对象，无论给定的对象是mock还是监视的都可以被找出来。

在Mockito以后的版本中MockingDetails可能会扩大并且提供其它有用的有关mock的信息。e.g. invocations, stubbing info, etc.

Parameters:

  • 要检查的对象。允许为空

Returns:

MockingDetails实例

Since:

  • 1.9.5

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CZ3x1fyB-1678931610814)(null)]

n-w开头的函数

never()函数

public static VerificationMode never()

相当于times(0),可参见 times(int)
验证交互没有发生. 例如:

verify(mock, never()).someMethod();

如果你想验证mock之间没有交互，可以使用verifyZeroInteractions(Object...) 或者 verifyNoMoreInteractions(Object...) 这两个方法

具体例子可以参考Javadoc中的Mockito类

Returns:

  • 验证模式

only()函数

public static VerificationMode only()

如果当前mock的方法只被调用一次，则允许被检验。例如：


   verify(mock, only()).someMethod();
   //上面这行代码是下面这两行代码的简写
   
   verify(mock).someMethod();
   verifyNoMoreInvocations(mock);

可以参考verifyNoMoreInteractions(Object...)方法

具体例子可以参考Javadoc中的Mockito类

Returns:

  • verification mode

reset(T… mocks)函数

public static void reset(T... mocks)

聪明的程序员很少会使用这个方法，因为他们知道使用这个方法意味着这个测试写的很low.通常情况下，你不需要重置你的mocks,你仅仅需要为你的测试方法创建新的mocks就可以了。

你可以考虑写一些简单的、精悍的、聚焦的测试方法来代替reset()这个方法。当你在在测试方法的中间部分用到reset()这个方法时，说明你的测试方法太庞大了。

请遵循以下关于测试方法的建议：请保证你的测试方法在一个动作中短小、精悍、聚焦。在mockito的邮件列表中有很多关于这方面的主题讨论。

我们添加reset()方法的唯一原因是使得注入容器的mocks得以有效的运行，具体可以参看issue 55 here or FAQ here

不要败坏了你在程序员界的名声，测试方法中间的reset()方法是代码中的害群之马（这意味着你的这个测试方法太多）

   List mock = mock(List.class);
   when(mock.size()).thenReturn(10);
   mock.add(1);

   reset(mock);
   //此时会清除你之前所有的交互以及测试桩

Type Parameters:

  • T - mocks的类型

Parameters:

  • 被重置的mocks

spy(Class classToSpy)函数

@Incubating public static T spy(Class classToSpy)

请参考关于类spy的文档，过渡使用spy会导致代码变的非常糟糕。

相比与原来的spy（对象），这种方法可以在类的基础上创建一个spy，而不是一个对象。有时你可以很方便基于类创建spy而避免提供一个spy对象的实例。

因为他们不能被实例化，所以这个对于抽象类的监控非常有用。参见mocksettings.useconstructor()。

例如：


   SomeAbstract spy = spy(SomeAbstract.class);

   //Robust API, via settings builder:
   //稳定的API，充过builder方式来设置
   
   OtherAbstract spy = mock(OtherAbstract.class, withSettings()
      .useConstructor().defaultAnswer(CALLS_REAL_METHODS));

   //Mocking a non-static inner abstract class:
   //模拟一个非静态抽象内部类
   
   InnerAbstract spy = mock(InnerAbstract.class, withSettings()
      .useConstructor().outerInstance(outerInstance).defaultAnswer(CALLS_REAL_METHODS));

Type Parameters:

  • T - spy的类型

Parameters:

  • spy的类

Returns:

  • a spy of the provided class

Since:

  • 1.10.12

stub(T methodCall)函数

public static DeprecatedOngoingStubbing stub(T methodCall)

对一个方法打桩会返回结果值或者错误异常，例如：


 stub(mock.someMethod()).toReturn(10);

 //you can use flexible argument matchers, e.g:
 //你可以使用灵活的参数匹配，例如：
 
 stub(mock.someMethod(anyString())).toReturn(10);

 //setting exception to be thrown:
 //设置抛出的异常
 
 stub(mock.someMethod("some arg")).toThrow(new RuntimeException());

 //you can stub with different behavior for consecutive method calls.
 // 你可以对不同作用的连续回调的方法打测试桩：
 //Last stubbing (e.g: toReturn("foo")) determines the behavior for further consecutive calls.
 // 最后面的测试桩（例如：返回一个对象："foo"）决定了接下来的回调方法以及它的行为。
 
 stub(mock.someMethod("some arg"))
  .toThrow(new RuntimeException())
  .toReturn("foo");

一些用户有点混乱、混淆，是因为相比于’stub()'，'when(Object)'更加被推荐

   //Instead of:
   //替代为：
   stub(mock.count()).toReturn(10);

  //你可以这样做：
   //You can do:
   when(mock.count()).thenReturn(10);

当对一个返回值为空且抛出异常的方法打测试桩：doThrow(Throwable)测试桩会被重写：例如通常测试桩会设置为常用固定设置，但测试方法可以重写它。切记重写测试桩是一种非常不推荐的写法，因为这样做会导致非常多的测试桩。

一旦这个方法打过桩，无论这个方法被调用多少次，这个方法会一直返回这个测试桩的值。

当你对相同的方法调用相同的参数打测试桩很多次，最后面的测试桩则非常重要

尽管我们可以去验证对测试桩的调用，但通常它都是多余的。比如说你对foo.bar()打测试桩。如果你比较关心的是当某些情况foo.bar()中断了（经常在verify()方法执行之前）,此时会返回什么。如果你的代码不关心是get(0)会返回什么那么它就不应该被添加测试桩。如果你还不确定？看这里

Parameters:

  • methodCall - 调用的方法

Returns:

  • DeprecatedOngoingStubbing 对象是用来设置测试桩的值或者异常的

stubVoid(T mock)函数

public static VoidMethodStubbable stubVoid(T mock)

已废弃.使用doThrow(Throwable)方法代替去打空测试桩

  //Instead of:
  //替代为：
   stubVoid(mock).toThrow(e).on().someVoidMethod();

   //Please do:
   //请这样做：
   doThrow(e).when(mock).someVoidMethod();

doThrow()之所以取代了stubVoid()方法，是因为它增加了和它的兄弟方法doAnswer()的可读性以及一致性


 stubVoid(mock).toThrow(new RuntimeException()).on().someMethod();

 //you can stub with different behavior for consecutive calls.
 //你可以对不同作用的连续回调的方法打测试桩：
 //Last stubbing (e.g. toReturn()) determines the behavior for further consecutive calls.
 //最后面的测试桩（例如：`toReturn()`）决定了接下来的回调方法以及它的行为。
 
 stubVoid(mock)
   .toThrow(new RuntimeException())
   .toReturn()
   .on().someMethod();

具体例子可以参考Javadoc中的Mockito类

Parameters:

  • mock - to stub

Returns:

  • stubbable object that allows stubbing with throwable

timesout(long millis)函数

public static VerificationWithTimeout timeout(long millis)

允许验证时使用timeout。它会在指定的时间后触发你所期望的动作，而不是立即失败，也许这个对并发条件下的测试非常有用。它和after()是有所有不同的，因为after()会等候一个完整的时期，除非最终的测试结果很快就出来了(例如：当never()失败了), 然而当验证通过时，timeout()会快速地停止，当你使用times(2)时会产生不同的行为。例如，当先通过然后失败，在这种情况下，timeout将会当time(2)通过时迅速通过，然而after()将会一直运行直到times(2)失败，然后它也一同失败。

这个功能看起来应该极少使用，但在多线程的系统的测试中，这是一个很好的方式

目前尚未实现按照顺序去验证


   //passes when someMethod() is called within given time span
   //当`someMethod()`被以时间段的形式调用时通过
    
   verify(mock, timeout(100)).someMethod();
   //above is an alias to:
   // 上面的是一个别名
   
   verify(mock, timeout(100).times(1)).someMethod();

   //passes as soon as someMethod() has been called 2 times before the given timeout
   // 在超时之前，`someMethod()`通过了2次调用
   verify(mock, timeout(100).times(2)).someMethod();

   //equivalent: this also passes as soon as someMethod() has been called 2 times before the given timeout
   //这个和上面的写法是等价的，也是在超时之前，`someMethod()`通过了2次调用
   verify(mock, timeout(100).atLeast(2)).someMethod();

   //verifies someMethod() within given time span using given verification mode
   //在一个超时时间段内，用自定义的验证模式去验证`someMethod()`方法
   //useful only if you have your own custom verification modes.
   //只有在你有自己定制的验证模式时才有用
   
   verify(mock, new Timeout(100, yourOwnVerificationMode)).someMethod();

具体例子可以参考Javadoc中的Mockito类

Parameters:

  • millis - - 时间长度（单位：毫秒）

Returns:

  • 验证模式

time(int wantedNumberOfInvocations)函数

public static VerificationMode times(int wantedNumberOfInvocations)

允许验证调用方法的精确次数，例如：

verify(mock, times(2)).someMethod("some arg");
//连续调用该方法两次

具体例子可以参考Javadoc中的Mockito类

Parameters:

  • wantedNumberOfInvocations - 希望调用的次数

Returns:

  • 验证模式

validateMockitoUsage()函数

public static void validateMockitoUsage()

首页，无论遇到任何问题，我都鼓励你去阅读the Mockito问答集：http://groups.google.com/group/mockito,你也可以在mockito 邮件列表提问http://groups.google.com/group/mockito.

validateMockitoUsage()会明确地检验framework的状态以用来检查Mockito是否有效使用。但是，这个功能是可选的，因为**'Mockito`会使这个用法一直有效**，不过有一个问题请继续读下去。

错误示例:

 //Oops, thenReturn() part is missing:
 //当心，`thenReturn()`部分是缺失的
 
 when(mock.get());

 //Oops, verified method call is inside verify() where it should be on the outside:
 //当心，下面验证方法的调用在`verify()`里面，其实应该在外面
 
 verify(mock.execute());

 //Oops, missing method to verify:
 //当心，验证缺失方法
 
 verify(mock);

如果你错误的使用了Mockito，这样将会抛出异常，这样你就会知道你的测试是否写的正确。你要清楚当你使用这个框架时，Mockito会接下来的所有时刻开始验证（例如：下一次你验证、打测试桩、调用mock等）。尽管在下一次测试中可能会抛出异常，但这个异常消息包含了一个完整栈踪迹路径以及这个错误的位置。此时你可以点击并找到这个Mockito使用错误的地方。

有时，你可能想知道这个框架的使用方法。比如，一个用户想将validateMockitoUsage()放在它的@after方法中，为了能快速地知道它使用Mockito时哪里错了。如果没有这个，它使用这个框架时将不能那么迅速地知道哪里使用错了。另外在@after中使用validateMockitoUsage()比较好的一点是jUnit runner以及Junit rule中的测试方法在有错误时也会失败，然而普通的next-time验证可能会在下一次测试方法中才失败。但是尽管Junit可能对下一次测试报告显示红色，但不要担心，这个异常消息包含了一个完整栈踪迹路径以及这个错误的位置。此时你可以点击并找到这个Mockito使用错误的地方。

同样在runner中：MockitoJUnitRunner and rule：MockitoRule在每次测试方法之后运行validateMockitoUsage()

一定要牢记通常你不需要’validateMockitoUsage()'和框架验证，因为基于next-time触发的应该已经足够，主要是因为可以点击出错位置查看强大的错误异常消息。但是，如果你已经有足够的测试基础（比如你为所有的测试写有自己的runner或者基类），我将会推荐你使用validateMockitoUsage()，因为对@After添加一个特别的功能时将是零成本。

具体例子可以参考Javadoc中的Mockito类

verify(T mock)函数

public static T verify(T mock)

验证发生的某些行为
等同于verify(mock, times(1)) 例如：

   verify(mock).someMethod("some arg");

上面的写法等同于：

   verify(mock, times(1)).someMethod("some arg");

参数比较是通过equals()方法。可参考ArgumentCaptor或者ArgumentMatcher中关于匹配以及断言参数的方法。

尽管我们可以去验证对测试桩的调用，但通常它都是多余的。比如说你对foo.bar()打测试桩。如果你比较关心的是当某些情况foo.bar()中断了（经常在verify()方法执行之前）,此时会返回什么。如果你的代码不关心是get(0)会返回什么那么它就不应该被添加测试桩。如果你还不确定？看这里

具体例子可以参考Javadoc中的Mockito类

Parameters:

  • mock - 要被验证的
    Returns:

  • mock本身

verifyNoMoreInteractions(Object… mocks)函数

public static void verifyNoMoreInteractions(Object... mocks)

检查入参的mocks是否有任何未经验证的交互,你可以在验证你的mocks之后使用这个方法，用以确保你的mocks没有其它地方会被调用.

测试柱的调用也被看成是交互。

**警告：**一些使用者，倾向于经常使用verifyNoMoreInteractions()方法做大量经典的、期望-运行-验证的模拟，甚至是在所有的测试方法中使用。verifyNoMoreInteractions()并不被推荐于使用在所有的测试方法中。在交互测试工具中，verifyNoMoreInteractions()是一个很方便的断言。你只能在当它是明确的、相关的时候使用它。滥用它将导致多余的指定、不可维护的测试。你可以在这里查找更多的文章。

这个方法会在测试方法运行之前检查未经验证的调用，例如：在setUp(),@Before方法或者构造函数中。考虑到要写出良好优秀的代码，交互只能够在测试方法中。

示例：

 //interactions
 //交互
 mock.doSomething();
 mock.doSomethingUnexpected();

 //verification
 //验证
 verify(mock).doSomething();

 //following will fail because 'doSomethingUnexpected()' is unexpected
 //因为'doSomethingUnexpected()'是未被期望的，所以下面将会失败
 verifyNoMoreInteractions(mock);

具体例子可以参考Javadoc中的Mockito类

Parameters:

  • mocks - 被验证的

verifyZeroInteractions(Object… mocks)函数

public static void verifyZeroInteractions(Object... mocks)

传进来的mocks之间没有任何交互。

   verifyZeroInteractions(mockOne, mockTwo);

这个方法会在测试方法运行之前检查调用，例如：在setUp(),@Before方法或者构造函数中。考虑到要写出良好的代码，交互只能够在测试方法中。

你也可以参考never()方法 - 这个方法很明确的表达了当前方法的用途.
具体例子可以参考Javadoc中的Mockito类

Parameters:

  • mocks - 被验证的

when(T methodCall)函数

public static OngoingStubbing when(T methodCall)

使测试桩方法生效。当你想让这个mock能调用特定的方法返回特定的值，那么你就可以使用它。
简而言之：当你调用x方法时会返回y。

when()是继承自已经废弃的方法stub(Object)

例如：

 when(mock.someMethod()).thenReturn(10);

 //you can use flexible argument matchers, e.g:
 //你可以使用灵活的参数匹配，例如 
 when(mock.someMethod(anyString())).thenReturn(10);

 //setting exception to be thrown:
 //设置抛出的异常
 when(mock.someMethod("some arg")).thenThrow(new RuntimeException());

 //you can set different behavior for consecutive method calls.
 //你可以对不同作用的连续回调的方法打测试桩：
 //Last stubbing (e.g: thenReturn("foo")) determines the behavior of further consecutive calls.
 //最后面的测试桩（例如：返回一个对象："foo"）决定了接下来的回调方法以及它的行为。
 
 when(mock.someMethod("some arg"))
  .thenThrow(new RuntimeException())
  .thenReturn("foo");

 //Alternative, shorter version for consecutive stubbing:
 //可以用以下方式替代，比较小版本的连贯测试桩：
 when(mock.someMethod("some arg"))
  .thenReturn("one", "two");
 //is the same as:
 //和下面的方式效果是一样的
 when(mock.someMethod("some arg"))
  .thenReturn("one")
  .thenReturn("two");

 //shorter version for consecutive method calls throwing exceptions:
 //比较小版本的连贯测试桩并且抛出异常：
 when(mock.someMethod("some arg"))
  .thenThrow(new RuntimeException(), new NullPointerException();

当你打空方法的测试桩，相关异常可参见：doThrow(Throwable),Stubbing可以被重写：比如：普通的测试桩可以使用固定的设置，但是测试方法能够重写它。切记重写测试桩是一种非常不推荐的写法，因为这样做会导致非常多的测试桩。

一旦这个方法打过桩，无论这个方法被调用多少次，这个方法会一直返回这个测试桩的值。

当你对相同的方法调用相同的参数打测试桩很多次，最后面的测试桩则非常重要

尽管我们可以去验证对测试桩的调用，但通常它都是多余的。比如说你对foo.bar()打测试桩。如果你比较关心的是当某些情况foo.bar()中断了（经常在verify()方法执行之前）,此时会返回什么。如果你的代码不关心是get(0)会返回什么那么它就不应该被添加测试桩。如果你还不确定？看这里

具体例子可以参考Javadoc中的Mockito类

Parameters:

  • methodCall - 调用的方法

Returns:

  • 通常是OngoingStubbing对象。不要为被返回的对象创建一个引用。

withSettings()函数

public static MockSettings withSettings()

可以在创建mock时添加设置。
不要经常去设置它。应该在使用简单的mocks时写简单的设置。跟着我重复：简单的测试会使整体的代码更简单，更可读、更可维护。如果你不能把测试写的很简单-那么请在测试时重构你的代码。

mock设置的例子

   //Creates mock with different default answer & name
   //用不同的默认结果和名字去创建`mock`
   
   Foo mock = mock(Foo.class, withSettings()
       .defaultAnswer(RETURNS_SMART_NULLS)
       .name("cool mockie"));

   //Creates mock with different default answer, descriptive name and extra interfaces
   用不同的默认结果和描述的名称以及额外的接口去创建`mock`
   Foo mock = mock(Foo.class, withSettings()
       .defaultAnswer(RETURNS_SMART_NULLS)
       .name("cool mockie")
       .extraInterfaces(Bar.class));

有两种原因推荐使用MockSettings.第一种，有需求要增加另外一种mock设置，这样用起来更方便。第二种，能够结合不同的moke设置以减少大量重载moke()方法。

具体可参考MockSettings文档来学习mock settins

Returns:

  • mock settings默认实例

你可能感兴趣的:(java,junit)

  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • Java 重写(Override)与重载(Overload) 叨唧唧的
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
  • Java企业面试题3 马龙强_ java
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
  • JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • 白骑士的Java教学基础篇 2.5 控制流语句 白骑士所长 Java教学java开发语言
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
  • python语法——三目运算符 HappyRocking pythonpython三目运算符
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • Java：爬虫框架 dingcho Javajava爬虫
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
  • python怎么将png转为tif_png转tif weixin_39977276
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy） 跳房子的前端 前端面试javascript开发语言ecmascript
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
  • JAVA·一个简单的登录窗口 MortalTom java开发语言学习
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
  • WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Javajava爬虫开发语言
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
  • 博客网站制作教程 2401_85194651 javamaven
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
  • 00. 这里整理了最全的爬虫框架（Java + Python） 有一只柴犬 爬虫系列爬虫javapython
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
  • JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式androidjava常用设计模式
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
  • JavaScript `Map` 和 `WeakMap`详细解释 跳房子的前端 JavaScript原生方法javascript前端开发语言
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
  • 切换淘宝最新npm镜像源是 hai40587 npm前端node.js
    切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
  • 【Java】已解决：java.util.concurrent.CompletionException 屿小夏 java开发语言
    文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
  • 设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】） ok!ko 设计模式设计模式建造者模式java
    文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
  • 关于旗正规则引擎中的MD5加密问题 何必如此 jspMD5规则加密
    一般情况下，为了防止个人隐私的泄露，我们都会对用户登录密码进行加密，使数据库相应字段保存的是加密后的字符串，而非原始密码。 在旗正规则引擎中，通过外部调用，可以实现MD5的加密，具体步骤如下： 1.在对象库中选择外部调用，选择“com.flagleader.util.MD5”，在子选项中选择“com.flagleader.util.MD5.getMD5ofStr({arg1})”； 2.在规
  • 【Spark101】Scala Promise/Future在Spark中的应用 bit1129 Promise
    Promise和Future是Scala用于异步调用并实现结果汇集的并发原语，Scala的Future同JUC里面的Future接口含义相同，Promise理解起来就有些绕。等有时间了再仔细的研究下Promise和Future的语义以及应用场景，具体参见Scala在线文档：http://docs.scala-lang.org/sips/completed/futures-promises.html
  • spark sql 访问hive数据的配置详解 daizj spark sqlhivethriftserver
    spark sql 能够通过thriftserver 访问hive数据，默认spark编译的版本是不支持访问hive，因为hive依赖比较多，因此打的包中不包含hive和thriftserver,因此需要自己下载源码进行编译，将hive，thriftserver打包进去才能够访问，详细配置步骤如下：   1、下载源码   2、下载Maven,并配置 此配置简单，就略过
  • HTTP 协议通信 周凡杨 javahttpclienthttp通信
                            一：简介  HTTPCLIENT，通过JAVA基于HTTP协议进行点与点间的通信！     二： 代码举例      测试类： import java
  • java unix时间戳转换 g21121 java
    把java时间戳转换成unix时间戳： Timestamp appointTime=Timestamp.valueOf(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())) SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:m
  • web报表工具FineReport常用函数的用法总结（报表函数） 老A不折腾 web报表finereport总结
    说明：本次总结中，凡是以tableName或viewName作为参数因子的。函数在调用的时候均按照先从私有数据源中查找，然后再从公有数据源中查找的顺序。   CLASS CLASS(object):返回object对象的所属的类。   CNMONEY CNMONEY(number,unit)返回人民币大写。 number:需要转换的数值型的数。 unit:单位，
  • java jni调用c++ 代码 报错 墙头上一根草 javaC++jni
    # # A fatal error has been detected by the Java Runtime Environment: # #  EXCEPTION_ACCESS_VIOLATION (0xc0000005) at pc=0x00000000777c3290, pid=5632, tid=6656 # # JRE version: Java(TM) SE Ru
  • Spring中事件处理de小技巧 aijuans springSpring 教程Spring 实例Spring 入门Spring3
    Spring 中提供一些Aware相关de接口，BeanFactoryAware、 ApplicationContextAware、ResourceLoaderAware、ServletContextAware等等，其中最常用到de匙ApplicationContextAware.实现ApplicationContextAwaredeBean，在Bean被初始后，将会被注入 Applicati
  • linux shell ls脚本样例 annan211 linuxlinux ls源码linux 源码
    #! /bin/sh - #查找输入文件的路径 #在查找路径下寻找一个或多个原始文件或文件模式 # 查找路径由特定的环境变量所定义 #标准输出所产生的结果 通常是查找路径下找到的每个文件的第一个实体的完整路径 # 或是filename :not found 的标准错误输出。 #如果文件没有找到 则退出码为0 #否则 即为找不到的文件个数 #语法 pathfind [--
  • List,Set,Map遍历方式 (收集的资源,值得看一下) 百合不是茶 listsetMap遍历方式
    List特点：元素有放入顺序，元素可重复 Map特点：元素按键值对存储，无放入顺序 Set特点：元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的） List接口有三个实现类：LinkedList，ArrayList，Vector LinkedList：底层基于链表实现，链表内存是散乱的，每一个元素存储本身
  • 解决SimpleDateFormat的线程不安全问题的方法 bijian1013 javathread线程安全
    在Java项目中，我们通常会自己写一个DateUtil类，处理日期和字符串的转换，如下所示： public class DateUtil01 { private SimpleDateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); public void format(Date d
  • http请求测试实例（采用fastjson解析） bijian1013 http测试
            在实际开发中，我们经常会去做http请求的开发，下面则是如何请求的单元测试小实例，仅供参考。 import java.util.HashMap; import java.util.Map; import org.apache.commons.httpclient.HttpClient; import
  • 【RPC框架Hessian三】Hessian 异常处理 bit1129 hessian
    RPC异常处理概述   RPC异常处理指是，当客户端调用远端的服务，如果服务执行过程中发生异常，这个异常能否序列到客户端？   如果服务在执行过程中可能发生异常，那么在服务接口的声明中，就该声明该接口可能抛出的异常。   在Hessian中，服务器端发生异常，可以将异常信息从服务器端序列化到客户端，因为Exception本身是实现了Serializable的
  • 【日志分析】日志分析工具 bit1129 日志分析
    1. 网站日志实时分析工具 GoAccess http://www.vpsee.com/2014/02/a-real-time-web-log-analyzer-goaccess/ 2. 通过日志监控并收集 Java 应用程序性能数据(Perf4J) http://www.ibm.com/developerworks/cn/java/j-lo-logforperf/ 3.log.io 和
  • nginx优化加强战斗力及遇到的坑解决 ronin47 nginx 优化
    　　　先说遇到个坑，第一个是负载问题，这个问题与架构有关，由于我设计架构多了两层，结果导致会话负载只转向一个。解决这样的问题思路有两个：一是改变负载策略，二是更改架构设计。 　　　由于采用动静分离部署，而nginx又设计了静态，结果客户端去读nginx静态，访问量上来，页面加载很慢。解决：二者留其一。最好是保留apache服务器。   　　　来以下优化：   　　　
  • java-50-输入两棵二叉树A和B，判断树B是不是A的子结构 bylijinnan java
    思路来自： http://zhedahht.blog.163.com/blog/static/25411174201011445550396/ import ljn.help.*; public class HasSubtree { /**Q50. * 输入两棵二叉树A和B，判断树B是不是A的子结构。 例如，下图中的两棵树A和B，由于A中有一部分子树的结构和B是一
  • mongoDB 备份与恢复 开窍的石头 mongDB备份与恢复
    Mongodb导出与导入 1: 导入/导出可以操作的是本地的mongodb服务器,也可以是远程的. 所以,都有如下通用选项: -h host   主机 --port port    端口 -u username 用户名 -p passwd   密码 2: mongoexport 导出json格式的文件
  • [网络与通讯]椭圆轨道计算的一些问题 comsci 网络
         如果按照中国古代农历的历法，现在应该是某个季节的开始，但是由于农历历法是3000年前的天文观测数据，如果按照现在的天文学记录来进行修正的话，这个季节已经过去一段时间了。。。。。       也就是说，还要再等3000年。才有机会了，太阳系的行星的椭圆轨道受到外来天体的干扰，轨道次序发生了变
  • 软件专利如何申请 cuiyadll 软件专利申请
    软件技术可以申请软件著作权以保护软件源代码，也可以申请发明专利以保护软件流程中的步骤执行方式。专利保护的是软件解决问题的思想，而软件著作权保护的是软件代码（即软件思想的表达形式）。例如，离线传送文件，那发明专利保护是如何实现离线传送文件。基于相同的软件思想，但实现离线传送的程序代码有千千万万种，每种代码都可以享有各自的软件著作权。申请一个软件发明专利的代理费大概需要5000-8000申请发明专利可
  • Android学习笔记 darrenzhu android
    1.启动一个AVD 2.命令行运行adb shell可连接到AVD,这也就是命令行客户端 3.如何启动一个程序   am start -n package name/.activityName   am start -n com.example.helloworld/.MainActivity 启动Android设置工具的命令如下所示： # am start -
  • apache虚拟机配置，本地多域名访问本地网站 dcj3sjt126com apache
    现在假定你有两个目录，一个存在于 /htdocs/a，另一个存在于 /htdocs/b 。 现在你想要在本地测试的时候访问 www.freeman.com 对应的目录是 /xampp/htdocs/freeman ,访问 www.duchengjiu.com 对应的目录是 /htdocs/duchengjiu。 1、首先修改C盘WINDOWS\system32\drivers\etc目录下的
  • yii2 restful web服务[速率限制] dcj3sjt126com PHPyii2
    速率限制 为防止滥用，你应该考虑增加速率限制到您的API。 例如，您可以限制每个用户的API的使用是在10分钟内最多100次的API调用。 如果一个用户同一个时间段内太多的请求被接收， 将返回响应状态代码 429 (这意味着过多的请求)。 要启用速率限制, [[yii\web\User::identityClass|user identity class]] 应该实现 [[yii\filter
  • Hadoop2.5.2安装——单机模式 eksliang hadoophadoop单机部署
    转载请出自出处：http://eksliang.iteye.com/blog/2185414 一、概述        Hadoop有三种模式 单机模式、伪分布模式和完全分布模式，这里先简单介绍单机模式 ，默认情况下，Hadoop被配置成一个非分布式模式，独立运行JAVA进程，适合开始做调试工作。   二、下载地址 Hadoop 网址http:
  • LoadMoreListView+SwipeRefreshLayout（分页下拉）基本结构 gundumw100 android
    一切为了快速迭代 import java.util.ArrayList; import org.json.JSONObject; import android.animation.ObjectAnimator; import android.os.Bundle; import android.support.v4.widget.SwipeRefreshLayo
  • 三道简单的前端HTML/CSS题目 ini htmlWeb前端css题目
    使用CSS为多个网页进行相同风格的布局和外观设置时，为了方便对这些网页进行修改，最好使用（ ）。http://hovertree.com/shortanswer/bjae/7bd72acca3206862.htm   在HTML中加入<table style=”color:red; font-size:10pt”>，此为（ ）。http://hovertree.com/s
  • overrided方法编译错误 kane_xie override
    问题描述： 在实现类中的某一或某几个Override方法发生编译错误如下： Name clash: The method put(String) of type XXXServiceImpl has the same erasure as put(String) of type XXXService but does not override it   当去掉@Over
  • Java中使用代理IP获取网址内容（防IP被封，做数据爬虫） mcj8089 免费代理IP代理IP数据爬虫JAVA设置代理IP爬虫封IP
    推荐两个代理IP网站：   1. 全网代理IP：http://proxy.goubanjia.com/   2. 敲代码免费IP：http://ip.qiaodm.com/   Java语言有两种方式使用代理IP访问网址并获取内容，   方式一，设置System系统属性   // 设置代理IP System.getProper
  • Nodejs Express 报错之 listen EADDRINUSE qiaolevip 每天进步一点点学习永无止境nodejs纵观千象
    当你启动 nodejs服务报错： >node app Express server listening on port 80 events.js:85 throw er; // Unhandled 'error' event ^ Error: listen EADDRINUSE at exports._errnoException (
  • C++中三种new的用法 _荆棘鸟_ C++new
    转载自：http://news.ccidnet.com/art/32855/20100713/2114025_1.html 作者: mt 其一是new operator，也叫new表达式；其二是operator new，也叫new操作符。这两个英文名称起的也太绝了，很容易搞混，那就记中文名称吧。new表达式比较常见，也最常用，例如： string* ps = new string("
  • Ruby深入研究笔记1 wudixiaotie Ruby
    module是可以定义private方法的 module MTest def aaa puts "aaa" private_method end private def private_method puts "this is private_method" end end
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他