Inversion of Control vs Dependency Injection

  Inversion of Control (IoC) : IoC or Dependency Inversion Principle (DIP) is one of the SOLID principles of object-oriented programming. It is a design guideline that promotes the creation of flexible and maintainable software by inverting the direction of dependency relationships. The Dependency Inversion Principle consists of two key concepts: High-level modules should not depend on low-level modules. Both should depend on abstractions. Abstractions should not depend on details. Details should depend on abstractions.

Here's a breakdown of the key concepts:

  1. High-level modules and Low-level modules:

    • High-level modules are modules or components that define the main functionality or business logic of an application. Low-level modules are the implementation details or components that support the high-level modules.

  2. Depend on Abstractions:

    • Instead of high-level modules depending directly on low-level modules, both should depend on abstractions (interfaces or abstract classes). This promotes a more flexible and interchangeable system.

  3. Abstractions should not depend on details:

    • Abstractions (interfaces or abstract classes) should define the contract or API without depending on specific implementations or details. This allows for multiple implementations to coexist without affecting the high-level modules.

Example without Dependency Inversion:

public class LightBulb { public void turnOn() { // Implementation details to turn on the light bulb } } public class Switch { private LightBulb bulb; public Switch() { this.bulb = new LightBulb(); // Dependency on a specific implementation } public void operate() { bulb.turnOn(); } }



In this example, the Switch class directly depends on the LightBulb class, violating the Dependency Inversion Principle.

Example with Dependency Inversion:

public interface Switchable { void turnOn(); } public class LightBulb implements Switchable { @Override public void turnOn() { // Implementation details to turn on the light bulb } } public class Switch { private Switchable device; public Switch(Switchable device) { this.device = device; // Dependency on abstraction (Switchable interface) } public void operate() { device.turnOn(); } }



In this improved example, the Switch class depends on the abstraction (Switchable interface) instead of a specific implementation (LightBulb). This adheres to the Dependency Inversion Principle, making the system more flexible and allowing different implementations of Switchable to be used without modifying the Switch class.


Dependency Injection (DI): DI is a specific pattern that implements IoC. In DI, the dependencies of a class are injected into it rather than the class creating its dependencies. This is typically achieved through constructor injection, setter injection, or field injection. Spring IoC container manages the dependencies of objects and injects them when creating the objects. This reduces the tight coupling between classes and makes the code more testable and maintainable.

Comments

Post a Comment

Popular posts from this blog

Transform values with a stream

The goal is to transform an array of numbers into a comma-delimited string using functional programming. The code snippet you provided has a minor issue: String.join(",", strings[0]) is incorrect because it tries to join a single element ( strings[0] ) rather than all elements in the strings array. Here's the corrected code for the transformValues method: import java.util.Arrays; class Answer {     // Change these boolean values to control whether you see      // the expected answer and/or hints.     static boolean showExpectedResult = true;     static boolean showHints = true;     // Transform an array of numbers into a comma-delimited list     // using functional programming.     static String transformValues(int[] numbers) {         // Convert the int array to a stream of integers         // Map each integer to its String representation         // ...
Read more

Collections Framework

 The Java Collections Framework provides a comprehensive set of interfaces, implementations, and algorithms to work with collections of objects in Java. It offers a unified architecture for representing and manipulating collections, making it easier to work with data structures in Java programs. The Collections Framework is a fundamental part of Java programming and is widely used in various applications ranging from simple data manipulation tasks to complex algorithms and data processing pipelines.  Key components of the Collections Framework: Interfaces Collection : The root interface of the Collections Framework hierarchy. Represents a group of objects, known as elements. Subinterfaces include List , Set , and Queue . List : Represents an ordered collection of elements where duplicate elements are allowed. Allows elements to be accessed and inserted by index. Implementations include ArrayList , LinkedList , and Vector . Set : Represents a collection of unique elements ...
Read more

Inspect a collection

Calculate the cart total  import java.util.List; import java.util.concurrent.atomic.AtomicReference; public class Main {     public static void main(String[] args) {         List<Item> items = List.of(             new Item("Item1", 10.0f, 2),             new Item("Item2", 5.0f, 4),             new Item("Item3", 20.0f, 1)         );         float total = getCartTotal(items);         System.out.println("Cart Total: " + total);  // Output: Cart Total: 60.0     }     static float getCartTotal(List<Item> items) {         AtomicReference<Float> total = new AtomicReference<>(0.0f);         items.forEach(item -> {             total.updateAndGet(v -> v + item.getQuantity() * item.getPrice())...
Read more