@Autowired for dependency injection in Spring Boot - Mini Project: Build & Apply

Using @Autowired for Dependency Injection in Spring Boot

📖 Scenario: You are building a simple Spring Boot application that manages messages. You want to use Spring's dependency injection to automatically provide a service to your controller.

🎯 Goal: Learn how to use @Autowired to inject a service into a controller in Spring Boot.

📋 What You'll Learn

Create a service class called MessageService with a method getMessage() that returns a string.

Create a controller class called MessageController.

Use @Autowired to inject MessageService into MessageController.

Add a method in MessageController that calls getMessage() from the service.

💡 Why This Matters

🌍 Real World

Dependency injection with @Autowired is a common pattern in Spring Boot applications to manage components and their dependencies automatically.

💼 Career

Understanding @Autowired and dependency injection is essential for Java developers working with Spring Boot to build maintainable and testable applications.

1

Create the MessageService class

Create a class called MessageService annotated with @Service. Inside it, write a method public String getMessage() that returns the string "Hello from MessageService".

Spring Boot

// Your code here

Hint

Use @Service to mark the class as a service component.

2

Create the MessageController class

Create a class called MessageController annotated with @RestController. This class will later use the service.

Spring Boot

import org.springframework.stereotype.Service;

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

// Your code here

Hint

Use @RestController to mark the class as a controller that returns data.

3

Inject MessageService into MessageController using @Autowired

Inside MessageController, declare a private field messageService of type MessageService. Use @Autowired above it to inject the service.

Spring Boot

import org.springframework.stereotype.Service;

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

import org.springframework.web.bind.annotation.RestController;
import org.springframework.beans.factory.annotation.Autowired;

@RestController
public class MessageController {
    // Your code here
}

Hint

Use @Autowired to let Spring inject the service automatically.

4

Add a method in MessageController to use the injected service

In MessageController, add a method public String showMessage() annotated with @GetMapping("/message"). This method should return the result of calling messageService.getMessage().

Spring Boot

import org.springframework.stereotype.Service;

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

import org.springframework.web.bind.annotation.RestController;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;

@RestController
public class MessageController {
    @Autowired
    private MessageService messageService;

    // Your code here
}

Hint

Use @GetMapping to create a web endpoint that returns the message.

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