Spring Boot Field Injection Example

In this tutorial, we will learn how to use field-based dependency injection in the Spring boot application.

Dependency Injection is a design pattern on which dependency of the object is injected by the framework rather than created by the Object itself - It is also called IOC (Inversion of Control).

Dependency Injection reduces coupling between multiple objects as its dynamically injected by the framework. Spring IoC Container uses DI to inject one object into another object.

There are mainly three types of Dependency Injection:

1. Constructor Injection
2. Setter Injection
3. Field Injection

In this tutorial, we will see step by step how to use field-based dependency injection in the Spring boot application.

Field Injection

As the name says, the dependency is injected directly into the field, with no constructor or setter needed. This is done by annotating the class member with the @Autowired annotation.

Spring container uses reflection to inject the dependencies, which is costlier than constructor-based or setter-based injection.

Field Injection Example

In order to demonstrate the usage of field injection, let's create a few interfaces and classes.

MessageService

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

EmailService

    import org.springframework.stereotype.Component;

    @Component
    public class EmailService implements MessageService{
    
        @Override
        public void sendMessage(String message){
            System.out.println(message);
        }
    }

We have annotated EmailService class with @Component annotation so the Spring container automatically creates a Spring bean and manages its life cycle.

SMSService

    import org.springframework.stereotype.Component;

    @Component("smsService")
    public class SMSService implements MessageService{
    
        @Override
        public void sendMessage(String message){
            System.out.println(message);
        }
    }
    

We have annotated SMSService class with @Component annotation so the Spring container automatically creates a Spring bean and manages its life cycle.

MessageSender

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

@Component
public class MessageSender {

    @Autowired
    @Qualifier("emailService")
    private MessageService messageService;

    @Autowired
    private MessageService smsService;

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

@Qualifier annotation is used in conjunction with Autowired to avoid confusion when we have two or more beans configured for the same type.

Spring @Autowired annotation is used for the automatic injection of beans.

Spring container uses the below fields to inject dependency on any Spring-managed bean (MessageSender is a Spring bean):

    @Autowired
    @Qualifier("emailService")
    private MessageService messageService;

    @Autowired
    private MessageService smsService;

            

AppConfig

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages = "com.spring.core.di")
public class AppConfig {
}
            

@Configuration: Used to indicate that a configuration class declares one or more @Bean methods. These classes are processed by the Spring container to generate bean definitions and service requests for those beans at runtime.

@ComponentScan: This annotation is used to specify the base packages to scan for spring beans/components.

Testing

Let's create ApplicationContext and test this example:

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Client {

    public static void main(String[] args) {

        String message = "Hi, good morning have a nice day!.";
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);

        MessageSender messageSender = applicationContext.getBean(MessageSender.class);
        messageSender.sendMessage(message);
    }
}

Output:

Conclusion

In this tutorial, we saw how to use field-based dependency injection in the Spring boot application.

In the next tutorial, learn about Using Setter Injection in Spring Boot Application.