Spring IoC & Dependency Injection

1. What is a Dependency?

A dependency exists when one class needs another class to perform its work.

class EmailService {

    public void sendEmail(String message) {
        System.out.println("Sending: " + message);
    }
}

class OrderService {

    private EmailService emailService;

    public void placeOrder() {
        emailService.sendEmail("Order placed");
    }
}

OrderService ---> EmailService

2. The Problem: Who Creates the Dependency?

A simple implementation may create the dependency inside the class.

class OrderService {

    private EmailService emailService = new EmailService();

    public void placeOrder() {
        emailService.sendEmail("Order placed");
    }
}

Now OrderService is responsible for creating and using EmailService.

If the implementation changes from EmailService to SMS or another notification mechanism, OrderService must also change.

3. What is Tight Coupling?

When a class directly creates and depends on a concrete implementation, the classes become tightly coupled.

class OrderService {

    private EmailService emailService =
            new EmailService();

    public void placeOrder() {
        emailService.sendEmail("Order placed");
    }
}

OrderService is tightly coupled to EmailService.

A common design principle is:

4. Better Design Using an Interface

public interface NotificationService {

    void sendNotification(String message);
}

Email Implementation

class EmailNotificationService
        implements NotificationService {

    @Override
    public void sendNotification(String message) {
        System.out.println(
            "Sending Email: " + message);
    }
}

SMS Implementation

class SmsNotificationService
        implements NotificationService {

    @Override
    public void sendNotification(String message) {
        System.out.println(
            "Sending SMS: " + message);
    }
}

Now the client can depend on the interface rather than a concrete implementation.

class OrderService {

    private NotificationService notificationService;

    public void placeOrder() {
        notificationService.sendNotification(
            "Order placed");
    }
}

5. Different Approaches for Managing Dependencies

6. Composition

Composition means one class contains or uses another object as a member.

class Engine {

    public void start() {
        System.out.println("Engine started");
    }
}

class Car {

    private Engine engine;

    public Car() {
        this.engine = new Engine();
    }

    public void drive() {
        engine.start();
        System.out.println("Car is running");
    }
}

This represents a HAS-A relationship.

Composition with Dependency Injection

class Car {

    private Engine engine;

    public Car(Engine engine) {
        this.engine = engine;
    }

    public void drive() {
        engine.start();
        System.out.println("Car is running");
    }
}

Engine engine = new Engine();
Car car = new Car(engine);

Now Car does not create Engine. The dependency is provided from outside.

7. Factory Pattern

A Factory centralizes object creation logic.

interface NotificationService {

    void send(String message);
}

class EmailNotificationService
        implements NotificationService {

    @Override
    public void send(String message) {
        System.out.println("Email: " + message);
    }
}

class SmsNotificationService
        implements NotificationService {

    @Override
    public void send(String message) {
        System.out.println("SMS: " + message);
    }
}

Factory

class NotificationFactory {

    public static NotificationService
        getService(String type) {

        if ("EMAIL".equalsIgnoreCase(type)) {
            return new EmailNotificationService();
        }

        if ("SMS".equalsIgnoreCase(type)) {
            return new SmsNotificationService();
        }

        throw new IllegalArgumentException(
            "Unknown notification type");
    }
}

Client

class OrderService {

    private NotificationService notificationService;

    public OrderService(String type) {
        this.notificationService =
            NotificationFactory.getService(type);
    }

    public void placeOrder() {
        notificationService.send("Order placed");
    }
}

The Factory hides object creation logic, but the client still knows about the Factory.

8. JNDI Registry

JNDI stands for Java Naming and Directory Interface.

It allows an application to look up resources from a naming registry.

Example

Context context = new InitialContext();

DataSource dataSource =
    (DataSource) context.lookup(
        "java:/comp/env/jdbc/MyDB");

The application asks the registry for a resource registered under a particular name.

9. Dependency Lookup / Pull Model

In Dependency Lookup, the object itself asks a container or registry for its dependency.

class OrderService {

    public void process() {

        NotificationService service =
            Container.getNotificationService();

        service.send("Order placed");
    }
}

This is called the Pull Model because the object pulls the dependency.

10. Dependency Injection / Push Model

In Dependency Injection, the class does not ask for its dependency. The dependency is provided to the class.

class OrderService {

    private NotificationService notificationService;

    public OrderService(
            NotificationService notificationService) {

        this.notificationService =
            notificationService;
    }

