What is Inversion of Control (IoC)?

• IoC is a "Design Principle" in which the control of object creation and management is transferred from the application code to a container or framework.
• In traditional programming, the application is responsible for creating and managing its dependencies (objects). With IoC, the framework controls the creation, lifecycle, and dependencies of objects, promoting loose coupling between components.

Use of Inversion of Control (IoC)

1. Simplifies Code :

• IoC removes the need to manually create and manage objects, as the container takes care of object instantiation and management.

2. Loose Coupling :

• It reduces dependencies between components, ensuring different parts of the application can work independently and be easily modified or tested without impacting others.

3. Dependency Injection :

• The IoC container injects dependencies into objects, eliminating the need for hardcoding and simplifying code by avoiding manual lookups.

4. Configuration Flexibility :

• IoC supports flexible configuration using XML, annotations, or Java-based setup, making it easy to adapt to various application needs.

5. Centralized Lifecycle Management :

• The container manages the entire lifecycle of objects, handling creation, initialization, and destruction, so developers don’t need to manage them manually.

6. Improved Testing :

• IoC makes it easy to swap objects with mocks during testing, allowing components to be tested in isolation without modifying the main code.

7. Code Reusability :

• It promotes reusability by keeping business logic separate from dependency management, ensuring components can be reused across different parts of the application.

Principles of Inversion of Control (IoC)

• The principles of Inversion of Control (IoC) focus on transferring the responsibility of managing object creation and dependencies from the program's logic to an external container.

1. Dependency Injection (DI) :

• Objects (or classes) receive their dependencies from an external source rather than creating them internally.
• Promotes loose coupling between components.

2. Dependency Lookup / Service Locator :

• The container provides access to required dependencies on demand (less commonly used than DI).

3. Inversion of Responsibility :

• Instead of classes controlling their dependencies, the IoC container manages this control, creating and injecting objects where needed.

4. Configuration over Code :

• Dependencies and object behaviors are defined in configuration files or annotations, reducing hard-coded dependencies.

5. Lifecycle Management :

• The IoC container manages the lifecycle of objects, such as creation, initialization, and destruction, allowing the developer to focus on business logic.

NOTE : These principles help promote modularity, testability, and maintainability by decoupling components in an application.

IoC Container

• IoC Container is a container that implements the Inversion of Control principle (explained above).
• It manages the creation, configuration, and lifecycle of objects (beans) while handling their dependencies through techniques like Dependency Injection (DI).

• NOTE : IoC Container is not tied to any specific framework or technology. Different frameworks can implement IoC principles in various ways.

• Some examples of IoC Container are :-
  1. Spring Container
  2. Google Guice
  3. PicoContainer
  4. Dagger