@Autowired for dependency injection in Spring Boot - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to inject the service using @Autowired.

Spring Boot

public class UserController {
    @[1]
    private UserService userService;
}

Drag options to blanks, or click blank then click option'

AAutowired

BInject

CService

DComponent

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Inject instead of @Autowired in Spring Boot without proper configuration.

Forgetting the @Autowired annotation and manually instantiating the service.

The @Autowired annotation tells Spring to inject the UserService dependency automatically.

2fill in blank

medium

Complete the code to inject the repository via constructor with @Autowired.

Spring Boot

public class ProductService {
    private final ProductRepository productRepository;

    @[1]
    public ProductService(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }
}

Drag options to blanks, or click blank then click option'

AAutowired

BInject

CService

DComponent

Attempts:

3 left

💡 Hint

Common Mistakes

Not annotating the constructor and expecting Spring to inject dependencies automatically.

Using @Inject without proper configuration in Spring Boot.

Using @Autowired on the constructor tells Spring to inject the ProductRepository when creating ProductService.

3fill in blank

hard

Fix the error in the code by completing the annotation to inject the service.

Spring Boot

public class OrderController {
    @[1]
    private OrderService orderService;

    public void placeOrder() {
        orderService.processOrder();
    }
}

Drag options to blanks, or click blank then click option'

AComponent

BAutowired

CService

DRepository

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Service or @Component instead of @Autowired for injection.

Forgetting to annotate the field and causing NullPointerException.

The @Autowired annotation is required to inject the OrderService dependency properly.

4fill in blank

hard

Fill both blanks to inject the repository and annotate the class as a Spring component.

Spring Boot

@[1]
public class CustomerRepository {

    @[2]
    private DataSource dataSource;

}

Drag options to blanks, or click blank then click option'

AComponent

BAutowired

CRepository

DService

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Component instead of @Repository for repository classes.

Forgetting @Autowired on the dataSource field.

The class should be annotated with @Repository to mark it as a Spring repository, and the dataSource field should be injected with @Autowired.

5fill in blank

hard

Fill all three blanks to create a service class with constructor injection and proper annotations.

Spring Boot

@[1]
public class PaymentService {

    private final PaymentRepository paymentRepository;

    @[2]
    public PaymentService([3] paymentRepository) {
        this.paymentRepository = paymentRepository;
    }
}

Drag options to blanks, or click blank then click option'

AService

BAutowired

CPaymentRepository

DComponent

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Component instead of @Service for service classes.

Forgetting @Autowired on the constructor.

Incorrect parameter type in the constructor.

The class is annotated with @Service, the constructor with @Autowired, and the parameter type is PaymentRepository for proper dependency injection.

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