What is an Inversion of Control (IoC) container in Spring and how does it work?

Inversion of Control (IoC) container in Spring is the main component of the framework. It manages the lifecycle of Java objects (called Spring Beans), their configuration, and dependencies. Instead of objects creating and seeking their dependencies themselves (traditional approach with new and Service Locator), the IoC container "inverts" control: it creates objects, configures them, and "injects" the necessary dependencies.

Main responsibilities of the IoC container:

• Object creation (Instantiation): The container creates instances of Spring Beans based on their definitions (XML, annotations, or JavaConfig).
• Object configuration (Configuration): The container configures the properties of these objects based on the provided configuration.
• Dependency management: The container resolves dependencies between objects and injects them into the appropriate beans. This can be done via constructor (Constructor Injection), setter (Setter Injection), or field (Field Injection).
• Lifecycle management: The container manages the lifecycle of beans from creation to destruction.

The principle of "inversion of control" means that the program's execution flow is managed by the IoC container, not directly by application components. Spring offers two main implementations of the IoC container:

1. BeanFactory: A simple container providing basic functionality. Usually used for lazy initialization of beans.
2. ApplicationContext: An extension of BeanFactory that adds many features such as support for internationalization, events, resource loading, web applications, and more advanced lifecycle management. ApplicationContext is the preferred implementation in most cases.

How it works in general:

1. The process begins with loading the configuration (e.g., XML file, scanning packages with annotations @Component, @Service, etc., or JavaConfig classes). This configuration describes which objects are beans, how to create them, and what dependencies they have.
2. The IoC container parses the configuration and creates "bean definitions," which are metadata for creating and configuring beans.
3. When the application requires a bean, the container looks up its definition, creates an instance of the class, configures its properties, and injects dependencies.
4. The container manages these beans, providing them upon request and managing their lifecycle.

Example XML configuration for a MyService bean with a dependency on MyRepository:

<!-- beans.xml -->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="myRepository" class="com.example.MyRepository"/>

    <bean id="myService" class="com.example.MyService">
        <!-- Injecting dependency myRepository into myService -->
        <constructor-arg ref="myRepository"/>
    </bean>

</beans>

JavaConfig example:

// AppConfig.java
@Configuration
public class AppConfig {

    @Bean
    public MyRepository myRepository() {
        return new MyRepository();
    }

    @Bean
    public MyService myService(MyRepository myRepository) {
        // Injecting dependency myRepository via constructor
        return new MyService(myRepository);
    }
}

Annotation-based example:

// MyRepository.java
@Repository
public class MyRepository {
    // ...
}

// MyService.java
@Service
public class MyService {

    private final MyRepository myRepository;

    // Injecting dependency via constructor (preferred)
    @Autowired
    public MyService(MyRepository myRepository) {
        this.myRepository = myRepository;
    }

    // Or via field (not recommended, but works)
    // @Autowired
    // private MyRepository myRepository;

    // ...
}

// MainApp.java
public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        // Or: ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        MyService service = context.getBean(MyService.class);
        // Use the service created and configured by the container
        service.doSomething();
    }
}