Constructor injection (preferred) in Spring Boot - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a constructor for dependency injection in a Spring Boot component.

Spring Boot

public class UserService {
    private final UserRepository userRepository;

    public UserService([1] userRepository) {
        this.userRepository = userRepository;
    }
}

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

AUserRepository

Bvoid

Cint

DString

Attempts:

3 left

💡 Hint

Common Mistakes

Using a primitive type like int instead of the dependency class.

Using void as a parameter type, which is invalid.

The constructor parameter must be the type of the dependency to inject, here UserRepository.

2fill in blank

medium

Complete the code to annotate the class as a Spring component for constructor injection.

Spring Boot

[1]
public class OrderService {
    private final PaymentService paymentService;

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

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

A@Autowired

B@ComponentScan

C@Repository

D@Service

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Autowired on the class instead of on the constructor or fields.

Using @ComponentScan which is for configuration classes.

The @Service annotation marks the class as a Spring service component, enabling constructor injection.

3fill in blank

hard

Fix the error in the constructor injection by completing the annotation for automatic wiring.

Spring Boot

public class NotificationService {
    private final EmailSender emailSender;

    [1]
    public NotificationService(EmailSender emailSender) {
        this.emailSender = emailSender;
    }
}

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

A@Service

B@Inject

C@Autowired

D@Component

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Service or @Component on the constructor instead of the class.

Using @Inject which is a Java EE annotation, not Spring-specific.

The @Autowired annotation tells Spring to inject the dependency via the constructor.

4fill in blank

hard

Fill both blanks to complete a Spring component with constructor injection and final field declaration.

Spring Boot

@Component
public class [1] {
    private final [2] repository;

    public [1]([2] repository) {
        this.repository = repository;
    }
}

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

AProductService

BUserRepository

COrderRepository

DCustomerService

Attempts:

3 left

💡 Hint

Common Mistakes

Mismatching class name and constructor parameter types.

Using service names as repository types.

The class name and the field type must match the service and repository names respectively for proper constructor injection.

5fill in blank

hard

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

Spring Boot

[1]
public class [2] {
    private final [3] paymentGateway;

    public [2]([3] paymentGateway) {
        this.paymentGateway = paymentGateway;
    }
}

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

A@Service

BPaymentService

CPaymentGateway

D@Component

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Component instead of @Service for service classes.

Mismatching class and parameter names.

The class must be annotated with @Service, named PaymentService, and inject a PaymentGateway dependency.

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