中文文档参考地址，点击这里
汪文君Mockito实战视频
汪文君Mockito源码，点击这里
参考文章

@InjectMocks

用来修饰被测试的类：就是对哪个类中的方法进行单元测试的时候，就用该注解修饰这个类。

• InjectMocks创建这个类的对象并自动标记@Mock，@Spy等注解的属性注入到这个中。
• 要求必须是类不能是接口。

使用

步骤：

1. 环境使用mock和test包
2. 使用mockitoRule构造mockito环境

@Rule

public MokitoRule rule = MockitoJUnit.rule();

注意这里的修饰符public，如果没有这个修饰符的话使用mock测试会报错

 @Rule

 public ExpectedException thrown = ExpectedException.none();

可以选择忽视抛出的异常？（我是这么理解的不知道是否正确）

3. 对目标测试类加@InjectMocks注解
4. 对目标测试类的依赖属性使用@mock创建依赖
5. 使用@test注解测试目标类的方法执行逻辑
   2mock对象创建和目标测试类的依赖注入
   这里我还没有看juint执行的逻辑，只是看了mock环境下获取注解创建mock对象，并将mock的对向注入到@Injectmocks的目标测试对象中去的逻辑。

1.Maven

<!-- https://mvnrepository.com/artifact/org.mockito/mockito-all -->
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-all</artifactId>
        <version>2.0.2-beta</version>
    </dependency>
       <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>

2.创建Mock对象

1.通过方法创建

/**
 * @description: 使用Mockito启动器进行单元测试
 * @author: wei·man cui
 * @date: 2020/8/13 11:08
 */
@RunWith(MockitoJUnitRunner.class)
public class MockitoByRunnerTest {
    

    @Test
    public void testMock() {
    
        //通过方法的模式，Mock一个对象
        AccountDao accountDao = Mockito.mock(AccountDao.class);
        // 不会报错，但返回null。不会真正执行 accountDao.findAccount()方法，只是模拟该行为。
        Account account = accountDao.findAccount("x", "y");
        System.out.println(account);
    }

}

2.通过注解创建

/**
 * @description: Annotation方式进行Mock
 * @author: wei·man cui
 * @date: 2020/8/13 11:22
 */
public class MockByAnnotationTest {
    

    @Before
    public void init() {
    
        MockitoAnnotations.initMocks(this);
    }

    @Mock
    private AccountDao accountDao;

    @Test
    public void testMock() {
    
        Account account = accountDao.findAccount("x", "y");
        System.out.println(account);
    }

}

一个简单的例子：

package Mockito;

import org.junit.Assert;
import org.junit.Test;
import java.util.List;

import static org.mockito.Mockito.*;

public class MyTest {
    
    @Test
    public void myTest() {
    
        /* 创建 Mock 对象 */
        List list = mock(List.class);
        /* 设置预期，当调用 get(0) 方法时返回 "111" */
        when(list.get(0)).thenReturn("111");

        Assert.assertEquals("asd", 1, 1);
        /* 设置后返回期望的结果 */
        System.out.println(list.get(0));
        /* 没有设置则返回 null */
        System.out.println(list.get(1));

        /* 对 Mock 对象设置无效 */
        list.add("12");
        list.add("123");
        /* 返回之前设置的结果 */
        System.out.println(list.get(0));
        /* 返回 null */
        System.out.println(list.get(1));
        /* size 大小为 0 */
        System.out.println(list.size());

        /* 验证操作，验证 get(0) 调用了 2 次 */
        verify(list, times(2)).get(0);

        /* 验证返回结果 */
        String ret = (String)list.get(0);
        Assert.assertEquals(ret, "111");
   }

从上面代码能看出一般使用的步骤：

设置方法预期返回
通过 when(list.get(0)).thenReturn(“111”); 来设置当调用 list.get(0) 时返回 “111”，该方法就是 Stub，替换我们实际的操作。

验证方法调用
该方法验证 get(0) 方法调用的次数 verify(list, times(2)).get(0);，还可以设置是否调用过，调用时间等等。

验证返回值
Assert.assertEquals(ret, “111”); 方法验证 Mock 对象方法调用后的返回值是否达到预期。

---

Spy

Mock构造一个List对象的时候，使用add是无效的(代表对象的真正的方法)，只有使用Spy的时候才能使之生效。
代码如下所示：

