Bean concept in Spring in Spring Boot - Step-by-Step Execution

Concept Flow - Bean concept in Spring

Start Application

↓

Spring Container Initializes

↓

Scan for @Component/@Bean

↓

Create Bean Instances

↓

Inject Dependencies

↓

Beans Ready to Use

↓

Application Runs Using Beans

↓

Shutdown -> Beans Destroyed

Spring starts, scans for beans, creates and injects them, then runs the app using these beans.

Execution Sample

Spring Boot

@Component
public class MyService {
  @Autowired
  private MyRepository repo;
}

Defines a bean MyService with an injected dependency MyRepository.

Execution Table

Step	Action	Bean Name	State	Details
1	Start Spring Application	-	Initializing	Spring container starts up
2	Scan Classes	-	Scanning	Finds @Component MyService and @Repository MyRepository
3	Create Bean	myRepository	Created	Instance of MyRepository created
4	Create Bean	myService	Created	Instance of MyService created
5	Inject Dependency	myService	Dependency Injected	myRepository injected into myService
6	Beans Ready	-	Ready	Beans are ready for use in application
7	Application Running	-	Running	Application uses beans to handle requests
8	Shutdown	-	Destroyed	Beans destroyed and container closed

💡 Spring application stops, beans are destroyed and container shuts down

Variable Tracker

Bean	Start	After Creation	After Injection	Final State
myRepository	Not Created	Created	N/A	Ready
myService	Not Created	Created	Injected myRepository	Ready

Key Moments - 3 Insights

Why does Spring create beans automatically?

Spring scans classes with @Component or @Bean annotations and creates instances to manage them, as shown in steps 2-4 in the execution table.

How does dependency injection work in Spring beans?

Spring injects required dependencies into beans after creating them, like myRepository injected into myService at step 5.

What happens to beans when the application stops?

Beans are destroyed and resources cleaned up during shutdown, as shown in step 8.

Visual Quiz - 3 Questions

Look at the execution table, at which step is the myService bean created?

A Step 4

B Step 3

C Step 5

D Step 6

💡 Hint

Check the 'Bean Name' and 'Action' columns in the execution table rows 3 and 4.

According to the variable tracker, what is the state of myRepository after injection?

A Not Created

B Created

C Injected into myService

D Destroyed

💡 Hint

Look at the 'After Creation' and 'After Injection' columns for myRepository in the variable tracker.

If the @Autowired annotation was missing on myService, what would change in the execution table?

A Step 3 would not create myRepository

B Step 4 would not create myService

C Step 5 would not inject myRepository into myService

D Beans would not be destroyed at shutdown

💡 Hint

Focus on the 'Inject Dependency' action in step 5 of the execution table.

Concept Snapshot

Spring Bean Concept:
- Beans are objects managed by Spring container.
- Use @Component or @Bean to define beans.
- Spring auto-creates and injects dependencies (@Autowired).
- Beans lifecycle: creation -> injection -> use -> destruction.
- Beans enable loose coupling and easier testing.

Full Transcript

When a Spring application starts, the Spring container initializes and scans the code for classes marked as beans using annotations like @Component or @Bean. It then creates instances of these beans. After creation, Spring injects any dependencies marked with @Autowired into these beans. Once all beans are ready, the application runs using these managed objects. When the application stops, Spring destroys the beans and cleans up resources. This process helps manage object lifecycles and dependencies automatically.

Practice

1. What is a Bean in the Spring framework?

easy

A. A type of Java exception

B. A database connection

C. An object managed by the Spring container

D. A user interface component

Solution

1. Step 1: Understand Spring's role

   Spring manages objects to help organize and connect parts of an application.

2. Step 2: Define what a Bean is

   A Bean is any object that Spring creates and manages in its container.

3. Final Answer:

   An object managed by the Spring container -> Option C

4. Quick Check:

   Bean = Managed object [OK]

Hint: Beans are Spring-managed objects, not UI or exceptions [OK]

Common Mistakes:

• Confusing beans with database connections
• Thinking beans are UI elements
• Assuming beans are exceptions

2. Which annotation is used to declare a class as a Spring Bean?

easy

A. @Qualifier

B. @Component

C. @Autowired

D. @RequestMapping

Solution

1. Step 1: Identify annotations for beans

   @Component marks a class as a Spring-managed bean.

2. Step 2: Differentiate from other annotations

   @Qualifier specifies which bean to inject, @Autowired injects beans, @RequestMapping maps web requests.

3. Final Answer:

   @Component -> Option B

4. Quick Check:

   @Component = Bean declaration [OK]

Hint: Use @Component to declare beans; others serve different roles [OK]

Common Mistakes:

• Confusing @Autowired with bean declaration
• Using @RequestMapping for beans
• Thinking @Qualifier declares beans

3. Given the code below, what will be printed (assuming the @Autowired field and System.out.println are inside a Spring-managed class)?

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

@Autowired
MyBean myBean;

System.out.println(myBean.greet());

medium

A. Hello Spring

B. null

C. Compilation error

D. No output

Solution

1. Step 1: Understand @Component and @Autowired

   @Component creates the bean, @Autowired injects it into the field.

2. Step 2: Check method call output

   Calling greet() returns "Hello Spring", so it prints that string.

3. Final Answer:

   Hello Spring -> Option A

4. Quick Check:

   Injected bean method returns greeting [OK]

Hint: Autowired injects bean; method returns greeting string [OK]

Common Mistakes:

• Assuming null because of missing initialization
• Thinking it causes compile error
• Expecting no output without System.out.println

4. What is wrong with this Spring bean declaration?

@Component
public class MyService {
  @Autowired
  private MyRepository repo;

  public void doWork() {
    repo.save();
  }
}

Assuming MyRepository is not annotated as a bean.

medium

A. No @Autowired on MyService class

B. Missing @Service annotation on MyService

C. Method doWork() should return a value

D. MyRepository is not a Spring bean, so injection fails

Solution

1. Step 1: Check bean injection requirements

   Spring can only inject beans that are managed by the container.

2. Step 2: Identify missing bean annotation

   MyRepository lacks @Component or similar, so Spring cannot inject it.

3. Final Answer:

   MyRepository is not a Spring bean, so injection fails -> Option D

4. Quick Check:

   Injection requires bean annotation [OK]

Hint: Injected classes must be beans too [OK]

Common Mistakes:

• Thinking @Service is mandatory for injection
• Assuming method must return value
• Confusing @Autowired placement

5. You want to create a bean that returns a customized object. Which method correctly defines a bean using Java configuration?

hard

A. @Bean
public MyBean myBean() {
return new MyBean("custom");
}

B. @Component
public MyBean myBean() {
return new MyBean("custom");
}

C. public MyBean myBean() {
return new MyBean("custom");
}

D. @Autowired
public MyBean myBean() {
return new MyBean("custom");
}

Solution

1. Step 1: Understand @Bean usage

   @Bean annotation on a method inside a @Configuration class defines a bean returned by that method.

2. Step 2: Differentiate from other annotations

   @Component is for classes, not methods; @Autowired injects dependencies, not defines beans.

3. Final Answer:

   @Bean public MyBean myBean() { return new MyBean("custom"); } -> Option A

4. Quick Check:

   @Bean method returns custom bean [OK]

Hint: Use @Bean on methods inside @Configuration classes [OK]

Common Mistakes:

• Using @Component on methods instead of classes
• Omitting @Bean annotation
• Confusing @Autowired with bean creation