IoC container mental model in Spring Boot - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when Spring Boot starts the IoC container?

When a Spring Boot application starts, what does the IoC container do first?

A It deletes all existing beans and starts with an empty container.

B It scans for classes annotated with @Component, @Service, @Repository, and creates their instances as beans.

C It waits for user input before loading any beans.

D It immediately runs all @PostConstruct methods before creating any beans.

💡 Hint

Think about how Spring finds and prepares the parts of your app it manages.

The IoC container scans the classpath for classes marked with special annotations like @Component and creates their instances as beans to manage them.

❓ state_output

intermediate

What is the state of a bean after Spring IoC container finishes initialization?

After the Spring IoC container finishes initializing, what is true about the beans it manages?

A Beans are created but their lifecycle methods like @PostConstruct are not called.

B Beans are only created when first requested by the application code.

C Beans exist but have no dependencies injected yet.

D All singleton beans are created and ready to use, with dependencies injected.

💡 Hint

Consider the default scope of beans and when dependencies are set.

By default, singleton beans are created eagerly at startup with all dependencies injected and lifecycle methods called.

📝 Syntax

advanced

Which code snippet correctly defines a Spring bean with constructor injection?

Choose the correct way to define a Spring bean using constructor injection in a @Component class.

A

@Component
public class ServiceA {
  private final Repo repo;
  public ServiceA(Repo repo) { this.repo = repo; }
}

B

@Component
public class ServiceA {
  @Autowired
  private Repo repo;
  public ServiceA() {}
}

C

@Component
public class ServiceA {
  private Repo repo;
  public void setRepo(Repo repo) { this.repo = repo; }
}

D

@Component
public class ServiceA {
  private Repo repo;
  public ServiceA() { repo = new Repo(); }
}

💡 Hint

Constructor injection means passing dependencies through the constructor parameters.

Option A uses constructor injection correctly by defining a constructor with the dependency parameter. Spring will inject the Repo bean automatically.

🔧 Debug

advanced

Why does this Spring bean fail to initialize?

Given this Spring bean code, why does the application fail to start?

@Component
public class MyService {
  private final MyRepository repo;
  public MyService() {}
}

A Because the constructor does not accept MyRepository, Spring cannot inject the dependency.

B Because @Component is missing, Spring does not detect the class.

C Because MyRepository is not annotated with @Service, injection fails.

D Because the class has no @Autowired annotation on the constructor.

💡 Hint

Think about how Spring injects dependencies when constructors are present.

Spring uses constructor injection by default if a constructor with parameters exists. Here, the no-arg constructor prevents injection, so the dependency is never set.

🧠 Conceptual

expert

How does Spring IoC container manage bean lifecycle callbacks?

Which statement best describes how the Spring IoC container manages lifecycle callbacks like @PostConstruct and DisposableBean?

A Spring ignores lifecycle annotations and requires manual calls to lifecycle methods.

B Spring calls @PostConstruct methods before creating the bean instance, and DisposableBean methods immediately after creation.

C Spring calls @PostConstruct methods after creating and injecting dependencies, and calls DisposableBean methods before destroying singleton beans.

D Spring only calls lifecycle methods if the bean is prototype scoped.

💡 Hint

Think about when initialization and destruction happen in the bean lifecycle.

Spring calls @PostConstruct after the bean is fully created and dependencies injected. It calls DisposableBean methods before destroying singleton beans during container shutdown.

Practice

1. What is the main role of the IoC container in Spring Boot?

easy

A. To create and manage the lifecycle of application objects (beans)

B. To handle database connections directly

C. To write application logs automatically

D. To manage user interface rendering

Solution

1. Step 1: Understand IoC container purpose

   The IoC container is responsible for creating and managing objects called beans in Spring Boot.

2. Step 2: Compare options with IoC role

   Only To create and manage the lifecycle of application objects (beans) correctly describes this role; others describe unrelated tasks.

3. Final Answer:

   To create and manage the lifecycle of application objects (beans) -> Option A

4. Quick Check:

   IoC container = manages beans [OK]

Hint: IoC container manages objects, not UI or logs [OK]

Common Mistakes:

