@Component, @Service, @Repository, @Controller in Spring Boot - Step-by-Step Execution

Concept Flow - @Component, @Service, @Repository, @Controller

Start Spring Boot App

↓

Scan for Annotations

↓

Find @Component/@Service/@Repository/@Controller

↓

Create Bean Instances

↓

Inject Beans where needed

↓

App runs with managed components

Spring Boot scans for these annotations, creates and manages objects (beans), and injects them where needed to run the app.

Execution Sample

Spring Boot

@Component
public class MyComponent {}

@Service
public class MyService {}

@Repository
public class MyRepository {}

@Controller
public class MyController {}

Defines four classes each marked with a Spring annotation to be managed as beans.

Execution Table

Step	Action	Annotation Found	Bean Created	Injection Point	Result
1	Start app and scan classes	None yet	No	No	Scanning begins
2	Find MyComponent class	@Component	Yes: MyComponent bean	No	Bean ready for injection
3	Find MyService class	@Service	Yes: MyService bean	No	Bean ready for injection
4	Find MyRepository class	@Repository	Yes: MyRepository bean	No	Bean ready for injection
5	Find MyController class	@Controller	Yes: MyController bean	No	Bean ready for injection
6	Inject beans into dependent classes	N/A	N/A	Yes	Beans wired where needed
7	App runs with all beans managed	N/A	N/A	N/A	App fully functional

💡 All annotated classes are detected, beans created, and injected; app starts successfully.

Variable Tracker

Bean Name	Start	After Scan	After Creation	After Injection	Final
MyComponent	Not found	Found	Created	Injected if needed	Ready
MyService	Not found	Found	Created	Injected if needed	Ready
MyRepository	Not found	Found	Created	Injected if needed	Ready
MyController	Not found	Found	Created	Injected if needed	Ready

Key Moments - 3 Insights

Why does Spring create objects for these classes automatically?

Because the classes have special annotations like @Component, Spring scans and creates beans for them as shown in execution_table steps 2-5.

What is the difference between @Component and @Service?

@Service is a specialized @Component for service layer logic, but both cause Spring to create beans. See execution_table steps 2 and 3 for both bean creations.

How does Spring know where to put these beans?

Spring injects beans into other classes marked for injection, as shown in execution_table step 6 where injection happens.

Visual Quiz - 3 Questions

Look at the execution_table, at which step is the MyRepository bean created?

A Step 3

B Step 5

C Step 4

D Step 6

💡 Hint

Check the 'Bean Created' column for MyRepository in the execution_table rows.

According to variable_tracker, what is the state of MyService after injection?

A Injected if needed

B Created but not injected

C Not found

D Destroyed

💡 Hint

Look at the 'After Injection' column for MyService in variable_tracker.

If a class is missing @Component or similar annotation, what happens during scanning?

A Spring creates a bean anyway

B Spring ignores the class

C Spring throws an error

D Spring injects it automatically

💡 Hint

Refer to execution_table step 1 where no annotation means no bean creation.

Concept Snapshot

@Component, @Service, @Repository, @Controller are Spring annotations.
They mark classes for Spring to create and manage as beans.
Spring scans these annotations at startup, creates beans, and injects them.
@Service is for service logic, @Repository for data access, @Controller for web controllers.
All are specializations of @Component.
Beans are injected where needed to run the app smoothly.

Full Transcript

In Spring Boot, classes marked with @Component, @Service, @Repository, or @Controller are automatically detected during app startup. Spring scans the code, finds these annotations, and creates bean instances for each. These beans are then injected into other classes that need them, enabling easy reuse and management. @Service is a specialized @Component for business logic, @Repository for data access, and @Controller for handling web requests. This process allows the app to run with all components managed by Spring, simplifying development and wiring.