Spring IOC & DI Principles

Inversion of Control (IOC) is a design pattern and one of the core concepts of the Spring Framework. It primarily addresses issues regarding object dependencies and coupling, making code easier to maintain and extend.

In traditional development, objects manage their own dependencies; that is, objects actively create and manage other objects. This approach often results in high coupling between objects, where a change in one object necessitates modifications to all objects that depend on it, leading to high maintenance costs.

With IOC, the management of object dependencies is delegated to the container. Objects simply declare their required dependencies without actively creating or managing them. When the container creates an object, it automatically injects the dependent objects into it. This reduces coupling between objects and makes code easier to maintain and extend.

The Spring Framework implements IOC through Dependency Injection (DI), injecting dependent objects via constructors, setter methods, or fields. Developers can define Bean objects and their dependencies using XML configuration files, Java annotations, or Java code. The Spring container automatically creates and manages Bean objects based on this configuration information.

Using IOC offers the following benefits:

1. Reduces coupling between objects, making code easier to maintain and extend.
2. Enhances code readability and maintainability, making it easier to understand and modify.
3. Improves testability; developers can more easily perform unit testing and integration testing on the code.
4. Supports AOP implementation, enabling developers to conveniently implement features such as transaction control and logging.

// Example demonstrating Constructor Injection
public class UserService {
    private final UserRepository userRepository;

    // Constructor injection: dependency is provided by the container
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public void createUser() {
        // Business logic implementation
    }
}

// Example demonstrating Setter Injection
public class OrderService {
    private PaymentGateway paymentGateway;

    // Setter injection: dependency is injected via a setter method
    public void setPaymentGateway(PaymentGateway paymentGateway) {
        this.paymentGateway = paymentGateway;
    }

    public void processOrder() {
        if (paymentGateway != null) {
            // Business logic implementation
        }
    }
}