• Confusing IoC container with database or UI management
• Thinking IoC handles logging automatically

2. Which of the following is the correct way to declare a bean in a Spring Boot application using annotations?

easy

A. @Autowired public MyService myService;

B. @Service public void myService() {}

C. @ComponentScan public class MyService {}

D. @Bean public MyService myService() { return new MyService(); }

Solution

1. Step 1: Identify correct bean declaration syntax

   The @Bean annotation on a method returning an object is the standard way to declare a bean.

2. Step 2: Check other options for correctness

   @Service is a class-level annotation, not for methods; @ComponentScan is for scanning packages; @Autowired injects beans, not declares them.

3. Final Answer:

   @Bean public MyService myService() { return new MyService(); } -> Option D

4. Quick Check:

   @Bean method declares bean [OK]

Hint: Use @Bean on methods returning objects [OK]

Common Mistakes:

• Using @Service on methods instead of classes
• Confusing @ComponentScan with bean declaration
• Using @Autowired to declare beans

3. Given the following Spring Boot code snippet, what will be the output when the application runs?

@Component
public class Printer {
  public void print() { System.out.println("Hello from Printer"); }
}

@Component
public class Runner {
  private final Printer printer;
  @Autowired
  public Runner(Printer printer) { this.printer = printer; }
  @PostConstruct
  public void run() { printer.print(); }
}

medium

A. NullPointerException at runtime

B. Hello from Printer

C. No output, method not called

D. Compilation error due to missing annotations

Solution

1. Step 1: Understand bean creation and injection

   Both Printer and Runner are @Component beans. Spring creates them and injects Printer into Runner's constructor.

2. Step 2: Analyze method call on startup

   The @PostConstruct method run() calls printer.print(), which prints "Hello from Printer" to the console.

3. Final Answer:

   Hello from Printer -> Option B

4. Quick Check:

   @PostConstruct runs print() = Hello from Printer [OK]

Hint: Look for @PostConstruct to find startup output [OK]

Common Mistakes:

• Assuming printer is null without injection
• Missing @PostConstruct means no method call
• Confusing compilation errors with runtime behavior

4. Consider this Spring Boot code snippet:

@Component
public class ServiceA {
  @Autowired
  private ServiceB serviceB;
}

@Component
public class ServiceB {
  @Autowired
  private ServiceA serviceA;
}

What problem will occur when the application starts?

medium

A. ServiceB will not be injected into ServiceA

B. No problem, both services work fine

C. Circular dependency causing startup failure

D. Compilation error due to missing constructors

Solution

1. Step 1: Identify circular dependency

   ServiceA depends on ServiceB and ServiceB depends on ServiceA, creating a circular reference.

2. Step 2: Understand Spring's behavior on circular dependencies

   Spring cannot resolve this circular injection automatically with field injection, causing startup failure.

3. Final Answer:

   Circular dependency causing startup failure -> Option C

4. Quick Check:

   Circular dependency = startup error [OK]

Hint: Check if two beans inject each other directly [OK]

Common Mistakes:

• Assuming circular dependencies always work
• Thinking missing constructors cause compile errors here
• Believing Spring resolves all circular injections automatically

5. You want to replace a bean implementation in your Spring Boot app without changing the code that uses it. Which IoC container feature helps achieve this easily?

hard

A. Using interfaces and configuring which implementation bean to inject

B. Manually creating objects with new keyword everywhere

C. Hardcoding class names in all dependent classes

D. Disabling the IoC container and managing beans yourself

Solution

1. Step 1: Understand IoC container flexibility

   IoC allows injecting different implementations of an interface without changing dependent code.

2. Step 2: Evaluate options for flexibility

   Only Using interfaces and configuring which implementation bean to inject uses interfaces and configuration to swap implementations easily; others break IoC benefits.

3. Final Answer:

   Using interfaces and configuring which implementation bean to inject -> Option A

4. Quick Check:

   Interfaces + config = easy bean replacement [OK]

Hint: Use interfaces and config to swap beans easily [OK]

Common Mistakes:

• Using new keyword breaks IoC benefits
• Hardcoding class names reduces flexibility
• Disabling IoC container loses automatic management