@Autowired for dependency injection in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What does @Autowired do in Spring Boot?

In Spring Boot, what is the primary purpose of the @Autowired annotation?

A It marks a class as a Spring Boot application entry point.

B It automatically injects the required dependency into a class field or constructor.

C It defines a REST endpoint in a controller class.

D It configures database connection properties.

💡 Hint

Think about how Spring Boot provides objects to classes without manual creation.

@Autowired tells Spring Boot to provide the needed object automatically, so you don't have to create it yourself.

❓ component_behavior

intermediate

What happens if Spring cannot find a bean to @Autowired?

Consider a Spring Boot class with a field annotated with @Autowired. What happens if Spring cannot find a matching bean to inject?

A Spring creates a new bean automatically without any error.

B Spring logs a warning but continues running.

C The field remains null and the application runs without errors.

D The application fails to start with a NoSuchBeanDefinitionException.

💡 Hint

Think about what Spring expects when it cannot find a required dependency.

If Spring cannot find a bean to inject, it throws an exception and stops the application startup to avoid null references.

📝 Syntax

advanced

Which code snippet correctly uses @Autowired for constructor injection?

Select the code snippet that correctly uses @Autowired to inject a dependency via constructor in a Spring Boot component.

A

public class Service {
  private final Repo repo;
  @Autowired
  public Service(Repo repo) {
    this.repo = repo;
  }
}

B

public class Service {
  @Autowired
  private Repo repo;
  public Service() {}
}

C

public class Service {
  private Repo repo;
  public Service(@Autowired Repo repo) {
    this.repo = repo;
  }
}

D

public class Service {
  private Repo repo;
  public Service(Repo repo) {
    this.repo = repo;
  }
}

💡 Hint

Look for the correct placement of @Autowired on the constructor.

The correct way is to put @Autowired on the constructor so Spring knows to inject the dependency when creating the object.

🔧 Debug

advanced

Why does this @Autowired field remain null?

Given this Spring Boot component code, why does the service field remain null? public class Controller { @Autowired private Service service; public void doWork() { service.perform(); } } Assume Service is a valid Spring bean.

A The Controller class is not managed by Spring (missing @Component or similar).

B The Service bean is not annotated with @Service.

C The @Autowired annotation is missing on the service field.

D The perform() method does not exist in Service.

💡 Hint

Think about which classes Spring manages and injects dependencies into.

If the Controller is not a Spring-managed bean, Spring will not inject dependencies into it, so the field stays null.

❓ lifecycle

expert

When is the @Autowired injection performed in Spring Boot lifecycle?

At what point in the Spring Boot application lifecycle does the @Autowired injection happen for a bean?

A After the application context is fully started and running.

B Before the constructor is called, during class loading.

C During bean creation, after the constructor but before any @PostConstruct methods.

D Only when the bean is first accessed by another bean.

💡 Hint

Consider when Spring sets dependencies relative to constructor and lifecycle callbacks.

Spring injects dependencies right after creating the bean instance (constructor call) but before calling any @PostConstruct methods.

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