Arul .A

Posted on Jun 14

Dependency Injection in Spring Boot?

#springboot #dependencyinversion #webdev

Introduction

Spring Boot is one of the most popular frameworks for building Java applications. One of its most powerful features is Dependency Injection (DI), which helps developers create flexible, maintainable, and scalable applications.

Dependency Injection allows Spring Boot to manage the creation and injection of objects automatically, reducing manual coding and improving application design.

What is Dependency Injection?

Dependency Injection is a design pattern where an object's dependencies are provided by an external source rather than being created inside the object itself.

A dependency is simply an object that another object needs to perform its work.

Without Dependency Injection

public class UserService {

    private UserRepository userRepository = new UserRepository();

}

In this example, UserService creates its own UserRepository object. This creates tight coupling between the two classes.

With Dependency Injection

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

}

Here, Spring Boot automatically creates and injects the UserRepository object into UserService.

Why is Dependency Injection Important?

Dependency Injection provides several benefits:

Reduces tight coupling between classes
Improves code maintainability
Makes unit testing easier
Encourages reusable components
Simplifies object management

These advantages make applications more scalable and easier to maintain over time.

Understanding Spring Beans

A Spring Bean is an object managed by the Spring IoC (Inversion of Control) Container.

Spring automatically creates beans for classes annotated with:

@Component
@Service
@Repository
@Controller
@RestController

The Spring Container is responsible for creating, configuring, and managing these beans throughout the application's lifecycle.

Common Annotations Used in Dependency Injection

@Component

The @Component annotation tells Spring that a class should be managed as a bean.

@Component
public class EmailService {

    public void sendEmail() {
        System.out.println("Email Sent");
    }
}

@Service

The @Service annotation is used for classes that contain business logic.

@Service
public class UserService {

    public String getUserDetails() {
        return "User Details";
    }
}

@Repository

The @Repository annotation is used for database-related operations.

@Repository
public class UserRepository {

    public String findUser() {
        return "Arul";
    }
}

@Autowired

The @Autowired annotation tells Spring to inject a required dependency automatically.

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public String getUser() {
        return userRepository.findUser();
    }
}

Constructor Injection (Recommended)

Constructor Injection is considered the best practice in modern Spring Boot applications.

@Service
public class UserService {

    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public String getUser() {
        return userRepository.findUser();
    }
}

Benefits of Constructor Injection

Better testability
Improved readability
Supports immutability
Clearly defines required dependencies

How Dependency Injection Works

The Spring Framework follows these steps:

Spring Boot starts the application.
Component scanning identifies annotated classes.
Spring creates bean instances.
Dependencies are detected.
Required beans are injected automatically.
The application becomes ready to handle requests.

This entire process is managed by the Spring IoC Container.

Real-World Example

Consider an Employee Management System.

Repository Layer

@Repository
public class EmployeeRepository {

    public String getEmployee() {
        return "Arul";
    }
}

Service Layer

@Service
public class EmployeeService {

    private final EmployeeRepository employeeRepository;

    public EmployeeService(EmployeeRepository employeeRepository) {
        this.employeeRepository = employeeRepository;
    }

    public String fetchEmployee() {
        return employeeRepository.getEmployee();
    }
}

Controller Layer

@RestController
@RequestMapping("/employee")
public class EmployeeController {

    private final EmployeeService employeeService;

    public EmployeeController(EmployeeService employeeService) {
        this.employeeService = employeeService;
    }

    @GetMapping
    public String getEmployee() {
        return employeeService.fetchEmployee();
    }
}

Request Flow

Client Request → Controller → Service → Repository → Database

Spring automatically injects the required dependencies at each layer.

DEV Community