   @RunWith(MockitoJUnitRunner.class)
public class SpyingTest {
    

    /**
     * Spy：用于部分方法的 Mock(模拟)
     */
    @Test
    public void testSpy() {
    
        List<String> realList = new ArrayList<>();
        List<String> list = Mockito.spy(realList);

        list.add("Mockito");
        list.add("PowerMock");
        assertThat(list.get(0), equalTo("Mockito"));
        assertThat(list.get(1), equalTo("PowerMock"));
        assertThat(list.isEmpty(), equalTo(false));

        // Stubbing 语法 模拟 list 的返回内容
        Mockito.when(list.isEmpty()).thenReturn(true);
        Mockito.when(list.size()).thenReturn(0);

        assertThat(list.get(0), equalTo("Mockito"));
        assertThat(list.get(1), equalTo("PowerMock"));
        assertThat(list.isEmpty(), equalTo(true));
        assertThat(list.size(), equalTo(0));
    }

}

或者使用注解的方式：

public class SpyingAnnotationTest {
    

    @Spy
    private List<String> list = new ArrayList<>();

    @Before
    public void init() {
    
        MockitoAnnotations.initMocks(SpyingAnnotationTest.class);
    }

    @Test
    public void testSpy() {
    
        list.add("Mockito");
        list.add("PowerMock");
        assertThat(list.get(0), equalTo("Mockito"));
        assertThat(list.get(1), equalTo("PowerMock"));
        assertThat(list.isEmpty(), equalTo(false));

       // Stubbing 语法 模拟 list 的返回内容
        Mockito.when(list.isEmpty()).thenReturn(true);
        Mockito.when(list.size()).thenReturn(0);

        assertThat(list.get(0), equalTo("Mockito"));
        assertThat(list.get(1), equalTo("PowerMock"));
        assertThat(list.isEmpty(), equalTo(true));
        assertThat(list.size(), equalTo(0));
    }

}

我认为比较好的一种方式:

下面是Mockito具体使用的一些示例：

mock外部依赖对象，并注入到我们的业务类中，以便在单元测试中进行模拟调用：

@RunWith(MockitoJUnitRunner.class) //让测试运行于Mockito环境
public class LocalServiceImplMockTest {
    

    @InjectMocks    //此注解表示这个对象需要被注入mock对象
    private LocalServiceImpl localService;
    @Mock   //此注解会自动创建1个mock对象并注入到@InjectMocks对象中
    private RemoteServiceImpl remoteService;

    //如果不使用上述注解，可以使用@Before方法来手动进行mock对象的创建和注入，但会几行很多代码
    /*
    private LocalServiceImpl localService;
    private RemoteServiceImpl remoteService;

    @Before
    public void setUp() throws Exception {
        localService = new LocalServiceImpl();
        remoteService = Mockito.mock(RemoteServiceImpl.class);  //创建Mock对象
        Whitebox.setInternalState(localService, "remoteService", remoteService); //注入依赖对象
    }
    */

    @Test
    public void testMock() {
    
        Node target = new Node(1, "target");    //创建一个Node对象作为返回值
        Mockito.when(remoteService.getRemoteNode(1)).thenReturn(target); //指定当remoteService.getRemoteNode(int)方法传入参数为1时返回target对象
        Node result = localService.getRemoteNode(1);    //调用我们的业务方法，业务方法内部调用依赖对象方法
        assertEquals(target, result);   //可以断言我们得到的返回值其实就是target对象
        assertEquals(1, result.getNum());   //具体属性和我们指定的返回值相同
        assertEquals("target", result.getName());   //具体属性和我们指定的返回值相同

        Node result2 = localService.getRemoteNode(2);   //未指定参数为2时对应的返回规则
        assertNull(result2);    //未指定时返回为null
    }
}

1.spy外部依赖对象，并注入到我们的业务类中：

@RunWith(MockitoJUnitRunner.class)
public class LocalServiceImplSpyTest {
    

