Field injection and why to avoid it in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why is field injection discouraged in Spring Boot?

Which of the following is the main reason developers are advised to avoid field injection in Spring Boot?

A Field injection automatically validates dependencies at compile time, preventing runtime errors.

B Field injection improves code readability and is recommended for all Spring Boot projects.

C Field injection makes unit testing harder because dependencies are private and cannot be set easily.

D Field injection allows dependencies to be changed dynamically at runtime without restarting the application.

💡 Hint

Think about how private fields affect testing and flexibility.

Field injection hides dependencies inside private fields, making it difficult to replace or mock them during unit tests. Constructor injection is preferred because it makes dependencies explicit and easier to manage.

❓ component_behavior

intermediate

What happens when a Spring component uses field injection?

Consider a Spring component with a private field annotated with @Autowired for dependency injection. What is the behavior when the application context starts?

A Spring calls the constructor with the dependency as a parameter to inject it.

B Spring requires a setter method to inject the dependency into the private field.

C Spring throws a compile-time error because private fields cannot be injected.

D Spring injects the dependency directly into the private field using reflection after the object is created.

💡 Hint

Think about how Spring accesses private fields.

Spring uses reflection to inject dependencies directly into private fields annotated with @Autowired after the object is instantiated. This bypasses constructors and setters.

🔧 Debug

advanced

Why does this Spring Boot test fail with field injection?

Given this Spring Boot test class using field injection, why does the test fail with a NullPointerException? public class UserServiceTest { @Autowired private UserRepository userRepository; @Test public void testFindUser() { User user = userRepository.findById(1L); assertNotNull(user); } }

A Field injection requires the userRepository field to be public for injection to work.

B The test class is missing @ExtendWith(SpringExtension.class) or @SpringBootTest, so Spring does not inject dependencies.

C The UserRepository bean is not annotated with @Component, so Spring cannot inject it.

D The test method must be static for Spring to inject dependencies.

💡 Hint

Check if Spring context is loaded for the test.

Without proper Spring test annotations like @SpringBootTest or @ExtendWith(SpringExtension.class), Spring does not create the application context and does not inject dependencies, causing NullPointerException.

📝 Syntax

advanced

Which code snippet correctly uses constructor injection in Spring Boot?

Select the code snippet that correctly implements constructor injection for a service class in Spring Boot.

A

public class OrderService {
  private final PaymentService paymentService;

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

B

public class OrderService {
  private PaymentService paymentService;

  public void setPaymentService(PaymentService paymentService) {
    this.paymentService = paymentService;
  }
}

C

public class OrderService {
  private PaymentService paymentService;

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

D

public class OrderService {
  @Autowired
  private PaymentService paymentService;
}

💡 Hint

Constructor injection requires a constructor with parameters and @Autowired.

Constructor injection uses a constructor annotated with @Autowired (optional in recent Spring versions) that takes dependencies as parameters and assigns them to final fields. This makes dependencies explicit and immutable.

❓ state_output

expert

What is the state of the dependency in this Spring Boot component using field injection?

Given this Spring Boot component: @Component public class NotificationService { @Autowired private EmailService emailService; public void sendNotification() { emailService.sendEmail("Hello"); } } What happens if you create NotificationService with new NotificationService() and call sendNotification()?

A A NullPointerException occurs because emailService is not injected when using new operator.

B The emailService is injected automatically even when using new operator, so the email is sent.

C The code compiles but sendNotification() does nothing because emailService is empty.

D Spring throws a runtime error when new NotificationService() is called.

💡 Hint

Think about how Spring manages injection and object creation.

When you create an object with new, Spring does not manage it and does not inject dependencies. The private field remains null, causing NullPointerException when accessed.