What Is Spring Boot- Examples And Types

Discover the power of `Autowired` in Spring Boot! Learn how this essential feature simplifies dependency injection and manages your development process. Read this article further to dive into practical examples and different types to enhance your Spring Boot applications.
authorImageVarun Saharawat30 Oct, 2025
What Is Spring Boot- Examples And Types

What is Autowired In Spring Boot

Autowired in Spring Boot is basically a special code that makes things connect automatically. In simple terms, we can say that It's like a helpful robot that knows which parts of our program should work together.  Let us understand the concept of Autowired in Spring Boot more clearly with a simple example: suppose we have a class for a car and another for an engine, Autowired will link them automatically without our involvement. Using Autowired in Spring Boot basically saves time and makes our code neater and easier to understand.

Key Takeaways

  • Learning about the Concept of Autowired in Spring Boot.
  • Understanding the types of injections used in Autowired in Spring Boot.
  • Understanding the advantages and disadvantages of all the dependency injections.
  • Learning the concept of Ambiguity during Autowired in Spring Boot and the method to resolve ambiguity. 

Basics of Autowired In Spring Boot

Autowired in Spring Boot is a way to automatically connect different parts of a program without manually specifying each connection. It helps save time and effort by letting the program figure out how things should be linked together. In spring boot, The “@Autowired” annotation is basically used to autowire the spring beans to other beans which means letting spring beans link with required beans without the involvement of Developers automatically. 

How Spring Boot Resolves Dependencies-

Spring helps in resolving dependencies in a program by automatically figuring out which part of the code needs to work together and also makes sure that they do. Let us understand the basic method used by Spring to auto wire things- So Spring generally uses three methods to match the expected types. Let us talk about each one of them in detail.
  1. By Type: This means if you have a class of a certain type, Spring Boot automatically finds and connects it to other parts of your program that need that type.
  2. By Qualifier: Qualifier is added to the bean when you have multiple classes or beans in a single program. Qualifiers in the Spring Boot helps individuals to be more specific about beans like where to use a specific bean.
  3. By Name: If qualifiers are not specified in your code, Spring automatically checks for any bean name that matches the name of the member value and if it happens it automatically matches both of them together.

Field Injection-

Field injection is a method of directly injecting dependencies into the class fields. This means that instead of injecting dependencies through constructor parameters, they are directly assigned to the class fields. Using field injection is not recommended as it has various drawbacks like, It makes dependencies less visible making the code and class more complex this often creates confusion for developers about which dependency to replace during testing. This is why unit testing is much harder to perform  using field injection.

Constructor Injection-

Constructor injection is the most preferable method of dependency injection used in Autowired in Spring Boot, where dependencies are provided to a class through its constructor parameters. In this method, the class dependencies are declared as constructor parameters, and the dependency injection framework of the class is responsible for providing these dependencies. Below is the example code given for your better understanding:
Constructor Injection in Spring Boot
public class UserService { private UserRepository userRepository; public UserService(UserRepository userRepository) { this.userRepository = userRepository;   } }
Here in the example above, UserService has a dependency on UserRepository, which is also passed to its constructor. This basically allows UserService to work with an instance of UserRepository.

Setter Method Injection-

Another method of dependency injection in Autowired in Spring Boot is Setter Method Injection. Here in this method dependencies are provided to a class through the setter method instead of passing dependencies to the constructor. This method is not so common nowadays as most of the developers prefer the Constructor method over this. Below is the example code for your better understanding of Setter Method injection:
Setter Method Injection In Spring Boot
public class UserService { private UserRepository userRepository; public UserService() {     }     public void setUserRepository(UserRepository userRepository) {     this.userRepository = userRepository;     } }

Using Autowired on Constructors-

As we have discussed above, the most commonly used dependency injection in the class is constructor-based. Let us talk about the basic advantages of Constructor Injection to understand why it is preferred by most of the developers.

