IoC container mental model in Spring Boot - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a Spring bean using annotation.

Spring Boot

@Component
public class [1]Service {
    // service logic
}

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

AUser

BAutowired

CRepository

DController

Attempts:

3 left

💡 Hint

Common Mistakes

Using annotation names like @Autowired instead of class names.

Using unrelated class names like Repository or Controller.

The class name should represent the service, so UserService is correct here.

2fill in blank

medium

Complete the code to inject a bean using Spring's dependency injection.

Spring Boot

public class UserController {
    @[1]
    private UserService userService;
}

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

AComponent

BRepository

CAutowired

DService

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Component or @Service which are for bean declaration, not injection.

Using @Repository which is for data access layers.

The @Autowired annotation tells Spring to inject the bean automatically.

3fill in blank

hard

Fix the error in the bean declaration by completing the annotation.

Spring Boot

@[1]
public class OrderService {
    // service logic
}

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

AAutowired

BRepository

CComponent

DService

Attempts:

3 left

💡 Hint

Common Mistakes

Using @Autowired which is for injection, not declaration.

Using @Component which works but is less specific.

Using @Repository which is for data access.

The @Service annotation is the best practice to declare a service bean in Spring.

4fill in blank

hard

Fill both blanks to complete the code for constructor injection in Spring.

Spring Boot

public class PaymentController {
    private final PaymentService paymentService;

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

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

APaymentService

BpaymentService

CPaymentController

Dthis

Attempts:

3 left

💡 Hint

Common Mistakes

Using the class name as the field name.

Using 'this' instead of the field name.

The constructor parameter type is PaymentService and the field assigned is paymentService.

5fill in blank

hard

Fill all three blanks to complete the code for a Spring configuration class defining a bean.

Spring Boot

@Configuration
public class AppConfig {

    @Bean
    public UserService [1]() {
        return new [2]();
    }

    @Bean
    public UserRepository [3]() {
        return new UserRepository();
    }
}

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

AuserService

BUserService

CuserRepository

DUserRepository

Attempts:

3 left

💡 Hint

Common Mistakes

Using class names as method names.

Mixing up method names and class names.

The method names for beans are usually camelCase like userService and userRepository. The classes are PascalCase like UserService.

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