    @InjectMocks
    private LocalServiceImpl localService;
    @Spy    //注意这里使用的是@Spy注解
    private RemoteServiceImpl remoteService;
    //注意如果自己创建spy对象的话要这么写：
    /*
        remoteService = new RemoteServiceImpl();    //先创建一个具体实例
        remoteService = Mockito.spy(remoteService);   //再调用Mockito.spy(T)方法创建spy对象
    */

    @Test
    public void testSpy() {
    
        Node target = new Node(1, "target");    //创建一个Node对象作为返回值
        Mockito.when(remoteService.getRemoteNode(1)).thenReturn(target); //指定当remoteService.getRemoteNode(int)方法传入参数为1时返回target对象
        Node result = localService.getRemoteNode(1);    //调用我们的业务方法，业务方法内部调用依赖对象方法
        assertEquals(target, result);   //可以断言我们得到的返回值其实就是target对象
        assertEquals(1, result.getNum());   //具体属性和我们指定的返回值相同
        assertEquals("target", result.getName());   //具体属性和我们指定的返回值相同

        Node result2 = localService.getRemoteNode(2);   //未指定参数为2时的调用规则，所以会直接调用真实对象，返回remote创建的节点
        assertEquals(2, result2.getNum());
        assertEquals("Node from remote service", result2.getName());    //remoteService创建Node对象时设置name属性为"Node from remote service"
    }
}

1.使用ArgumentMatchers的any系列方法指定多种返回值，有any()、anyInt()、anyString()、anyByte()、anyLong()等等，可以看下ArgumentMatchers类源码中定义的所有方法：

    @Test
    public void testAny() {
    
        Node target = new Node(1, "target");
        when(remoteService.getRemoteNode(anyInt())).thenReturn(target); //静态导入Mockito.when和ArgumentMatchers.anyInt后可以简化代码提升可读性

        Node result = localService.getRemoteNode(20); //上面指定了调用remoteService.getRemoteNode(int)时，不管传入什么参数都会返回target对象
        assertEquals(target, result);   //可以断言我们得到的返回值其实就是target对象
        assertEquals(1, result.getNum());   //具体属性和我们指定的返回值相同
        assertEquals("target", result.getName());   //具体属性和我们指定的返回值相同
    }

指定mock对象多次调用的返回值：

    /**
     * 指定mock多次调用返回值
     */
    @Test
    public void testMultipleReturn() {
    
        Node target1 = new Node(1, "target");
        Node target2 = new Node(1, "target");
        Node target3 = new Node(1, "target");
        when(remoteService.getRemoteNode(anyInt())).thenReturn(target1).thenReturn(target2).thenReturn(target3);
        //第一次调用返回target1、第二次返回target2、第三次返回target3

        Node result1 = localService.getRemoteNode(1); //第1次调用
        assertEquals(target1, result1);
        Node result2 = localService.getRemoteNode(2); //第2次调用
        assertEquals(target2, result2);
        Node result3 = localService.getRemoteNode(3); //第3次调用
        assertEquals(target3, result3);
    }
指定mock对象抛出异常（注意如果方法中未声明会抛出异常，只能指定抛出运行时异常，如果仍指定为抛出受检查异常，运行时会报错误org.mockito.exceptions.base.MockitoException: Checked exception is invalid for this method!）：
    //RemoteServiceImpl方法：
    @Override
    public Node getRemoteNode(String name) throws MockException {
    
        if (StringUtils.isEmpty(name)) {
    
            throw new MockException("name不能为空", name);
        }
        return new Node(name);
    }