Advantages of Constructor Injection:

  • Immutable Dependencies: Constructor-based Injection dependencies are basically immutable once set, this means they remain unchanged throughout the object's lifecycle. This leads to more predictable behavior and easier debugging.
  • Testability: Constructor-based injection makes unit testing easier by allowing dependencies to be mocked or replaced easily. This makes it easier to test different scenarios and ensures that tests are isolated and predictable.
  • Explicitness and Clarity: Constructor injection explicitly declares dependencies as constructor parameters, making it clear what dependencies a class requires. This makes code more readable and makes it easier for developers to understand the class dependencies.
Basic Example of Autowired Applied to a Constructor
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; @service public class MyService {     private final MyRepository repository;     @Autowired     public MyService(MyRepository repository) {         this.repository = repository;     }           public void doSomething() {        MyRepository.doSomething();     }

  Handling Multiple Dependencies on Constructor

While handling beans with multiple dependencies, constructor injection keeps everything clear and concise. Below is the example given for your reference.
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; @Component public class MyService {     private final MyRepository repository;     private final MyLogger logger;     @Autowired     public MyService(MyRepository repository, MyLogger logger) {         this.repository = repository;         this.logger = logger;     }                    public void doSomething() {        userRepository.doSomething();        orderRepository.placeOrder();     }

Using Autowired on Setter Methods

Using setter methods in Spring boot is another form of dependency injection known as setter injection. It allows for more flexibility in injecting dependencies compared to constructor injection, especially when dealing with optional dependencies or circular dependencies.  However, constructor injection is generally preferred for mandatory dependencies.

When to Use Setter Injection

Setter injection is often used in scenarios where you want to provide optional dependencies or have circular dependencies that cannot be resolved through constructor injection.  Below are some specific situations when setter injections are generally preferred:
  • Optional Dependencies: If a dependency is not mandatory for the functioning of a bean, you can use setter injection to make it optional. In this way, if the dependency is not available, the bean can still be created and used, and the dependency can be injected later if needed.
  • Circular Dependencies: Setter injection can help resolve circular dependencies between beans. Using setter injection, you can create the beans first and then inject the dependencies later which allows for circular references to be resolved.
  • Configuration Flexibility: Setter injection can provide more configuration flexibility compared to constructor injection, especially when dealing with beans that have a large number of dependencies.
Example of the Setter Method: Below is a common example of the setter method In Autowired Spring Boot for your better understanding.
Setter Method Example In Autowired Spring Boot
@Service public class SampleService {    private UserRepository userRepository;    @Autowired    public void setUserRepository(UserRepository userRepository) {        this.userRepository = userRepository;    }    public void doSomething() {        userRepository.doSomething();    } }

Handling Multiple Dependencies in the Setter Method

Handling Multiple Dependencies In Setter Method In Spring Boot
public class Person {     private String name;     private int age;     private Address address;     public Person() {         // Default constructor     }     // Setter method for the name     public void setName(String name) {         this.name = name;     }     // Setter method for the age     public void setAge(int age) {         this.age = age;     }     // Setter method for the address     public void setAddress(Address address) {         this.address = address;     }     public String getName() {         return name;     }     public int getAge() {         return age;     }     public Address getAddress() {         return address;     }     public static void main(String[] args) {         Person person = new Person();         person.setName("John Doe");         person.setAge(30);         Address address = new Address();         address.setStreet("123 Main St");         address.setCity("Anytown");         address.setZipCode("12345");         person.setAddress(address);         System.out.println("Name: " + person.getName());         System.out.println("Age: " + person.getAge());         System.out.println("Address: " + person.getAddress().getStreet() + ", " + person.getAddress().getCity() + ", " + person.getAddress().getZipCode());     } } class Address {     private String street;     private String city;     private String zipCode;     public Address() {         // Default constructor     }     public void setStreet(String street) {         this.street = street;     }     public void setCity(String city) {         this.city = city;     }     public void setZipCode(String zipCode) {         this.zipCode = zipCode;     }     public String getStreet() {         return street;     }     public String getCity() {         return city;     }     public String getZipCode() {         return zipCode;     } }
Pros of Using Setter Method:
  1. Flexibility: Setter methods allow you to set the values of object properties after object creation, this provides flexibility in initializing objects with different values.
  2. Encapsulation: By making fields private and providing setter methods, you encapsulate the internal state of an object. This helps in maintaining object integrity.
  3. Modification: If the internal implementation of a class changes, using setter methods allows you to modify the behavior of setting properties without affecting the external code that uses the class.
Cons Of Using Setter Method:
  1. Mutability: Setter methods in Autowired make objects mutable, meaning that their internal state can be changed after creation. This can lead to unexpected behavior if not used carefully, especially in multi-threaded environments.
  2. Completeness: While using the Setter Method, there is no guarantee that the bean is in a completely initialized state when constructed.

Ambiguity Problem in Spring Boot

The ambiguity problem in the context of Autowired in Spring boot typically refers to situations where the Spring's dependency injection mechanism cannot determine which bean to inject due to multiple beans being available. This ambiguity can arise for various reasons, such as having multiple beans of the same type or multiple beans matching the specified criteria.

Resolving Ambiguity Problem In Spring Boot

The ambiguity Problem in case of multiple beans can be resolved by using @qualifier annotations. This annotation allows you to specify the name of bean that has to be injected into the particular place. Below is an example of using Qualifier Annotation in the spring boot.
Suppose we have two beans of the same type “MyService” and we want to inject one of them into another bean “MyController” using @Qualifier annotation.
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.stereotype.Component; @Component("service1") public class MyService {     public void showMessage() {         System.out.println("Service 1 is running.");     } } @Component("service2") public class AnotherService {     public void showMessage() {         System.out.println("Service 2 is running.");     } } @Component public class MyController {     private final MyService myService;     @Autowired     public MyController(@Qualifier("service1") MyService myService) {         this.myService = myService;     }     public void displayMessage() {         myService.showMessage();     } }

How to Indicate Primary Beans In Spring Boot

In Spring Boot, you can indicate a primary bean by using the @Primary annotation. When multiple beans of the same type are available, We can mark one of them as @Primary bean which tells Spring to prioritize injecting the primary bean when no specific qualifier is provided.
@Component("car") @Primary public class Car implements Vehicle { }
With @Primary annotation in place, whenever there are multiple “Vehicle” beans, “Car” will be chosen as the default option to be injected.

Learn DSA Java With PW Skills

Welcome to an exciting journey into the world of Java programming! Our comprehensive Java with DSA Course is designed to equip you with the skills and knowledge needed to grow in today's tech-driven world. Whether you are a beginner or a working professional looking forward to starting your career as a Java Developer our course has got you covered. With a focus on hands-on learning, Working on real-world projects, and guidance from experienced tutors, You’ll gain all the skills that are required including Autowired in Spring boot. From mastering core Java concepts to building advanced applications, you'll have the opportunity to learn, practice, and grow by enrolling in this course.
Our Social Channels

Spring Boot FAQs

How does Autowired work in Spring Boot?

Autowired annotation in Spring Boot uses the dependency injection mechanism to inject beans into other beans. It searches for beans of the specified type in the application context and injects them into the target bean.

What are the different ways to use Autowired in Spring Boot?

Autowired can be used to inject dependencies by using constructor injection, setter injection, or field injection in Spring Boot. Constructor injection and setter injection are generally recommended over field injection as they give better code readability and testability.

What happens if Spring Boot finds multiple beans of the same type for @Autowired injection?

If Spring Boot finds multiple beans of the same type for @Autowired injection, it may result in ambiguity. To resolve this, we can use @Qualifier annotation along with @Primary annotation to indicate the primary bean.

What is Autowired in Spring Boot?

Autowired is an annotation in Spring Boot used for automatic dependency injection. It automatically wires beans into other beans based on their types, eliminating the need for manual bean wiring.