Constructor injection (preferred) in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this Spring Boot component using constructor injection?

Consider this Spring Boot service class using constructor injection. What will be printed when greet() is called?

Spring Boot

import org.springframework.stereotype.Service;

@Service
public class GreetingService {
    private final String message;

    public GreetingService() {
        this.message = "Hello, World!";
    }

    public String greet() {
        return message;
    }
}

A null

B "Hello, World!"

C Compilation error due to missing constructor injection

D "Hello"

💡 Hint

Look at how the message field is set in the constructor.

The constructor sets the message field to "Hello, World!". So calling greet() returns that string.

📝 Syntax

intermediate

Which constructor injection code snippet is syntactically correct in Spring Boot?

Choose the correct constructor injection syntax for a Spring Boot service that depends on DataService.

A public MyService(DataService dataService) { dataService = dataService; }

B public MyService() { this.dataService = new DataService(); }

C public void MyService(DataService dataService) { this.dataService = dataService; }

D public MyService(DataService dataService) { this.dataService = dataService; }

💡 Hint

Remember constructors have no return type and parameters are assigned to fields.

Option D correctly defines a constructor with a parameter and assigns it to the field. Option D uses manual instantiation, not injection. Option D has a void return type, so it's a method, not a constructor. Option D assigns the parameter to itself, not the field.

🔧 Debug

advanced

Why does this Spring Boot component fail to inject dependency via constructor?

Examine this Spring Boot component. Why will the dependency injection fail?

Spring Boot

import org.springframework.stereotype.Component;

@Component
public class UserComponent {
    private final UserService userService;

    public UserComponent() {
        this.userService = null;
    }

    public String getUserName() {
        return userService.getName();
    }
}

A Because @Component annotation is missing

B Because userService is final and cannot be null

C Because the constructor does not accept UserService, so Spring cannot inject it

D Because getUserName() method is not annotated with @Autowired

💡 Hint

Think about how Spring injects dependencies via constructors.

Spring injects dependencies by calling constructors with parameters. Here, the constructor has no parameters, so Spring cannot inject UserService. The field is set to null manually, causing a NullPointerException later.

❓ state_output

advanced

What is the value of the injected field after Spring Boot creates this component?

Given this Spring Boot component using constructor injection, what will be the value of configValue after creation?

Spring Boot

import org.springframework.stereotype.Component;

@Component
public class ConfigComponent {
    private final String configValue;

    public ConfigComponent(String configValue) {
        this.configValue = configValue;
    }

    public String getConfigValue() {
        return configValue;
    }
}

A Compilation error due to missing @Value annotation

B null

C Empty string ""

D The string value from Spring configuration if properly wired

💡 Hint

Think about how Spring injects simple types like String in constructors.

Spring cannot inject a String parameter without additional annotations like @Value or configuration. Without them, Spring cannot resolve the constructor parameter, so the component creation fails or the field remains null if forced.

🧠 Conceptual

expert

Why is constructor injection preferred over field injection in Spring Boot?

Choose the best explanation why constructor injection is preferred in Spring Boot applications.

A Constructor injection ensures dependencies are immutable and required, improving testability and design clarity

B Constructor injection automatically wires private fields without setters

C Constructor injection requires less code and no explicit annotations

D Constructor injection allows Spring to inject dependencies lazily at runtime

💡 Hint

Think about immutability and testing benefits.

Constructor injection makes dependencies final and required, which helps avoid nulls and makes testing easier. It also clarifies what dependencies a class needs. Other options are incorrect or misleading.