IoC container mental model in Spring Boot - Mini Project: Build & Apply

Understanding the IoC Container Mental Model in Spring Boot

📖 Scenario: You are building a simple Spring Boot application that manages a greeting service. The application uses the IoC (Inversion of Control) container to manage the creation and injection of components.This project will help you understand how Spring Boot's IoC container works by creating a service, configuring it, and letting Spring manage its lifecycle.

🎯 Goal: Build a Spring Boot application that defines a greeting service as a component, configures a message, and uses the IoC container to inject and use the service in the main application class.

📋 What You'll Learn

Create a GreetingService class annotated as a Spring component

Add a configuration property greetingMessage in the service

Use constructor injection to inject the greeting message into the service

Create a main application class that uses the IoC container to get the GreetingService bean and call its method

💡 Why This Matters

🌍 Real World

Spring Boot's IoC container is used in almost all real-world Spring applications to manage components and their dependencies automatically, making code cleaner and easier to maintain.

💼 Career

Understanding the IoC container is essential for Java developers working with Spring Boot, as it is the foundation for dependency injection and component management in enterprise applications.

1

Create the GreetingService component

Create a class called GreetingService annotated with @Component. Inside it, create a private final String variable called greetingMessage and a constructor that takes a String parameter greetingMessage and assigns it to the variable.

Spring Boot

@Component
public class GreetingService {
    private final String greetingMessage;
    
    // Your code here
}

Hint

Use @Component to mark the class as a Spring bean. Create a constructor that takes greetingMessage and assigns it to the field.

2

Add a configuration property for the greeting message

Create a configuration class called GreetingConfig annotated with @Configuration. Inside it, create a method greetingMessage annotated with @Bean that returns the String "Hello from Spring IoC!".

Spring Boot

@Component
public class GreetingService {
    private final String greetingMessage;

    public GreetingService(String greetingMessage) {
        this.greetingMessage = greetingMessage;
    }

    public String greet() {
        return greetingMessage;
    }
}

// Your code here

Hint

Use @Configuration to create a config class. Define a @Bean method that returns the greeting message string.

3

Inject the greeting message into GreetingService

Modify the GreetingService constructor to use @Autowired on the constructor and accept the greetingMessage bean injected by Spring.

Spring Boot

@Component
public class GreetingService {
    private final String greetingMessage;

    // Your code here

    public String greet() {
        return greetingMessage;
    }
}

@Configuration
public class GreetingConfig {
    @Bean
    public String greetingMessage() {
        return "Hello from Spring IoC!";
    }
}

Hint

Add @Autowired above the constructor to tell Spring to inject the greetingMessage bean.

4

Use the IoC container to get and use GreetingService

Create a main application class called IoCApplication annotated with @SpringBootApplication. In the main method, get the ApplicationContext by running SpringApplication.run. Then get the GreetingService bean from the context and call its greet() method.

Spring Boot

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Bean;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

@Component
public class GreetingService {
    private final String greetingMessage;

    @Autowired
    public GreetingService(String greetingMessage) {
        this.greetingMessage = greetingMessage;
    }

    public String greet() {
        return greetingMessage;
    }
}

@Configuration
public class GreetingConfig {
    @Bean
    public String greetingMessage() {
        return "Hello from Spring IoC!";
    }
}

// Your code here

Hint

Create a main class with @SpringBootApplication. Use SpringApplication.run to get the context, then get the GreetingService bean and call greet().

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