    //LocalServiceImpl方法
    @Override
    public Node getRemoteNode(String name) throws MockException {
    
        try {
    
            return remoteService.getRemoteNode(name);
        } catch (IllegalArgumentException e) {
    
            throw e;
        }
    }

    /**
     * 指定mock对象已声明异常抛出的方法抛出受检查异常
     */
    @Test
    public void testExceptionDeclare() {
    
        try {
    
            Node target = new Node(1, "target");
            when(remoteService.getRemoteNode("name")).thenReturn(target).thenThrow(new MockException(
                    "message", "exception")); //第一次调用正常返回，第二次则抛出一个Exception

            Node result1 = localService.getRemoteNode("name");
            assertEquals(target, result1); //第一次调用正常返回

            Node result2 = localService.getRemoteNode("name"); //第二次调用不会正常返回，会抛出异常
            assertEquals(target, result2);
        } catch (MockException e) {
    
            assertEquals("exception", e.getName()); //验证是否返回指定异常内容
            assertEquals("message", e.getMessage()); //验证是否返回指定异常内容
        }
    }

    /**
     * 指定mock对象为声明异常抛出的方法抛出运行时异常
     */
    @Test
    public void testRuntimeException() {
    
        Node target = new Node(1, "target");
        when(remoteService.getRemoteNode(1)).thenThrow(new RuntimeException("exception")); //指定调用时抛出一个运行时异常

        try {
    
            Node result = localService.getRemoteNode(1);
            assertEquals(target, result);
        } catch (RuntimeException e) {
    
            assertEquals("exception", e.getMessage());
        }
    }

    /**
     * 指定mock对象未声明异常抛出的方法抛出受检查异常，以下方法执行会报错
     */
    @Test
    public void testNotDefineCheckedException() {
    
        Node target = new Node(1, "target");
        when(remoteService.getRemoteNode(1)).thenThrow(new IOException("io exception"));

        try {
    
            Node result = localService.getRemoteNode(1);
            assertEquals(target, result);
        } catch (Exception e) {
    
            assertEquals("io exception", e.getMessage());
        }
    }
mock void方法抛异常、什么都不做：
    //RemoteServiceImpl方法：
    @Override
    public void doSometing() {
    
        System.out.println("remote service do something!");
    }

    //LocalServiceImpl方法
    @Override
    public void remoteDoSomething() {
    
        remoteService.doSometing();
    }

    //注意void方法没有返回值，所以mock规则写法顺序不一样
    doNothing().when(remoteService).doSometing();
    doThrow(new RuntimeException("exception")).when(remoteService).doSometing();

校验mock对象的调用情况（除Mockito中的never()、times(int)方法外，还有atLeast(int)、atLeastOne()、atMost(int)等方法）：

   /**
     * 校验mock对象和方法的调用情况
     *
     */
    public void testVerify() {
    
        Node target = new Node(1, "target");
        when(remoteService.getRemoteNode(anyInt())).thenReturn(target);

        verify(remoteService, never()).getRemoteNode(1); //mock方法未调用过

        localService.getRemoteNode(1);
        Mockito.verify(remoteService, times(1)).getRemoteNode(anyInt()); //目前mock方法调用过1次

        localService.getRemoteNode(2);
        verify(remoteService, times(2)).getRemoteNode(anyInt()); //目前mock方法调用过2次
        verify(remoteService, times(1)).getRemoteNode(2); //目前mock方法参数为2只调用过1次
    }

利用ArgumentCaptor捕获方法参数进行mock方法参数校验

    /**
     * 利用ArgumentCaptor捕获方法参数进行mock方法参数校验
     */
    @Test
    public void testCaptor() throws Exception {
    
        Node target = new Node(1, "target");
        when(remoteService.getRemoteNode(anyString())).thenReturn(target);

        localService.getRemoteNode("name1");
        localService.getRemoteNode("name2");
        verify(remoteService, atLeastOnce()).getRemoteNode(localCaptor.capture()); //设置captor

        assertEquals("name2", localCaptor.getValue()); //获取最后一次调用的参数
        List<String> list = localCaptor.getAllValues(); //按顺序获取所有传入的参数
        assertEquals("name1", list.get(0));
        assertEquals("name2", list.get(1));
    }

mock对象调用真实方法：