    public void placeOrder() {
        notificationService.send("Order placed");
    }
}

NotificationService notificationService =
    new EmailNotificationService();

OrderService orderService =
    new OrderService(notificationService);

The dependency is pushed into OrderService.

11. What is IoC?

IoC means Inversion of Control.

Normally, application code controls object creation:

OrderService service = new OrderService();

EmailService emailService =
    new EmailService();

Your code decides:

With Spring, control is transferred to the Spring IoC Container.

12. Spring IoC Container

The central concept in Spring Core is the IoC Container.

ApplicationContext is the commonly used container in Spring applications.

It manages Spring Beans.

A Spring Bean is simply an object that is created and managed by Spring.

@Component
public class EmailService {

    public void sendEmail(String message) {
        System.out.println(
            "Email sent: " + message);
    }
}

Spring detects the class and creates an object managed by the container.

13. Basic Spring IoC Example

Step 1: Interface

public interface NotificationService {

    void send(String message);
}

Step 2: Implementation

import org.springframework.stereotype.Component;

@Component
public class EmailNotificationService
        implements NotificationService {

    @Override
    public void send(String message) {
        System.out.println(
            "Email sent: " + message);
    }
}

@Component tells Spring to create and manage an object of this class.

Step 3: Client Class

import org.springframework.stereotype.Service;

@Service
public class OrderService {

    private final NotificationService notificationService;

    public OrderService(
            NotificationService notificationService) {

        this.notificationService =
            notificationService;
    }

    public void placeOrder() {

        System.out.println("Order placed");

        notificationService.send(
            "Order confirmation");
    }
}

14. What Happens During Spring Boot Startup?

@SpringBootApplication
public class Application {

    public static void main(String[] args) {

        SpringApplication.run(
            Application.class,
            args);
    }
}

Conceptually, Spring Boot performs these activities:

15. Constructor Injection

Constructor Injection is generally the preferred form of dependency injection for required dependencies.

@Service
public class OrderService {

    private final NotificationService notificationService;

    public OrderService(
            NotificationService notificationService) {

        this.notificationService =
            notificationService;
    }
}

With a single constructor, modern Spring can automatically use it without @Autowired.

You can also explicitly write:

@Autowired
public OrderService(
        NotificationService notificationService) {

    this.notificationService =
        notificationService;
}

Why Constructor Injection?

• Required dependencies are available during construction.
• Dependencies are clearly visible.
• Fields can be final.
• Easy to unit test.
• Reduces the possibility of creating an invalid object.

16. Setter Injection

In Setter Injection, Spring creates the object and then calls a setter method to provide the dependency.

@Service
public class OrderService {

    private NotificationService notificationService;

    @Autowired
    public void setNotificationService(
            NotificationService notificationService) {

        this.notificationService =
            notificationService;
    }
}

When is Setter Injection useful?

• Optional dependencies
• Configurable dependencies
• Dependencies that do not need to exist during construction

17. Field Injection

@Service
public class OrderService {

    @Autowired
    private NotificationService notificationService;

    public void placeOrder() {

        notificationService.send(
            "Order placed");
    }
}

Spring injects the dependency directly into the field, generally using reflection.

Advantages

• Very little code.
• Easy to write for simple examples.

Disadvantages

• Dependencies are hidden.
• Fields are generally not final.
• Unit testing without Spring is less convenient.
• It can encourage classes with too many hidden dependencies.

18. Constructor vs Setter vs Field Injection

19. Why Interfaces Are Important in DI

public interface NotificationService {

    void send(String message);
}

Possible implementations:

All implementations follow the same abstraction:

NotificationService

Therefore, OrderService can depend on the interface:

public OrderService(
        NotificationService notificationService) {

    this.notificationService =
        notificationService;
}

20. Multiple Implementations and @Qualifier

Suppose there are two implementations:

@Component("emailService")
public class EmailNotificationService
        implements NotificationService {
}

@Component("smsService")
public class SmsNotificationService
        implements NotificationService {
}

If we write:

public OrderService(
        NotificationService notificationService) {
}

Spring may not know which implementation should be injected.

Use @Qualifier:

@Service
public class OrderService {

    private final NotificationService notificationService;

    public OrderService(
            @Qualifier("emailService")
            NotificationService notificationService) {

        this.notificationService =
            notificationService;
    }
}

21. @Primary

If multiple implementations exist, one implementation can be marked as the default using @Primary.

