@Autowired | Dependency Injection & Beans Tutorial

Dependency Injection & Beans - `@Autowired`

Dependency Injection (DI) is a core principle in Spring that promotes loose coupling between components. Instead of a component creating its dependencies, those dependencies are provided to it. This makes your code more modular, testable, and maintainable. Beans are the objects that Spring manages – the components that are part of the Spring application context. @Autowired is the primary mechanism Spring uses to perform DI.

What is Dependency Injection?

Imagine building a car. You wouldn't manufacture the engine, tires, and steering wheel inside the car assembly line, right? You'd get them from specialized suppliers. DI is similar. Your components (like the car's body) don't create their dependencies (engine, tires, etc.); they receive them.

Benefits of Dependency Injection:

Loose Coupling: Components are less reliant on specific implementations of their dependencies.
Testability: Easily mock or stub dependencies for unit testing.
Maintainability: Changes to one component are less likely to ripple through the entire application.
Reusability: Components can be reused in different contexts with different dependencies.

Beans in Spring

In Spring, a bean is simply an object that is managed by the Spring IoC (Inversion of Control) container. Spring creates, configures, and destroys these beans. Beans are typically defined using annotations like @Component, @Service, @Repository, and @Controller. These are all specializations of @Component.

Example:

import org.springframework.stereotype.Component;

@Component
public class MessageService {

    public String getMessage() {
        return "Hello, Spring!";
    }
}

In this example, MessageService is a bean. Spring will automatically detect it because of the @Component annotation and manage its lifecycle.

`@Autowired` - The Magic of Dependency Injection

@Autowired is used to inject dependencies into a bean. Spring will automatically find a bean of the required type and inject it into the field, constructor, or setter method annotated with @Autowired.

Ways to use @Autowired:

Field Injection:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MyApplication {

    @Autowired
    private MessageService messageService;

    public void run() {
        System.out.println(messageService.getMessage());
    }
}

Explanation: Spring finds a bean of type MessageService and assigns it to the messageService field.
Pros: Simple and concise.
Cons: Can make testing harder (tightly coupled). Less clear dependency declaration.

Constructor Injection:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MyApplication {

    private final MessageService messageService;

    @Autowired
    public MyApplication(MessageService messageService) {
        this.messageService = messageService;
    }

    public void run() {
        System.out.println(messageService.getMessage());
    }
}

Explanation: Spring finds a bean of type MessageService and passes it to the constructor.
Pros: Encourages immutability (using final fields). Clear dependency declaration. Easier to test. Recommended approach.
Cons: Can be more verbose.

Setter Injection:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MyApplication {

    private MessageService messageService;

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

    public void run() {
        System.out.println(messageService.getMessage());
    }
}

Explanation: Spring finds a bean of type MessageService and calls the setMessageService setter method to inject it.
Pros: Flexible.
Cons: Less clear dependency declaration. Can lead to issues if the dependency is not set before use.

`@Autowired` and Multiple Beans

What happens if there are multiple beans of the same type? Spring needs a way to determine which bean to inject.

@Primary: Mark one of the beans as the primary candidate for injection.

import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;

@Component
@Primary
public class EnglishMessageService implements MessageService {
    @Override
    public String getMessage() {
        return "Hello, Spring! (English)";
    }
}

@Component
public class SpanishMessageService implements MessageService {
    @Override
    public String getMessage() {
        return "Hola, Spring! (Spanish)";
    }
}

In this case, EnglishMessageService will be injected by default.

@Qualifier: Specify the bean name to inject.

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

@Component
public class MyApplication {

    @Autowired
    @Qualifier("spanishMessageService") // Inject the bean named "spanishMessageService"
    private MessageService messageService;

    // ...
}

This explicitly tells Spring to inject the bean named "spanishMessageService". Note that the bean name is case-sensitive.

`@Autowired` and Optional Dependencies

Sometimes, a dependency might not always be required. You can make the injection optional using required = false.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MyApplication {

    @Autowired(required = false)
    private OptionalService optionalService;

    public void run() {
        if (optionalService != null) {
            optionalService.doSomething();
        } else {
            System.out.println("Optional service not available.");
        }
    }
}

If Spring cannot find a bean of type OptionalService, the optionalService field will be null.

Summary

@Autowired is a powerful tool for dependency injection in Spring. Understanding how to use it effectively is crucial for building well-structured, testable, and maintainable Spring applications. Constructor injection with final fields is generally the preferred approach for its clarity and benefits. Remember to handle cases where multiple beans of the same type exist using @Primary or @Qualifier.

Dependency Injection & Beans - @Autowired