Spring Dependency Injection with Example

Nadim Muhammad
Mar 01,2025 - 10:52

Dependency Injection (DI) is a design pattern in Spring that allows objects to be injected into other objects rather than being created inside them. This promotes loose coupling and makes the application more testable, maintainable, and modular.

Types of Dependency Injection in Spring

Spring provides two main types of Dependency Injection:

  1. Constructor Injection - Dependencies are provided through a class constructor.
  2. Setter Injection - Dependencies are provided through setter methods.

Dependency Injection is the main functionality provided by Spring IOC(Inversion of Control). The Spring-Core module is responsible for injecting dependencies through either Constructor or Setter methods. The design principle of Inversion of Control emphasizes keeping the Java classes independent of each other and the container frees them from object creation and maintenance. These classes, managed by Spring, must adhere to the standard definition of Java-Bean. Dependency Injection in Spring also ensures loose coupling between the classes.

 

Need for Dependency Injection:

Suppose class One needs the object of class Two to instantiate or operate a method, then class One is said to be dependent on class Two. Now though it might appear okay to depend on a module on the other, in the real world, this could lead to a lot of problems, including system failure. Hence such dependencies need to be avoided. Spring IOC resolves such dependencies with Dependency Injection, which makes the code easier to test and reuse .

Loose coupling between classes can be possible by defining interfaces for common functionality and the injector will instantiate the objects of required implementation. The task of instantiating objects is done by the container according to the configurations specified by the developer.

Example: Spring Dependency Injection

Let's create a simple example to demonstrate both Constructor and Setter Injection using Spring Boot.

1. Create a Spring Boot Project

If you're using Spring Boot, you can create a project using Spring Initializr with the following dependencies:

2. Implement Dependency Injection

Step 1: Create a Service Interface

package com.example.demo.service;

public interface MessageService {
    void sendMessage(String message);
}
 

Step 2: Implement the Service

 

package com.example.demo.service.impl;

import com.example.demo.service.MessageService;
import org.springframework.stereotype.Service;

@Service
public class EmailService implements MessageService {
    @Override
    public void sendMessage(String message) {
        System.out.println("Email sent: " + message);
    }
}
3. Constructor-Based Dependency Injection

Step 3: Inject Dependency via Constructor

package com.example.demo.controller;

import com.example.demo.service.MessageService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class NotificationController {

    private final MessageService messageService;

    // Constructor Injection
    @Autowired
    public NotificationController(MessageService messageService) {
        this.messageService = messageService;
    }

    public void notifyUser(String message) {
        messageService.sendMessage(message);
    }
}
4. Setter-Based Dependency Injection

Step 4: Inject Dependency via Setter

package com.example.demo.controller;

import com.example.demo.service.MessageService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class AlertController {

    private MessageService messageService;

    // Setter Injection
    @Autowired
    public void setMessageService(MessageService messageService) {
        this.messageService = messageService;
    }

    public void alertUser(String message) {
        messageService.sendMessage(message);
    }
}
 

5. Running the Application

Step 5: Test the Injection in main()

 

package com.example.demo;

import com.example.demo.controller.NotificationController;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    @Bean
    CommandLineRunner run(ApplicationContext context) {
        return args -> {
            NotificationController notificationController = context.getBean(NotificationController.class);
            notificationController.notifyUser("Hello, Dependency Injection!");
        };
    }
}
 

6. Output

Email sent: Hello, Dependency Injection!

Conclusion