Real-World Scenario

Business requirement:

An order processing service sends notifications using:

● Email service in production
● Mock service in test environments
● External messaging service in future

If your service directly does:

new EmailNotificationService();

You must modify production code every time implementation changes.

Dependency Injection solves this by:

● Injecting dependency from outside
● Allowing implementation to change without modifying core logic

What Is Dependency Injection?

Dependency Injection means:

Instead of a class creating its own dependencies,
dependencies are provided to it from outside.

This allows:

● Swapping implementations
● Easier unit testing
● Better separation of concerns

Common injection types:

● Constructor Injection
● Setter Injection

Both are possible in Apex.

Demo: Notification Service with Dependency Injection

◆ Step 1 – Common Interface

public interface NotificationService {
    void send(String message);
}

◆ Step 2 – Implementations

Email Notification

public class EmailNotificationService implements NotificationService {
    public void send(String message) {
        System.debug('Email sent: ' + message);
    }
}

Mock Notification

public class MockNotificationService implements NotificationService {
    public void send(String message) {
        System.debug('Mock send: ' + message);
    }
}

◆ Step 3 – Business Service Using Constructor Injection

public class OrderService {

    private NotificationService notifier;

    public OrderService(NotificationService notifier) {
        this.notifier = notifier;
    }

    public void processOrder() {
        // order logic
        notifier.send('Order processed');
    }
}

OrderService does not know which implementation is used.

◆ Step 4 – Production Usage

OrderService service = new OrderService(new EmailNotificationService());
service.processOrder();

◆ Step 5 – Test Usage

@IsTest
private class OrderServiceTest {

    @IsTest
    static void testOrderProcessing() {

        OrderService service = new OrderService(new MockNotificationService());
        Test.startTest();
        service.processOrder();
        Test.stopTest();

        System.assert(true);
    }
}

No production code changes required for testing.

Setter Injection (Alternative Approach)

Useful when dependency must be optional or changeable.

public class PaymentService {

    private PaymentGateway gateway;

    public void setGateway(PaymentGateway gateway) {
        this.gateway = gateway;
    }

    public void executePayment() {
        gateway.process();
    }
}

Combining DI with Factory Pattern

In real systems, factories and DI work together:

Factory decides implementation → DI injects it into service.

NotificationService notifier = NotificationFactory.getService();
OrderService service = new OrderService(notifier);

This keeps:

● Creation logic centralized
● Business logic decoupled

Why DI Matters in Apex

Benefits:

● Easier testing
● Clean separation of concerns
● Reduced code modification for changes
● Supports strategy and factory patterns
● Improves long-term maintainability

DI is essential for building extensible enterprise systems.

Best Practices

● Use interfaces for injected dependencies
● Prefer constructor injection for required services
● Avoid static dependencies in business logic
● Keep injection logic in service entry points
● Combine with Service & Selector layers

Even simple DI greatly improves code quality in Apex.

Conclusion

In this blog, you learned how to apply Dependency Injection in Apex without using any external frameworks.

Dependency Injection is a key building block of scalable and testable Apex systems.

Design for flexibility, and your code will grow with your business. 🚀

Apex Beginner to Advance

Dependency Injection in Apex