    /**
     * mock对象调用真实方法
     */
    @Test
    public void testCallRealMethod() {
    
        when(remoteService.getRemoteNode(anyInt())).thenCallRealMethod(); //设置调用真实方法
        Node result = localService.getRemoteNode(1);

        assertEquals(1, result.getNum());
        assertEquals("Node from remote service", result.getName());
    }

重置mock对象：

    //重置mock，清除所有的调用记录和返回规则
    Mockito.reset(remoteService);

校验mock对象0调用和未被验证的调用

    /**
     * 校验mock对象0调用和未被验证的调用
     */
    @Test(expected = NoInteractionsWanted.class)
    public void testInteraction() {
    
        verifyZeroInteractions(remoteService); //目前还未被调用过，执行不报错

        Node target = new Node(1, "target");
        when(remoteService.getRemoteNode(anyInt())).thenReturn(target);

        localService.getRemoteNode(1);
        localService.getRemoteNode(2);
        verify(remoteService, times(2)).getRemoteNode(anyInt());
        // 参数1和2的两次调用都会被上面的anyInt()校验到，所以没有未被校验的调用了
        verifyNoMoreInteractions(remoteService);

        reset(remoteService);
        localService.getRemoteNode(1);
        localService.getRemoteNode(2);
        verify(remoteService, times(1)).getRemoteNode(1);
        // 参数2的调用不会被上面的校验到，所以执行会抛异常
        verifyNoMoreInteractions(remoteService);
    }

Mockito 使用

设置 Mock 对象期望和返回值

/* 表示第一次调用 someMethod() 返回 value1 第二次调用返回 value2 */
when(mock.someMethod()).thenReturn(value1).thenReturn(value2);  
when(mock.someMethod()).thenReturn(value1, value2);  
/* 也可以设置两次 */
when(mock.someMethod()).thenReturn(value1);
when(mock.someMethod()).thenReturn(value2);

另外一种写法 doReturn()

/* 表示第一次调用 someMethod() 返回 value1 第二次调用返回 value2 */
doReturn(value1).doReturn(value2).when(mock).someMethod();  
/* 若返回 void，则设置为 doNothing() */
doNothing().when(mock).someMethod();

对方法设定返回异常

/* 当调用 someMethod() 方法时会抛出异常 */
when(mock.someMethod()).thenThrow(new RuntimeException());
/* 对 void 方法设定 */  
doThrow(new RuntimeException()).when(mock).someMethod();  

参数匹配器
我们不一定要固定 Stub 调用时的参数，如 get(0)。可以通过参数匹配器来调用。

when(list.get(anyInt())).thenReturn("hello");

不同的调用次数返回不同的值

@Test 
public void Test01(){
    
//这种方式，第一次调用返回1，第二次调用返回2，4次以后，都一直返回4.
 Mockito.when(list.size()).thenReturn(1,2,3,4);
 asertThat(list.size(),equalTo(1));
 asertThat(list.size(),equalTo(2));
 asertThat(list.size(),equalTo(3));
 asertThat(list.size(),equalTo(4));
//与上面等价的一种方式
 Mockito.when(list.size()).thenReturn(1).thenReturn(2).thenReturn(3).thenReturn(4);
}

Mock 对象的行为验证

package Mockito;

import org.mockito.ArgumentCaptor;
import org.mockito.InOrder;
import org.testng.annotations.Test;

import java.util.List;
import static org.mockito.Mockito.*;

/**
 * Created by andy.wwh on 2016/7/18.
 */
public class Behavior {
    
