Bean lifecycle overview in Spring Boot - Step-by-Step Execution

Concept Flow - Bean lifecycle overview

Bean Definition Loaded

↓

Bean Instantiation

↓

Populate Properties

↓

BeanNameAware.setBeanName()

↓

BeanFactoryAware.setBeanFactory()

↓

Pre-initialization PostProcessors

↓

InitializingBean.afterPropertiesSet()

↓

Custom init-method

↓

Bean Ready to Use

↓

Container Shutdown

↓

DisposableBean.destroy()

↓

Custom destroy-method

↓

Bean Destroyed

This flow shows the main steps a Spring Bean goes through from creation to destruction.

Execution Sample

Spring Boot

public class MyBean implements InitializingBean, DisposableBean {
  @Override
  public void afterPropertiesSet() { System.out.println("Init"); }
  @Override
  public void destroy() { System.out.println("Destroy"); }
}

A simple bean that prints messages during initialization and destruction phases.

Execution Table

Step	Action	Method Called	State/Output
1	Bean definition loaded by Spring	N/A	Bean metadata ready
2	Spring creates bean instance	Constructor	Bean object created
3	Spring sets bean properties	Setter methods	Properties set
4	Spring calls setBeanName()	BeanNameAware.setBeanName()	Bean name injected
5	Spring calls setBeanFactory()	BeanFactoryAware.setBeanFactory()	Bean factory injected
6	Spring applies pre-initialization processors	BeanPostProcessor.postProcessBeforeInitialization()	Bean processed
7	Spring calls afterPropertiesSet()	InitializingBean.afterPropertiesSet()	Custom init logic runs
8	Spring calls custom init-method	Custom init method	Additional init logic runs
9	Bean is ready for use	N/A	Bean fully initialized
10	Container shutdown begins	N/A	Shutdown triggered
11	Spring calls destroy()	DisposableBean.destroy()	Cleanup logic runs
12	Spring calls custom destroy-method	Custom destroy method	Additional cleanup runs
13	Bean destroyed and removed	N/A	Bean lifecycle ends

💡 Bean lifecycle ends after destruction methods complete during container shutdown.

Variable Tracker

Variable	Start	After Instantiation	After Properties Set	After Initialization	After Destruction
Bean Instance	null	Created	Properties Set	Initialized	Destroyed
Bean Name	null	Injected	Injected	Injected	Injected
Bean Factory	null	Injected	Injected	Injected	Injected

Key Moments - 3 Insights

Why does Spring call setBeanName() before initialization?

Spring calls setBeanName() early so the bean knows its own name before any initialization logic runs, as shown in step 4 of the execution_table.

What is the difference between afterPropertiesSet() and a custom init-method?

afterPropertiesSet() is from the InitializingBean interface and runs automatically, while a custom init-method is a user-defined method configured in the bean definition; both run during initialization (steps 7 and 8).

When does the bean get destroyed?

The bean is destroyed during container shutdown, after the destroy() method and custom destroy-method run, as shown in steps 11-13.

Visual Quiz - 3 Questions

Look at the execution_table, at which step does Spring inject the bean's name?

A Step 2

B Step 4

C Step 7

D Step 10

💡 Hint

Check the 'Method Called' column for setBeanName() in the execution_table.

According to variable_tracker, what is the state of the Bean Instance after properties are set?

A Properties Set

B Created

C Destroyed

D Initialized

💡 Hint

Look at the 'After Properties Set' column for 'Bean Instance' in variable_tracker.

If the custom init-method is removed, which step in the execution_table would be skipped?

A Step 7

B Step 11

C Step 8

D Step 4

💡 Hint

Step 8 shows the custom init-method call in the execution_table.

Concept Snapshot

Bean lifecycle in Spring Boot:
1. Bean is instantiated and properties set.
2. Awareness interfaces inject context (name, factory).
3. Initialization callbacks run (afterPropertiesSet, custom init).
4. Bean is ready for use.
5. On shutdown, destroy callbacks run (destroy, custom destroy).
This ensures beans are properly prepared and cleaned up.

Full Transcript

The Spring Boot bean lifecycle starts when the container loads the bean definition. Spring creates the bean instance and sets its properties. Then, it calls awareness methods like setBeanName and setBeanFactory to inject context. Before the bean is ready, Spring runs initialization callbacks such as afterPropertiesSet and any custom init-method. After initialization, the bean is ready for use. When the container shuts down, Spring calls destroy methods to clean up resources. This lifecycle ensures beans are properly created, initialized, and destroyed in an orderly way.

Practice

1. Which of the following best describes the lifecycle of a Spring bean?

easy

A. Creation, initialization, use, and destruction

B. Compilation, execution, and garbage collection

