Constructor Injection

Constructor Injection Pattern

@Service
public class OrderService {

    private final OrderRepository orderRepository;
    private final PaymentService paymentService;
    private final NotificationService notificationService;

    // All dependencies injected via constructor
    public OrderService(OrderRepository orderRepository,
                       PaymentService paymentService,
                       NotificationService notificationService) {
        this.orderRepository = orderRepository;
        this.paymentService = paymentService;
        this.notificationService = notificationService;
    }
}

Benefits

Benefit	Explanation
Immutability	Dependencies are final, can't change after construction
Explicit	All dependencies visible in constructor
Testable	Easy to pass mocks in unit tests
Null safety	Fails fast if dependency missing
No reflection	Works without Spring (POJO)

Unit Testing

class OrderServiceTest {

    @Test
    void shouldCreateOrder() {
        // Arrange — no Spring needed!
        OrderRepository mockRepo = mock(OrderRepository.class);
        PaymentService mockPayment = mock(PaymentService.class);
        NotificationService mockNotification = mock(NotificationService.class);

        OrderService service = new OrderService(mockRepo, mockPayment, mockNotification);

        // Act
        service.createOrder(new OrderRequest());

        // Assert
        verify(mockRepo).save(any());
    }
}

Circular Dependencies

A depends on B
B depends on A
→ Circular dependency error at startup

Solutions:

1. Redesign to break the cycle
2. Use @Lazy annotation
3. Extract shared logic to a third service

Key Principles

1. Follow SOLID principles
2. Write clean, readable code
3. Test thoroughly
4. Document decisions
5. Monitor in production

Implementation

• Start simple, refactor as needed
• Use established patterns
• Consider trade-offs
• Review with peers

Continuous Improvement

• Learn from incidents
• Update documentation
• Share knowledge
• Mentor others

Key Points

• Understanding Constructor Injection is essential for production systems
• Always consider scalability and maintainability
• Test thoroughly before deploying to production
• Monitor performance and set up alerting

Common Patterns

1. Validation: Always validate input at the boundary
2. Error Handling: Use structured error responses
3. Logging: Log key events for debugging
4. Testing: Unit, integration, and load tests
5. Documentation: Keep docs updated with code changes