Dependency Injection

Dependency Injection (DI) is the technique of providing an object's dependencies from the outside rather than creating them internally.

Without DI (Tightly Coupled)

// BAD: Class creates its own dependencies
public class OrderService {
    private final OrderRepository orderRepository = new OrderRepository();  // Hard-coded!
    private final PaymentService paymentService = new PaymentService();     // Hard-coded!
    private final EmailService emailService = new EmailService();           // Hard-coded!

    // Impossible to test — can't mock dependencies
}

With DI (Loosely Coupled)

// GOOD: Dependencies injected from outside
@Service
public class OrderService {
    private final OrderRepository orderRepository;
    private final PaymentService paymentService;
    private final EmailService emailService;

    // Spring creates and injects these automatically
    public OrderService(OrderRepository orderRepository,
                        PaymentService paymentService,
                        EmailService emailService) {
        this.orderRepository = orderRepository;
        this.paymentService = paymentService;
        this.emailService = emailService;
    }
}

Three Types of Injection

1. Constructor Injection (Recommended)

@Service
public class ProductService {
    private final ProductRepository repository;

    @Autowired  // Optional in Spring 4.3+
    public ProductService(ProductRepository repository) {
        this.repository = repository;
    }
}

2. Setter Injection

@Service
public class ProductService {
    private ProductRepository repository;

    @Autowired
    public void setRepository(ProductRepository repository) {
        this.repository = repository;
    }
}

3. Field Injection (Not Recommended)

@Service
public class ProductService {
    @Autowired  // Makes testing difficult
    private ProductRepository repository;
}

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 Dependency 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