@InjectMocks Injection Strategy | Java Fresher Interview

Direct Answer

@InjectMocks is a convenience, not a dependency-injection container. Mockito first considers the largest constructor and resolves arguments from declared mocks by type; unresolved non-mockable arguments may be passed as null. If constructor injection creates the object, Mockito does not continue with setter or field injection. Otherwise it may use a no-argument instance and try property/setter injection, then field injection. Unmatched dependencies can remain null without a clear injection error, while construction failures can still throw.

Code Example

class OrderService {
    private final PaymentGateway paymentGateway;
    private final InventoryRepository inventoryRepo;
    private EmailSender emailSender; // optional dependency

    // Constructor injection - Mockito tries this first
    public OrderService(PaymentGateway paymentGateway, InventoryRepository inventoryRepo) {
        this.paymentGateway = paymentGateway;
        this.inventoryRepo = inventoryRepo;
    }

    // Setter injection - Mockito tries this second if constructor fails
    public void setEmailSender(EmailSender emailSender) {
        this.emailSender = emailSender;
    }
}

@ExtendWith(MockitoExtension.class)
class OrderServiceTest {
    @Mock PaymentGateway paymentGateway;
    @Mock InventoryRepository inventoryRepo;
    @Mock EmailSender emailSender;

    @InjectMocks OrderService orderService; // wires all three via constructor + setter

    @Test
    void shouldProcessOrder() {
        when(paymentGateway.charge(any())).thenReturn(true);
        // test logic here
    }
}

Common Mistakes & Pitfalls

• Expecting an Error on Injection Failure: Freshers assume @InjectMocks will throw an exception if a dependency can't be wired — it doesn't. It leaves the field null, causing cryptic NPE later.
• Mixing Field and Constructor Injection: Using @Autowired field injection in production code then wondering why @InjectMocks behaves unpredictably — the injection order becomes ambiguous.
• Not Using @ExtendWith(MockitoExtension.class): Forgetting this annotation means @Mock and @InjectMocks aren't processed, leaving everything null and causing test failures that look like mock issues but are actually initialization problems.