单元测试中：Mock对象与实例化POJO对象哪种方式更优？

Great question! When working with POJOs—those simple data holders with just getters, setters, and maybe a basic constructor, no business logic to speak of—let’s break down the tradeoffs between mocking and using real instances.

Go with Real Instances (Almost Always) #

Here’s why creating an actual POJO instance is the better approach:

• It’s simple and intuitive: POJOs exist to carry data, so using a real one mirrors how your application will use it in production. No need to overcomplicate things with mocks. For example:

  User user = new User("Marcos", 30);
  // Or use a builder if you have one
  User user = User.builder().name("Marcos").age(30).build();
  

  This code is straightforward for anyone reading your tests to understand.
• No unnecessary overhead: Mocking frameworks like Mockito are designed to simulate objects with complex behavior or external dependencies. POJOs have neither—mocking them adds extra code (like stubbing getters) that serves no purpose. Why write when(mockUser.getName()).thenReturn("Marcos") when you can just set the value directly on a real object?
• Easier to validate: If your test needs to check that a POJO has the correct values, using a real instance lets you call its getters directly. With a mock, you’d have to verify stubbed methods, which is an extra layer of indirection that doesn’t add value.

When Might You Even Consider Mocking a POJO? #

Honestly? Hardly ever. The only edge cases I can think of are:

• A "POJO" that’s not actually a POJO: If your class has heavy initialization logic in its constructor (which it shouldn’t, if it’s a true POJO), you might mock it to avoid that overhead. But this is a red flag—you should probably refactor the class to separate data from logic instead of mocking it.
• Extremely niche test framework constraints: Maybe some specialized testing tool forces you to mock objects, but this is a rare exception, not the rule.

Final Takeaway #

Save yourself the hassle and stick with real POJO instances in your tests. Mocking them is overkill, adds unnecessary complexity, and makes your tests less reflective of how your code actually runs. POJOs are meant to be simple—your tests for them should be too.

内容的提问来源于stack exchange，提问作者Marcos