DI & IoC

 Dependency Injection & Inversion of Control

Inversion of Control (IoC)

IoC is a concept that reverses the control flow in a program. Usually, when we write code, we control how objects are created, and how they interact with each other. But with IoC, you let a framework or container take control of these things. This is like hiring a manager to handle the creation and interaction of the objects for you.

• Example in real life: Imagine you are at a restaurant. Normally, if you're cooking at home, you control how ingredients are selected and cooked. But when you go to a restaurant, the chef (IoC container) takes control and decides how your dish is prepared. You just ask for the dish (through a menu, which is like a request for an object), and the restaurant takes care of everything else.

Dependency Injection (DI)

DI is one way to implement IoC. In simple terms, it means that instead of creating objects directly inside a class, you get these objects from outside the class (like passing ingredients to the chef instead of letting the chef buy the ingredients themselves).

• Example in real life: Imagine you’re making coffee at home. You need ingredients like coffee beans, milk, and sugar. In regular code (without DI), you would go out and buy these ingredients yourself. But with DI, someone else (like your assistant or delivery service) provides you the ingredients directly, and you just focus on making coffee.

In code, this is how it might look:

• Without Dependency Injection (normal way):                                                                            

  

Here, the CoffeeMaker class is responsible for creating the CoffeeBeans object itself. This is tightly coupled, meaning if you want to change the type of beans or how they are made, you need to change the class.

• With Dependency Injection:                                                                                                            
  

Now, the CoffeeBeans object is provided from outside the CoffeeMaker class, so you can easily change the beans without modifying the class. This is more flexible and maintains loose coupling.

Key benefits of DI and IoC:

1. Loose Coupling: Classes are not tightly connected to each other, which makes code easier to maintain and modify.
2. Easier Testing: With DI, you can easily provide mock dependencies while testing.
3. Flexible and Reusable: You can change how objects are created without changing the logic inside your classes.

In Spring Boot, you often hear about IoC containers like Spring Framework that manage objects (beans) for you, injecting dependencies where needed. This makes your code simpler and more maintainable in larger applications.