Inversion of Control

Inversion of Control (IoC) is a design principle where the framework controls the flow of your application, rather than your code controlling it.

Traditional Control vs IoC

Traditional Control:
Your code → creates dependencies → uses dependencies
(Caller controls object creation)

Inversion of Control:
Framework → creates dependencies → injects into your code
(Framework controls object creation)

IoC in Spring

The Spring IoC container manages your objects (beans):

// You define beans
@Service
public class ProductService {
    private final ProductRepository repository;
    public ProductService(ProductRepository repository) {  // Container injects
        this.repository = repository;
    }
}

// Spring container creates and injects:
// 1. Creates ProductRepository (bean)
// 2. Creates ProductService (bean)
// 3. Injects ProductRepository into ProductService
// 4. Manages lifecycle (init, destroy)

ApplicationContext — The IoC Container

// Spring Boot automatically creates ApplicationContext
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        // SpringApplication creates and configures the IoC container
        ApplicationContext context = SpringApplication.run(Application.class, args);

        // You can access beans from the container
        ProductService productService = context.getBean(ProductService.class);
    }
}

IoC Container Responsibilities

1. Bean creation — instantiate objects
2. Dependency injection — wire dependencies together
3. Lifecycle management — call @PostConstruct, @PreDestroy
4. Scope management — singleton, prototype, request, session
5. AOP — apply cross-cutting concerns (logging, transactions)

Bean Scopes

Scope	Description
singleton	One instance per container (default)
prototype	New instance every time requested
request	One instance per HTTP request
session	One instance per user session

@Component
@Scope("prototype")
public class ShoppingCart {
    // New instance for each user
}

IoC vs DI

• IoC is the principle (inverting control of object creation)
• DI is a technique to achieve IoC (injecting dependencies)
• Spring IoC container uses DI to implement IoC

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 Inversion of Control 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