(在我看来)最简单和最易读的方法是使用方法级注入。

这将导致在测试方法中拥有所有测试数据。这将使您的测试类保持干净，因为没有“浮动”mock。

@ExtendWith(MockitoExtension.class)
public class SomeClassTest {

    @Test
    void someTestMethod(@Mock Foo<Bar> fooMock) {
        // do something with your mock
    }
    
}

正如其他答案所提到的，如果没有不安全的泛型访问和/或抑制泛型警告，直接使用mock()和spy()方法并不是一个很好的方法。

目前在Mockito项目(#1531)中有一个悬而未决的问题，即添加对使用mock()和spy()方法而不带泛型警告的支持。该问题于2018年11月开始发行，但没有任何迹象表明它将被优先考虑。根据Mockito贡献者对这个问题的评论:

鉴于.class不能很好地使用泛型，我认为在Mockito中没有任何解决方案。您已经可以使用@Mock (JUnit5扩展还允许方法参数@Mock)，这应该是一个合适的替代方案。因此，我们可以保持这个问题的开放性，但它不太可能被修复，因为@Mock是一个更好的API。

对于JUnit5，我认为最好的方法是在方法参数或字段中使用@Mock @ExtendWith(MockitoExtension.class)。

下面的例子用Hamcrest匹配器演示了这一点。

package com.vogella.junit5;                                                                    
                                                                                               
import static org.hamcrest.MatcherAssert.assertThat;                                           
import static org.hamcrest.Matchers.hasItem;                                                   
import static org.mockito.Mockito.verify;                                                      
                                                                                               
import java.util.Arrays;                                                                       
import java.util.List;                                                                         
                                                                                               
import org.junit.jupiter.api.Test;                                                             
import org.junit.jupiter.api.extension.ExtendWith;                                             
import org.mockito.ArgumentCaptor;                                                             
import org.mockito.Captor;                                                                     
import org.mockito.Mock;                                                                       
import org.mockito.junit.jupiter.MockitoExtension;                                             
                                                                                               
@ExtendWith(MockitoExtension.class)                                                            
public class MockitoArgumentCaptureTest {                                                      
                                                                                               
                                                                                               
    @Captor                                                                                    
    private ArgumentCaptor<List<String>> captor;                                               
                                                                                               
    @Test                                                                                      
    public final void shouldContainCertainListItem(@Mock List<String> mockedList) {            
        var asList = Arrays.asList("someElement_test", "someElement");                         
        mockedList.addAll(asList);                                                             
                                                                                               
        verify(mockedList).addAll(captor.capture());                                           
        List<String> capturedArgument = captor.getValue();                                     
        assertThat(capturedArgument, hasItem("someElement"));                                  
    }                                                                                          
}                                                                                              
                                                                                              

有关所需的Maven/Gradle依赖项，请参阅https://www.vogella.com/tutorials/Mockito/article.html。

JUnit5:在测试类上使用@ExtendWith(MockitoExtension.class)，然后添加这个字段:

@Mock
Foo<Bar> barMock;

为什么不用间谍

var mock = spy(new Foo<Bar>());
when(mockFoo.getValue()).thenReturn(new Bar());

我同意人们不应该在类或方法中压制警告，因为这样会忽略其他意外压制的警告。但是恕我直言，对于只影响一行代码的警告，不发出警告是完全合理的。

@SuppressWarnings("unchecked")
Foo<Bar> mockFoo = mock(Foo.class);