    @Test
    public void behaviorCheck() {
    
        List mock1 = mock(List.class);
        List mock2 = mock(List.class);

        /* 设置预期 */
        when(mock1.get(0)).thenReturn("hello world");
        when(mock1.get(1)).thenReturn("hello world");
        when(mock2.get(0)).thenReturn("hello world");
        mock1.get(0);

        /* 验证方法调用一次 */
        verify(mock1).get(0);
        mock1.get(0);
        /* 验证方法调用两次 */
        verify(mock1, times(2)).get(0);
        /* 验证方法从未被调用过 */
        verify(mock2, never()).get(0);
        /* 验证方法 100 毫秒内调用两次 */
        verify(mock1, timeout(100).times(2)).get(anyInt());

        /* 设置方法调用顺序 */
        InOrder inOrder = inOrder(mock1, mock2);
        inOrder.verify(mock1, times(2)).get(0);
        inOrder.verify(mock2, never()).get(1);

        /*  查询是否存在被调用，但未被 verify 验证的方法 */
        verifyNoMoreInteractions(mock1, mock2);
        /* 验证 Mock 对象是否没有交发生 */
        verifyZeroInteractions(mock1, mock2);

        /* 参数捕获器 */
        ArgumentCaptor<Integer> argumentCaptor = ArgumentCaptor.forClass(Integer.class);
        verify(mock1, times(2)).get(argumentCaptor.capture());
        System.out.println("argument:" + argumentCaptor.getValue());
    }
}

验证调用次数

verify(mock1, timeout(100).times(2)).get(anyInt());

除了代码中的方法，Mockito 还提供了

• never() 没有被调用，相当于times(0)
• atLeast(N) 至少被调用N次
• atLeastOnce() 相当于atLeast(1)
• atMost(N) 最多被调用N次

超时验证
通过 timeout 我们可以进行验证程序执行时间是否符合规则。

方法调用顺序
Inorder 可以验证方法调用的顺序

verifyNoMoreInteractions 和 verifyZeroInteractions
verifyNoMoreInteractions：查询是否存在被调用，但未被 verify 验证的方法

verifyZeroInteractions：verifyZeroInteractions

ArgumentCaptor 参数捕获器
可在验证时对方法的参数进行捕获，最后验证捕获的参数值。如果方法有多个参数都要捕获验证，那就需要创建多个ArgumentCaptor对象处理。

---

Spy 对象验证

Mock 操作的全是虚拟对象。即使我们设置了 when(list.get(0)).thenReturn(1)，我们调用如 size() 方法返回的还是 0。Mockito 还给我们提供了一种对真实对象操作的方法——Spy

做一个简单的比较：

package Mockito;

import org.testng.annotations.Test;

import java.util.List;

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

/**
 * Created by andy.wwh on 2016/7/18.
 */
public class MockObject {
    
    @Test
    public void MockTest() {
    
        List list = mock(List.class);

        when(list.get(0)).thenReturn("hello world");

        System.out.println(list.get(0));

        System.out.println(list.size());
    }
}

package Mockito;

import org.testng.annotations.Test;

import java.util.LinkedList;
import java.util.List;

import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;

/**
 * Created by andy.wwh on 2016/7/18.
 */
public class MockObject {
    
    @Test
    public void MockTest() {
    
        /* 创建真实对象 */
        List list = new LinkedList();
        List spy = spy(list);

        spy.add("hello");

        when(spy.get(0)).thenReturn("hello world");

        System.out.println(spy.get(0));
    }
}

看个官网的例子：

@Test  
public void spyTest() {
      
    List list = new LinkedList();  
    List spy = spy(list);  
    // optionally, you can stub out some methods:  
    when(spy.size()).thenReturn(100);  
    // using the spy calls real methods  
    spy.add("one");  
    spy.add("two");  
    // prints "one" - the first element of a list  
    System.out.println(spy.get(0));  
    // size() method was stubbed - 100 is printed  
    System.out.println(spy.size());  
    // optionally, you can verify  
    verify(spy).add("one");  
    verify(spy).add("two");