@Component
@Primary
public class EmailNotificationService
        implements NotificationService {
}

Then Spring can inject it when the dependency type is:

NotificationService

without requiring a qualifier in every injection point.

22. What is a Spring Bean?

A Spring Bean is an object created, configured, and managed by the Spring IoC container.

@Component
public class EmailService {
}

Other common stereotype annotations include:

23. Using @Bean

Instead of annotating a class with @Component, we can explicitly configure a bean using @Bean.

@Configuration
public class AppConfig {

    @Bean
    public EmailService emailService() {

        return new EmailService();
    }
}

This is particularly useful for configuring third-party classes that you cannot modify to add @Component.

Example

@Configuration
public class AppConfig {

    @Bean
    public ObjectMapper objectMapper() {

        return new ObjectMapper();
    }
}

Spring can then inject ObjectMapper wherever it is required.

24. @Component vs @Bean

25. Composition vs Inheritance

Inheritance

class Vehicle {

    public void start() {
    }
}

class Car extends Vehicle {
}

Relationship:

Composition

class Car {

    private Engine engine;
}

Relationship:

For many application-design situations, composition is preferred when the relationship is genuinely "has-a", because it avoids unnecessary inheritance coupling.

26. Real-World Example: Payment System

PaymentGateway Interface

public interface PaymentGateway {

    void pay(double amount);
}

Implementation

@Component
public class StripePaymentGateway
        implements PaymentGateway {

    @Override
    public void pay(double amount) {

        System.out.println(
            "Payment using Stripe: " + amount);
    }
}

PaymentService

@Service
public class PaymentService {

    private final PaymentGateway paymentGateway;

    public PaymentService(
            PaymentGateway paymentGateway) {

        this.paymentGateway = paymentGateway;
    }

    public void processPayment(double amount) {

        paymentGateway.pay(amount);
    }
}

OrderService

@Service
public class OrderService {

    private final PaymentService paymentService;

    public OrderService(
            PaymentService paymentService) {

        this.paymentService = paymentService;
    }

    public void placeOrder(double amount) {

        paymentService.processPayment(amount);

        System.out.println(
            "Order placed successfully");
    }
}

Dependency Graph

None of these classes needs to manually create its dependency using new.

27. Dependency Injection and Unit Testing

One of the biggest advantages of DI is testability.

@Service
public class PaymentService {

    private final PaymentGateway paymentGateway;

    public PaymentService(
            PaymentGateway paymentGateway) {

        this.paymentGateway = paymentGateway;
    }

    public void processPayment(double amount) {

        paymentGateway.pay(amount);
    }
}

Production:

Testing:

Example:

PaymentGateway mockGateway =
    Mockito.mock(PaymentGateway.class);

PaymentService service =
    new PaymentService(mockGateway);

The test can execute PaymentService without contacting a real payment provider.

28. IoC vs DI

29. Pull vs Push Model

Pull — Dependency Lookup

class OrderService {

    public void process() {

        NotificationService service =
            container.getBean(
                NotificationService.class);

        service.send("Order placed");
    }
}

Push — Dependency Injection

class OrderService {

    private final NotificationService service;

    public OrderService(
            NotificationService service) {

        this.service = service;
    }
}

30. Typical Spring Boot Dependency Graph

Spring manages these objects and resolves the dependencies between them.

For example:

@RestController
public class OrderController {

    private final OrderService orderService;

    public OrderController(
            OrderService orderService) {

        this.orderService = orderService;
    }
}

@Service
public class OrderService {

    private final PaymentService paymentService;
    private final OrderRepository orderRepository;

    public OrderService(
            PaymentService paymentService,
            OrderRepository orderRepository) {

        this.paymentService = paymentService;
        this.orderRepository = orderRepository;
    }
}

31. Important Interview Answers

What is IoC?

What is Dependency Injection?

Dependency Lookup vs Dependency Injection?

Why is Constructor Injection preferred?

• It makes required dependencies explicit.
• It supports immutable fields.
• It makes objects easier to construct correctly.
• It simplifies unit testing.
• It avoids hidden dependencies.

32. Final Summary

The Most Important Comparison

Without IoC/DI

class OrderService {

    PaymentService paymentService =
        new PaymentService();
}

The class creates its dependency.

With IoC/DI

class OrderService {

    private final PaymentService paymentService;

    OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }
}

The dependency is provided to the class.

One-Sentence Definition

Easy Memory Trick