Constructor injection (preferred) in Spring Boot - Mini Project: Build & Apply

Constructor Injection in Spring Boot

📖 Scenario: You are building a simple Spring Boot application that manages messages. You want to use constructor injection to provide a service to a controller. Constructor injection is the preferred way to inject dependencies in Spring Boot because it makes your code easier to test and more reliable.

🎯 Goal: Create a Spring Boot controller that uses constructor injection to get a message service. The controller will return a greeting message from the service.

📋 What You'll Learn

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

Create a controller class called MessageController that uses constructor injection to get the MessageService.

The controller should have a method greet() that returns the message from the service.

Use Spring annotations @Service and @RestController appropriately.

💡 Why This Matters

🌍 Real World

Constructor injection is widely used in Spring Boot applications to manage dependencies cleanly and make components easier to test and maintain.

💼 Career

Understanding constructor injection is essential for Java developers working with Spring Boot, as it is the preferred way to inject dependencies in professional projects.

1

Create the MessageService class

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

Spring Boot

@Service
public class MessageService {
    // Your code here
}

Hint

Use @Service above the class. Define getMessage() to return the exact string.

2

Create the MessageController class with constructor

Create a class called MessageController annotated with @RestController. Add a private final field of type MessageService called messageService. Create a public constructor that takes a MessageService parameter called messageService and assigns it to the field.

Spring Boot

@RestController
public class MessageController {
    private final MessageService messageService;

    // Your code here
}

Hint

Use @RestController above the class. Declare the field as private final. Create a constructor that assigns the parameter to the field.

3

Add the greet() method to MessageController

Inside MessageController, add a public method called greet() that returns a String. This method should return the result of calling getMessage() on the messageService field.

Spring Boot

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

@RestController
public class MessageController {
    private final MessageService messageService;

    public MessageController(MessageService messageService) {
        this.messageService = messageService;
    }

    // Add greet() method here
}

Hint

Define greet() to call getMessage() on the injected service and return its result.

4

Add @GetMapping to greet() method

Add the annotation @GetMapping("/greet") above the greet() method in MessageController so it handles HTTP GET requests at the path /greet.

Spring Boot

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

@RestController
public class MessageController {
    private final MessageService messageService;

    public MessageController(MessageService messageService) {
        this.messageService = messageService;
    }

    // Add @GetMapping annotation here
    public String greet() {
        return messageService.getMessage();
    }
}

Hint

Use @GetMapping("/greet") just above the greet() method.

Practice

1. What is the main advantage of using constructor injection in Spring Boot?

easy

A. It automatically creates objects without any code.

B. It requires less code than field injection.

C. It allows changing dependencies after the object is created.

D. It makes dependencies explicit and helps with testing.

Solution

1. Step 1: Understand constructor injection purpose

   Constructor injection passes dependencies when creating the object, making them clear and fixed.

2. Step 2: Benefits of explicit dependencies

   This clarity helps testing because dependencies can be easily replaced with mocks.

3. Final Answer:

   It makes dependencies explicit and helps with testing. -> Option D

4. Quick Check:

   Constructor injection = explicit dependencies [OK]

Hint: Constructor injection shows dependencies clearly [OK]

Common Mistakes:

• Thinking constructor injection creates objects automatically
• Confusing constructor injection with field injection
• Believing dependencies can be changed after creation

2. Which of the following is the correct syntax for constructor injection in a Spring Boot component?

easy

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

B. public class Service { @Autowired private Repo repo; }

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

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

Solution

1. Step 1: Identify constructor injection pattern

   Constructor injection requires a constructor that takes dependencies as parameters and assigns them.

2. Step 2: Check each option

   public class Service { private final Repo repo; public Service(Repo repo) { this.repo = repo; } } shows a constructor with a parameter and assigns it to a final field, which is correct.

3. Final Answer:

   public class Service { private final Repo repo; public Service(Repo repo) { this.repo = repo; } } -> Option A

4. Quick Check:

   Constructor with parameters = constructor injection [OK]

Hint: Constructor injection needs constructor with parameters [OK]

Common Mistakes:

• Using @Autowired on fields instead of constructor
• Using setter methods instead of constructor
• Creating new dependency instances inside the class

3. Given the code below, what will be the output when the printMessage method is called?

\@Component
public class Printer {
  private final MessageService service;
  public Printer(MessageService service) {
    this.service = service;
  }
  public void printMessage() {
    System.out.println(service.getMessage());
  }
}

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

medium

A. null

B. Hello Spring!

C. Compilation error

D. Runtime NullPointerException

Solution

1. Step 1: Understand constructor injection wiring

   Spring injects MessageService into Printer via constructor, so service is not null.

2. Step 2: Check method output

   Calling service.getMessage() returns "Hello Spring!", which is printed.

3. Final Answer:

   Hello Spring! -> Option B

4. Quick Check:

   Injected service returns message [OK]

Hint: Constructor injection ensures dependencies are not null [OK]

Common Mistakes:

• Assuming service is null without injection
• Confusing field injection with constructor injection
• Expecting compilation error due to missing annotations

4. What is wrong with the following Spring Boot component using constructor injection?

\@Component
public class UserService {
  private final UserRepository repo;
  public UserService() {
    this.repo = null;
  }
}

medium

A. Constructor does not accept UserRepository, so dependency is not injected.

B. Field repo should not be final.

C. Missing @Autowired annotation on the constructor.

D. UserRepository should be instantiated inside the constructor.

Solution

1. Step 1: Check constructor parameters for injection

   The constructor has no parameters, so Spring cannot inject UserRepository.

2. Step 2: Understand consequence of no injection

   repo is assigned null manually, so dependency is missing and will cause errors later.

3. Final Answer:

   Constructor does not accept UserRepository, so dependency is not injected. -> Option A

4. Quick Check:

   Constructor must have dependency parameters [OK]

Hint: Constructor must accept dependencies as parameters [OK]

Common Mistakes:

• Forgetting to add parameters to constructor
• Thinking @Autowired is required on constructor in Spring Boot
• Instantiating dependencies manually inside constructor

5. You have a Spring Boot service that depends on two other services: PaymentService and NotificationService. How should you write the constructor to follow best practices for constructor injection?

hard

A. public OrderService(PaymentService paymentService) { this.paymentService = paymentService; }

B. public OrderService() { this.paymentService = new PaymentService(); this.notificationService = new NotificationService(); }

C. public OrderService(PaymentService paymentService, NotificationService notificationService) { this.paymentService = paymentService; this.notificationService = notificationService; }

D. public OrderService(@Autowired PaymentService paymentService, NotificationService notificationService) { this.paymentService = paymentService; this.notificationService = notificationService; }

Solution

1. Step 1: Identify correct constructor injection with multiple dependencies

   The constructor should accept all required dependencies as parameters and assign them.

2. Step 2: Check options for best practice

   public OrderService(PaymentService paymentService, NotificationService notificationService) { this.paymentService = paymentService; this.notificationService = notificationService; } correctly accepts both services and assigns them, following best practice.

3. Final Answer:

   public OrderService(PaymentService paymentService, NotificationService notificationService) { this.paymentService = paymentService; this.notificationService = notificationService; } -> Option C

4. Quick Check:

   Constructor with all dependencies = best practice [OK]

Hint: Include all dependencies as constructor parameters [OK]

Common Mistakes:

• Instantiating dependencies inside constructor
• Missing one of the dependencies in constructor
• Using @Autowired on constructor parameters unnecessarily