@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.