@Autowired for dependency injection in Spring Boot

Introduction

@Autowired helps your Spring Boot app automatically connect parts that depend on each other, so you don't have to create or manage them manually.

When you want Spring to provide an object your class needs without creating it yourself.

When you have a service class that needs to use a repository class.

When you want to keep your code clean and easy to test by letting Spring handle object creation.

When you want to avoid writing boilerplate code to create and pass dependencies.

When you want to easily swap implementations without changing the dependent class.

Syntax

Spring Boot

@Autowired
private SomeDependency someDependency;

Place @Autowired above a field, constructor, or setter method to tell Spring to inject the needed object.

Spring looks for a matching bean (object) by type and injects it automatically.

Examples

Injects UserService into the current class automatically.

Spring Boot

@Autowired
private UserService userService;

Constructor injection: Spring injects UserService when creating MyController.

Spring Boot

private final UserService userService;

@Autowired
public MyController(UserService userService) {
    this.userService = userService;
}

Setter injection: Spring calls this method to inject UserService.

Spring Boot

private UserService userService;

@Autowired
public void setUserService(UserService userService) {
    this.userService = userService;
}

Sample Program

This Spring Boot app has two components: MessageService and MessagePrinter. MessagePrinter uses @Autowired to get MessageService automatically. When the app runs, it prints the message from MessageService.

Spring Boot

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@Component
class MessageService {
    public String getMessage() {
        return "Hello from MessageService!";
    }
}

@Component
class MessagePrinter {
    @Autowired
    private MessageService messageService;

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

@SpringBootApplication
public class DemoApplication implements CommandLineRunner {

    @Autowired
    private MessagePrinter printer;

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        printer.printMessage();
    }
}

Important Notes

If Spring finds more than one matching bean, it will throw an error unless you specify which one to use.

Using constructor injection is recommended for better testability and immutability.

@Autowired works only on Spring-managed beans (classes annotated with @Component, @Service, @Repository, etc.).

Summary

@Autowired automatically connects dependent parts in Spring Boot.

You can use it on fields, constructors, or setters.

It helps keep your code clean and easy to maintain.

Practice

1. What is the main purpose of the @Autowired annotation in Spring Boot?

easy

A. To create a new thread

B. To define a REST endpoint

C. To configure database connections

D. To automatically inject dependencies into a class

Solution

1. Step 1: Understand the role of @Autowired and identify the correct purpose

   @Autowired is used to automatically provide the needed objects (dependencies) to a class without manual creation. It helps Spring Boot inject required components, making code cleaner and easier to maintain.

2. Final Answer:

   To automatically inject dependencies into a class -> Option D

3. Quick Check:

   @Autowired = automatic dependency injection [OK]

Hint: Remember: @Autowired links needed parts automatically [OK]

Common Mistakes:

• Confusing @Autowired with REST endpoint annotations
• Thinking @Autowired manages database setup
• Assuming @Autowired creates new threads

2. Which of the following is the correct way to use @Autowired for field injection in a Spring Boot class?

easy

A. private Service service @Autowired;

B. @Autowired private Service service;

C. Service @Autowired service;

D. private @Autowired Service service;

Solution

1. Step 1: Recall field injection syntax and match correct syntax

   The @Autowired annotation is placed before the field declaration with its access modifier. @Autowired private Service service; correctly places @Autowired before the field type and name.

2. Final Answer:

   @Autowired private Service service; -> Option B

3. Quick Check:

   @Autowired before field = correct syntax [OK]

Hint: Put @Autowired right before the field declaration [OK]

Common Mistakes:

• Placing @Autowired after the field name
• Putting @Autowired between type and variable name
• Missing access modifier with @Autowired

3. Given the code below, what will be the output when myController.printServiceName() is called?

@Service
public class MyService {
    public String getName() { return "ServiceA"; }
}

@RestController
public class MyController {
    @Autowired
    private MyService myService;

    public void printServiceName() {
        System.out.println(myService.getName());
    }
}

medium

A. ServiceA

B. null

C. Compilation error

D. Runtime NullPointerException

Solution

1. Step 1: Understand @Autowired effect and trace method call output

   Spring Boot injects an instance of MyService into MyController automatically. Calling getName() on injected myService returns "ServiceA" which is printed.

2. Final Answer:

   ServiceA -> Option A

3. Quick Check:

   Injected service returns "ServiceA" [OK]

Hint: Autowired injects instance, so method returns actual value [OK]

Common Mistakes:

• Assuming myService is null without injection
• Thinking code causes compilation error
• Expecting NullPointerException due to missing initialization

4. What is wrong with the following Spring Boot code snippet?

@Service
public class UserService {
    private Repository repo;

    @Autowired
    public void setRepo(Repository repo) {
        this.repo = repo;
    }
}

@RestController
public class UserController {
    @Autowired
    private UserService userService;

    public void doSomething() {
        userService.repo.save();
    }
}

medium

A. Field 'repo' in UserService is private and cannot be accessed directly

B. Missing @Autowired on UserService constructor

C. UserController should not use @Autowired on fields

D. Repository interface is not annotated with @Service

Solution

1. Step 1: Check access to 'repo' field and identify cause of error

   The 'repo' field in UserService is private and cannot be accessed directly from UserController. Calling userService.repo.save() causes a compilation error due to private access.

2. Final Answer:

   Field 'repo' in UserService is private and cannot be accessed directly -> Option A

3. Quick Check:

   Private fields can't be accessed outside class [OK]

Hint: Private fields need getters; direct access causes error [OK]

Common Mistakes:

• Assuming @Autowired must be on constructor only
• Thinking field injection is disallowed in UserController
• Confusing Repository annotation requirements

5. You want to inject two different implementations of an interface PaymentService into a controller using @Autowired. How can you specify which implementation to inject?

hard

A. Rename one implementation class to avoid conflict

B. Use @Autowired twice on the same field

C. Use @Qualifier annotation with the bean name along with @Autowired

D. Use @Autowired(required=false) to ignore one implementation

Solution

1. Step 1: Understand multiple bean injection and use @Qualifier to specify bean

   When multiple beans implement the same interface, Spring needs help to know which one to inject. Adding @Qualifier with the bean name tells Spring exactly which implementation to use.

2. Final Answer:

   Use @Qualifier annotation with the bean name along with @Autowired -> Option C

3. Quick Check:

   @Qualifier + @Autowired = select specific bean [OK]

Hint: Use @Qualifier to pick the right bean when multiple exist [OK]

Common Mistakes:

• Trying to use @Autowired twice on one field
• Renaming classes doesn't solve injection ambiguity
• Using required=false hides errors but doesn't select bean