What is Inversion of Control (IoC)

In software design the concept of Inversion of Control (IoC) involves changing how control flows within a system. When discussing Java and Spring Boot IoC is closely linked with Dependency Injection (DI). The main idea is to hand over control of execution flow, to a container that handles the creation and insertion of dependencies.

Within the Spring Framework IoC is implemented through a container known as the Spring IoC container. This container oversees the lifecycle of Java objects manages dependency creation and insertion and handles application configuration.

Here’s a simple breakdown of concepts related to IoC, in Spring Boot;

Beans; These are components managed by the Spring IoC container that form the foundation of your application.
Dependency Injection (DI); A fundamental aspect of IoC where dependencies needed by a bean are inserted into it by the Spring IoC container. This promotes coupling between components enhancing code modularity and maintenance ease.
Container; The Spring IoC container takes charge of managing beans and their dependencies.
The software reads the setup details (often described in XML or annotations). Utilizes them to form and connect the components.

Configuration Metadata; In Spring you can define how beans and their connections are set up either through XML files or annotations, within Java code.

In a Spring Boot program, Inversion of Control (IoC) plays a role. Spring Boot streamlines the setup by offering defaults and automatic configuration enabling developers to concentrate on writing code instead of repetitive setup instructions.

Here’s a simple example using Spring Boot annotations:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class MyService {
    private final MyRepository repository;

    @Autowired
    public MyService(MyRepository repository) {
        this.repository = repository;
    }

    // Business logic using repository
}

In this scenario, MyService relies on MyRepository. The connection is established through the constructor with the @Autowired annotation. The Spring IoC container handles the creation and integration of the MyRepository component while generating the MyService component.