How can dependency injection be applied using Spring…

The Spring IoC container manages the lifecycle of Spring Beans (objects). Beans are the main building blocks of Spring applications. Dependency Injection (DI) using Spring Beans is implemented through configuration that instructs the container on how to create and wire components.

There are three main ways to inject dependencies in Spring:

Constructor Injection: Spring calls the class constructor when creating a Bean. This is the preferred method as it guarantees that all necessary dependencies are initialized upon object creation and allows dependencies to be immutable.
Setter Injection: Spring calls setter methods of the class to set dependencies after the Bean is created. This method is useful for optional dependencies.
Field Injection: Spring uses reflection to directly inject dependencies into class fields. This is not recommended as it makes testing difficult and breaks encapsulation.

Configuration for dependency injection can be done using:

Annotations: @Autowired, @Qualifier, @Value. The most common approach in modern Spring applications.

// Example of constructor injection with annotation
@Component // Make the class a Spring Bean
public class MyService {

    private final MyDependency dependency;

    @Autowired // Instruct Spring to inject dependency via constructor
    public MyService(MyDependency dependency) {
        this.dependency = dependency;
    }

    // ...
}

@Component
public class MyDependency {
    // ...
}

// Example of setter injection with annotation
@Component
public class AnotherService {

    private AnotherDependency dependency;

    @Autowired // Instruct Spring to inject dependency via setter
    public void setDependency(AnotherDependency dependency) {
        this.dependency = dependency;
    }

    // ...
}

@Component
public class AnotherDependency {
    // ...
}

// Example of field injection with annotation (not recommended)
@Component
public class FieldInjectedService {

    @Autowired // Instruct Spring to inject dependency into field
    private FinalDependency dependency;

    // ...
}

@Component
public class FinalDependency {
    // ...
}

XML Configuration: Used in older or specific projects.

<!-- Example of constructor injection in XML -->
<beans>
    <bean id="myDependency" class="com.example.MyDependency"/>

    <bean id="myService" class="com.example.MyService">
        <constructor-arg ref="myDependency"/>
    </bean>
</beans>

<!-- Example of setter injection in XML -->
<beans>
    <bean id="anotherDependency" class="com.example.AnotherDependency"/>

    <bean id="anotherService" class="com.example.AnotherService">
        <property name="dependency" ref="anotherDependency"/>
    </bean>
</beans>

Java Configuration (@Configuration and @Bean): Modern approach allowing configuration of the Spring container via Java code.

// Example of Java configuration
@Configuration // Indicate this is a configuration class
public class AppConfig {

    @Bean // Declare Bean myDependency
    public MyDependency myDependency() {
        return new MyDependency();
    }

    @Bean // Declare Bean myService
    public MyService myService(MyDependency myDependency) {
        // Constructor injection when creating Bean
        return new MyService(myDependency);
    }
}

The Spring IoC container scans the configuration (annotations, XML, Java classes), creates Bean instances, manages their lifecycle, and automatically injects dependencies. This reduces component coupling, facilitates testing (dependencies can be easily replaced with mock objects), and makes the code more maintainable.

How can dependency injection be applied using Spring Bean?