Lombok @Synchronized 与 Mockito 抛出 NPE

Question

鉴于synchronized 和Lombok 的@Synchronized，后者在模拟被测方法时会导致NullPointerException。给定

public class Problem
{
    public Problem()
    {
        // Expensive initialization,
        // so use Mock, not Spy
    }

    public synchronized String a()
    {
        return "a";
    }

    @Synchronized // <-- Causes NPE during tests, literally, here
    public String b()
    {
        return "b";
    }
}

和木星测试类

class ProblemTest
{
    @Mock
    private Problem subject;

    @BeforeEach
    void setup()
    {
        initMocks(this);
        // There is more mocking. Please don't let the simplicity
        // of this example throw you off.
        doCallRealMethod().when( subject ).a();
        doCallRealMethod().when( subject ).b();

        // This is a hack, but works. Can we rely on this?
        // ReflectionTestUtils.setField( subject, "$lock", new Object[0] );
    }

    @Test
    void a()
    {
        // Succeeds
        assertEquals( "a", subject.a() );
    }

    @Test
    void b()
    {
        // NullPointerException during tests
        assertEquals( "b", subject.b() );
    }
}

Lombok 添加如下内容：

private final Object $lock = new Object[0]; // We can't rely on this name
...
public String b()
{
    synchronized($lock)
    {
        return "b";
    }
}

如何模拟一个用 Lombok 的 default @Synchronized 注解修饰的方法？

---

这是堆栈跟踪，虽然它没有帮助。我怀疑 Lombok 在上面的示例中添加了一个字段，当然这并没有注入到模拟中，所以瞧，NPE。

java.lang.NullPointerException
    at com.ericdraken.Problem.b(Problem.java:16) // <-- @Synchronized keyword
    at com.ericdraken.ProblemTest.b(ProblemTest.java:43) // <-- assertEquals( "b", subject.b() );
    at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    ... [snip] ...
    at com.intellij.rt.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:230)
    at com.intellij.rt.junit.JUnitStarter.main(JUnitStarter.java:58)

Answer 1

这不是 Lombok 的问题，以下也失败了。

@ExtendWith({MockitoExtension.class})
@MockitoSettings(strictness = Strictness.LENIENT)
public class ProblemTest {
    @Mock
    private Problem subject;

    @BeforeEach
    void setup()
    {
        doCallRealMethod().when( subject ).c();

    }

    @Test
    void c()
    {
        // NullPointerException during tests
        assertEquals( "c", subject.c() );
    }
}

class Problem
{
  private final Map<String,String> c = new HashMap<>(){{put("c","c");}};

    public String c(){
        return c.get("c");
    }
}

确切地说，您并不是真的在嘲笑 Problem，而是通过 doCallRealMethod部分地嘲笑因此问题。

这在 Mockito 的 documentation 中也有提及，

Mockito.spy() 是创建部分模拟的推荐方法。原因是它保证对正确构造的对象调用真正的方法，因为您负责构造传递给 spy() 方法的对象。

doCallRealMethod() 是在一个模拟上调用的，但不能保证该对象会按照应有的方式创建。

所以要回答您的问题，是的，这就是您创建模拟的方式，但doCallRealMethod 始终是一场赌博，无论龙目岛如何。

如果你真的想调用实际的方法，你可以使用spy。

  @Test
  void c() {
    Problem spyProblem = Mockito.spy(new Problem());
    assertEquals("c", spyProblem.c());
    verify(spyProblem, Mockito.times(1)).c();
  }

Answer 2

核心问题是您将调用真实方法与模拟而不是间谍结合起来。这是危险的一般，因为它是否适用于任何事情很大程度上取决于相关方法的内部实现。

Lombok 之所以重要，是因为它通过在编译期间更改内部实现来工作，这种方式恰好需要正确的对象初始化才能在原始方法不工作的情况下工作。

如果你要配置一个模拟来调用真实的方法，你应该使用一个间谍来代替。

Answer 3

概要

Project Lombok 在隐藏底层和自动生成的私有锁的方法上有 @Synchronized 注释，而 synchronized 锁定 this。

当使用 Mockito 模拟时（不是间谍，因为在某些情况下我们不希望实例化完整的对象），字段不会被初始化。这也意味着自动生成的“锁定”字段为空，这会导致 NPE。

解决方案 1 - 现场注入

查看 Lombok source code，我们看到 Lombok 使用以下锁名称：

private static final String INSTANCE_LOCK_NAME = "$lock";
private static final String STATIC_LOCK_NAME = "$LOCK";

除非 Lombok 将来突然改变这一点，这意味着我们可以进行字段注入，即使感觉像是“黑客”：

@BeforeEach
void setup()
{
    initMocks(this);
    ...
    ReflectionTestUtils.setField( subject, "$lock", new Object[0] );
}

解决方案 2 - 声明一个锁，然后进行字段注入

问题是关于@Synchronized，而不是@Synchronized("someLockName")，但是如果你可以明确声明锁名，那么你可以对锁字段名有信心地使用解决方案一。