In which scenarios to use Static DI vs Dynamic DI ?

In Dynamic DI, dependencies are resolved at runtime, allowing more flexibility in how dependencies are injected. The DI container is responsible for resolving and injecting dependencies when an object is needed, and the dependencies can change based on the environment or configuration at runtime.

How Dynamic DI Works:

• Dependencies are resolved dynamically at runtime, meaning you can inject different dependencies based on conditions, configuration files, or environment variables.
• The DI container manages the lifecycle of objects and can inject different services depending on various factors at runtime.

Use Case:

• Flexible components where the dependencies may vary during runtime.
• Applications where configuration, environment, or user input can affect what dependencies need to be injected.

Real-time Scenario for Dynamic DI:

Imagine a logging framework where you want to use different logging strategies based on the environment (e.g., development, production).

class Logger {
    private final LogStrategy logStrategy;

    public Logger(LogStrategy logStrategy) {
        this.logStrategy = logStrategy;
    }

    public void log(String message) {
        logStrategy.logMessage(message);
    }
}

The Logger class can inject different logging strategies dynamically:

• For development: Log to the console.
• For production: Log to a file or a cloud service.

The LogStrategy can be dynamically chosen based on the environment or configuration at runtime:

class LogStrategyFactory {
    public static LogStrategy getLogStrategy(String environment) {
        if (environment.equals("development")) {
            return new ConsoleLogStrategy();
        } else {
            return new FileLogStrategy();
        }
    }
}

the LogStrategy dependency is injected dynamically based on the environment, allowing for flexibility.

In Static DI, dependencies are resolved and injected at compile time, meaning the container or framework knows about the dependencies at the time the application is compiled. The DI container predefines which services and objects should be injected into the class at the time of class instantiation.

How Static DI Works:

• The dependencies are injected by the DI container before the object is created.
• The relationships between classes and dependencies are predefined in configuration files or annotations.

Use Case:

• Tightly coupled components where the dependencies do not change during runtime.
• When the class dependencies are known ahead of time and are unlikely to change, making the system less flexible but more performant.

Real-time Scenario for Static DI:

Consider a payment processing system for an e-commerce platform. The system uses static DI to inject a payment service into a PaymentController.

class PaymentController {
    private final PaymentService paymentService;

    public PaymentController(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void processPayment() {
        paymentService.process();
    }
}

Here, PaymentService is injected at the time the PaymentController is instantiated (via static DI) and is pre-defined. The payment method (e.g., credit card, PayPal) remains fixed during the runtime, so static DI is a good fit.