@Component annotation in Spring Boot - Step-by-Step Execution

Concept Flow - @Component annotation

Start Application

↓

Spring scans classes

↓

Find @Component

↓

Create instance (bean)

↓

Add bean to ApplicationContext

↓

Inject bean where needed

↓

Use bean in app

Spring Boot scans classes for @Component, creates instances, stores them, and injects where needed.

Execution Sample

Spring Boot

import org.springframework.stereotype.Component;

@Component
public class MyService {
  public String greet() { return "Hello"; }
}

Defines a class marked with @Component so Spring creates and manages its instance automatically.

Execution Table

Step	Action	Evaluation	Result
1	Start Spring Boot app	Begin scanning classes	Scanning initiated
2	Scan MyService class	Check for @Component annotation	Found @Component
3	Create MyService instance	Instantiate class	Instance created
4	Register bean	Add instance to ApplicationContext	Bean stored
5	Inject bean	Find injection points	MyService injected where needed
6	Use bean	Call greet() method	Returns 'Hello'
7	End	No more classes to scan	Application ready

💡 All classes scanned and beans created; application context ready for use.

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
MyService instance	null	Created object	Stored in ApplicationContext	Injected and ready

Key Moments - 2 Insights

Why does Spring create an instance of MyService automatically?

Because the class is marked with @Component, Spring detects it during scanning (see execution_table step 2) and creates an instance (step 3).

How does Spring know where to use the MyService bean?

Spring looks for injection points like @Autowired fields or constructor parameters and injects the bean from ApplicationContext (step 5).

Visual Quiz - 3 Questions

Look at the execution table, what happens at step 3?

A Spring scans classes for annotations

B Spring injects the bean into other classes

C Spring creates an instance of MyService

D Spring starts the application

💡 Hint

Check the 'Action' and 'Result' columns at step 3 in the execution_table.

At which step does Spring add the MyService instance to the ApplicationContext?

A Step 4

B Step 2

C Step 3

D Step 5

💡 Hint

Look for the step where the bean is registered or stored in the execution_table.

If the @Component annotation is removed, what changes in the execution flow?

A Spring still creates and injects the bean

B Spring scans but does not create the bean

C Spring throws an error at startup

D Spring creates the bean but does not inject it

💡 Hint

Refer to step 2 where Spring checks for @Component to decide on bean creation.

Concept Snapshot

@Component annotation in Spring Boot:
- Marks a class as a Spring-managed bean
- Spring scans and creates instance automatically
- Bean stored in ApplicationContext
- Injected where needed via @Autowired
- Enables easy dependency management

Full Transcript

When a Spring Boot application starts, it scans all classes for the @Component annotation. When it finds a class marked with @Component, it creates an instance of that class and stores it in the ApplicationContext. Later, Spring injects this instance into other classes where it is needed, for example, using @Autowired. This process helps manage dependencies automatically without manual object creation.

Practice

1. What is the main purpose of the @Component annotation in Spring Boot?

easy

A. To mark a class so Spring automatically creates and manages its instance

B. To define a database entity

C. To configure application properties

D. To handle HTTP requests

Solution

1. Step 1: Understand the role of @Component

   The @Component annotation tells Spring to create an instance of the class and manage it automatically.

2. Step 2: Compare with other options

   The other options relate to other Spring features like entities, properties, or controllers, not @Component.

3. Final Answer:

   To mark a class so Spring automatically creates and manages its instance -> Option A

4. Quick Check:

   @Component = automatic management [OK]

Hint: Remember: @Component means Spring manages the class [OK]

Common Mistakes:

• Confusing @Component with @Entity
• Thinking it handles HTTP requests
• Assuming it configures properties

2. Which of the following is the correct way to declare a Spring component class?

easy

A. @Component public class MyService {}

B. @Service public void MyService() {}

C. public class MyService {}

D. @Component void MyService() {}

Solution

1. Step 1: Check annotation placement and class declaration

   The @Component annotation must be placed above a class declaration, like @Component public class MyService {}.

2. Step 2: Identify incorrect syntax

   A plain public class misses the annotation, annotating a method with @Service or @Component is invalid since components must be classes.

3. Final Answer:

   @Component public class MyService {} -> Option A

4. Quick Check:

   Annotation + class declaration = correct syntax [OK]

Hint: Always put @Component above a class, not a method [OK]

Common Mistakes:

• Annotating methods instead of classes
• Missing the annotation entirely
• Using wrong annotations for components

3. Given the code below, what will be the output when app.run() is called?

@Component
public class App {
  @Autowired
  private ServiceA serviceA;

  public void run() {
    System.out.println(serviceA.getName());
  }
}

@Component
public class ServiceA {
  public String getName() {
    return "ServiceA";
  }
}

medium

A. Runtime NullPointerException

B. null

C. ServiceA

D. Compilation error

Solution

1. Step 1: Understand component scanning and injection

   Both App and ServiceA are annotated with @Component, so Spring creates and manages their instances. The @Autowired injects ServiceA into App.

2. Step 2: Trace the method call

   Calling app.run() prints the result of serviceA.getName(), which returns "ServiceA".

3. Final Answer:

   ServiceA -> Option C

4. Quick Check:

   Autowired injects component = output string [OK]

Hint: If both classes are @Component, autowired works and prints value [OK]

Common Mistakes:

• Assuming serviceA is null without injection
• Confusing compilation vs runtime errors
• Forgetting to annotate both classes

4. What is the problem with the following code snippet?

@Component
public class MyComponent {
  @Autowired
  private ServiceB serviceB;

  public void doWork() {
    serviceB.perform();
  }
}

Assuming ServiceB is not annotated with @Component or any stereotype, what will happen?

medium

A. Compilation error due to missing import

B. The code will compile and run fine

C. ServiceB will be automatically created by Spring

D. Spring will throw a runtime error due to missing bean

Solution

1. Step 1: Check bean creation requirements

   Spring only manages classes annotated with @Component or similar. Since ServiceB lacks this, Spring won't create its bean.

2. Step 2: Understand autowiring consequences

   When Spring tries to inject serviceB, it finds no bean and throws a runtime error (NoSuchBeanDefinitionException).

3. Final Answer:

   Spring will throw a runtime error due to missing bean -> Option D

4. Quick Check:

   Missing @Component = runtime injection error [OK]

Hint: All injected classes must be annotated for Spring to manage [OK]

Common Mistakes:

• Assuming Spring creates beans without annotation
• Confusing compile errors with runtime errors
• Forgetting to annotate dependencies

5. You want to create two different implementations of an interface PaymentService and have Spring inject the correct one based on a custom qualifier. How should you use @Component to achieve this?

hard

A. Annotate only one implementation with @Component and inject by interface type

B. Annotate both implementations with @Component and use @Qualifier to specify which to inject

C. Use @Component only on the interface, not implementations

D. Create instances manually without @Component

Solution

1. Step 1: Annotate both implementations

   Both classes implementing PaymentService must be annotated with @Component so Spring manages them.

2. Step 2: Use @Qualifier to distinguish

   When injecting, use @Qualifier with the component name to tell Spring which implementation to use.

3. Final Answer:

   Annotate both implementations with @Component and use @Qualifier to specify which to inject -> Option B

4. Quick Check:

   Multiple components + qualifier = correct injection [OK]

Hint: Use @Component on all, @Qualifier to pick one [OK]

Common Mistakes:

• Annotating only one implementation
• Annotating interface instead of classes
• Not using @Qualifier when multiple beans exist