C. Declaration, inheritance, and polymorphism

D. Loading, linking, and running

Solution

1. Step 1: Understand Spring bean lifecycle phases

   Spring beans go through creation, initialization, usage, and destruction phases during their lifecycle.

2. Step 2: Compare options with lifecycle phases

   Only Creation, initialization, use, and destruction correctly lists these phases. Other options describe unrelated programming concepts.

3. Final Answer:

   Creation, initialization, use, and destruction -> Option A

4. Quick Check:

   Bean lifecycle = Creation, init, use, destroy [OK]

Hint: Remember bean lifecycle phases: create, init, use, destroy [OK]

Common Mistakes:

• Confusing bean lifecycle with Java program lifecycle
• Mixing bean lifecycle with object-oriented concepts
• Thinking lifecycle only involves creation and destruction

2. Which annotation is used in Spring to run a method after a bean's properties have been set?

easy

A. @PostConstruct

B. @PreDestroy

C. @Autowired

D. @Bean

Solution

1. Step 1: Identify annotation for post-initialization

   @PostConstruct is the annotation used to mark a method to run after bean properties are set.

2. Step 2: Eliminate other annotations

   @PreDestroy runs before destruction, @Autowired injects dependencies, and @Bean defines a bean method.

3. Final Answer:

   @PostConstruct -> Option A

4. Quick Check:

   @PostConstruct runs after properties set [OK]

Hint: PostConstruct runs after init, PreDestroy before destroy [OK]

Common Mistakes:

• Confusing @PreDestroy with @PostConstruct
• Using @Autowired for lifecycle methods
• Thinking @Bean runs after initialization

3. Given this Spring bean code snippet, what will be printed when the bean is initialized?

@Component
public class MyBean {
  @PostConstruct
  public void init() {
    System.out.println("Bean initialized");
  }
}

medium

A. Bean destroyed

B. No output

C. Bean initialized

D. Compilation error

Solution

1. Step 1: Understand @PostConstruct behavior

   The method annotated with @PostConstruct runs after the bean is created and properties set, printing "Bean initialized".

2. Step 2: Check output possibilities

   Since the method prints a message on init, output will be "Bean initialized". No errors or destruction messages occur here.

3. Final Answer:

   Bean initialized -> Option C

4. Quick Check:

   @PostConstruct prints "Bean initialized" [OK]

Hint: PostConstruct method runs once after bean creation [OK]

Common Mistakes:

• Expecting output on bean destruction instead
• Thinking no output occurs without explicit call
• Confusing syntax causing compilation errors

4. What is wrong with this Spring bean code if the cleanup() method is never called?

@Component
public class MyBean {
  public void cleanup() {
    System.out.println("Cleaning up");
  }
}

medium

A. cleanup method should be static

B. Missing @PreDestroy annotation on cleanup method

C. Missing @PostConstruct annotation on cleanup method

D. cleanup method must return a value

Solution

1. Step 1: Identify lifecycle annotation for destruction

   The cleanup method should be annotated with @PreDestroy to run before bean destruction.

2. Step 2: Check other options for correctness

   @PostConstruct is for initialization, static or return value are not required for lifecycle methods.

3. Final Answer:

   Missing @PreDestroy annotation on cleanup method -> Option B

4. Quick Check:

   @PreDestroy needed to run cleanup before destroy [OK]

Hint: Use @PreDestroy to run code before bean destruction [OK]

Common Mistakes:

• Using @PostConstruct instead of @PreDestroy for cleanup
• Making cleanup static unnecessarily
• Expecting cleanup to run without annotation

5. You want to ensure a Spring bean runs a method both after initialization and before destruction. Which combination correctly achieves this?

hard

A. Implement InitializingBean interface only

B. Annotate the same method with both @PostConstruct and @PreDestroy

C. Use @Autowired on init method and @PreDestroy on destroy method

D. Annotate one method with @PostConstruct and another with @PreDestroy

Solution

1. Step 1: Understand lifecycle annotations usage

   @PostConstruct runs after initialization, @PreDestroy runs before destruction; they must be on separate methods.

2. Step 2: Evaluate other options

   Annotating the same method with both annotations is invalid. @Autowired is for injection, not lifecycle. Implementing InitializingBean interface only handles post-initialization but not destruction.

3. Final Answer:

   Annotate one method with @PostConstruct and another with @PreDestroy -> Option D

4. Quick Check:

   Separate methods with @PostConstruct and @PreDestroy [OK]

Hint: Use separate methods for init (@PostConstruct) and destroy (@PreDestroy) [OK]

Common Mistakes:

• Trying to use one method for both init and destroy
• Confusing @Autowired with lifecycle annotations
• Using InitializingBean interface only