Click on any phase of the lifecycle diagram to understand how Spring manages your objects.

Simulation Legend

Standard Bean Object

AOP Proxy Wrapper

BeanDef

IoC Container (ApplicationContext)

Configuration

@Component / XML

Instantiation

Constructor Call

Dependency Injection

Populate Properties

Initialization

@PostConstruct / afterPropertiesSet

BeanPostProcessor

postProcessBeforeInitialization

BeanPostProcessor

postProcessAfterInitialization (AOP)

Ready for Use

Cached in Context

Destruction

@PreDestroy / Context Close

The Spring Bean Lifecycle

At the heart of the Spring Framework is the **IoC (Inversion of Control) Container**, represented by the `ApplicationContext`. Instead of your code constructing objects using the `new` keyword, Spring acts as a factory. It instantiates, configures, and manages the entire lifespan of these objects, which are called **Beans**.

Inversion of Control

You surrender control of object creation to the framework. You simply declare *what* you need (via interfaces/annotations), and Spring provides the fully configured implementation at runtime.

Dependency Injection

A specific form of IoC. When Spring creates Bean A, and Bean A needs Bean B to function, Spring automatically "injects" Bean B into Bean A (via constructors or setters) before Bean A is ready.

Lifecycle Phases in Detail

1. Instantiation & Dependency Injection

Spring reads your `@Component` classes or `@Bean` methods, uses reflection to call the constructor, and immediately injects required dependencies.

@Service
public class OrderService {
    private final PaymentProcessor processor;

    // Constructor Injection (Recommended)
    @Autowired 
    public OrderService(PaymentProcessor processor) {
        this.processor = processor; // Injected by Spring
    }
}

2. Initialization Callbacks (@PostConstruct)

Once dependencies are injected, the bean isn't fully ready yet. You might need to open a file, validate properties, or warm up a cache. Spring calls initialization methods you define.

@Component
public class CacheManager {
    
    @PostConstruct
    public void initCache() {
        // Runs AFTER dependencies are injected
        System.out.println("Loading initial data into cache...");
    }
}

3. BeanPostProcessors & AOP Proxies

This is where Spring's magic happens. `BeanPostProcessor`s are special hooks that can modify your bean *before* or *after* the initialization callbacks.

Crucially, if a bean requires AOP (Aspect-Oriented Programming) like `@Transactional`, `@Async`, or Method Security, Spring's `postProcessAfterInitialization` doesn't return your original object. It returns a dynamically generated **Proxy** object that wraps yours.

@Service
public class UserService {
    
    @Transactional // Triggers proxy creation during lifecycle
    public void createUser() {
        // DB logic...
    }
}

4. Destruction Callbacks (@PreDestroy)

When the application shuts down, singleton beans are given a chance to gracefully release resources, close connections, or save state.

@Component
public class DatabaseConnectionPool {
    
    @PreDestroy
    public void cleanup() {
        // Runs before the bean is garbage collected by Spring
        System.out.println("Closing all database connections...");
    }
}

Before any object is created, Spring reads configuration metadata to understand what to build. This comes from @Component, @Service, @Configuration classes, or older XML files.

Spring converts this metadata into an internal BeanDefinition recipe, describing the class name, scope, and dependencies.

Spring uses reflection to instantiate the object, typically by calling its default constructor or a constructor annotated with @Autowired.

At this exact moment, the object exists in memory, but it is "raw". Its properties are null, and its dependencies are not yet wired.

Also known as "Populate Properties". Spring looks at the BeanDefinition and finds all other beans required by this object.

It injects them via Setter methods, fields (not recommended), or Constructor arguments. If a dependency doesn't exist yet, Spring pauses this bean's creation and goes to create the dependency first.

BeanPostProcessor is an extension point. Spring calls the postProcessBeforeInitialization method of all registered processors.

Framework internals use this to process annotations like @Value or custom setup logic before the bean's own init method is called.

The bean executes custom initialization logic. It can now safely use its injected dependencies to fetch data, open sockets, or validate state.

Invoked methods include:

Methods annotated with @PostConstruct
afterPropertiesSet() if implementing InitializingBean
Custom init-method declared in config.

The most crucial step for Spring's advanced features. postProcessAfterInitialization is called.

If your bean uses AOP (e.g., @Transactional, @Async, @PreAuthorize), Spring detects it here. Instead of returning your raw object, it generates a dynamic **Proxy Object** that wraps yours, adding the transaction/security logic around your methods.

The bean (or its proxy wrapper) is fully configured and operational.

If it is a Singleton (the default scope), Spring caches it in the ApplicationContext. Subsequent requests for this bean type will return this exact, cached instance.

When the ApplicationContext is closed (e.g., app shutdown), Spring destroys all cached Singleton beans.

It calls methods annotated with @PreDestroy or destroy() from DisposableBean, allowing you to gracefully release resources.

Spring Bean Lifecycle

Component Inspector

The Spring Bean Lifecycle

Inversion of Control

Dependency Injection

Lifecycle Phases in Detail

1. Instantiation & Dependency Injection

2. Initialization Callbacks (@PostConstruct)

3. BeanPostProcessors & AOP Proxies

4. Destruction Callbacks (@PreDestroy)

Configuration

Instantiation

Dependency Injection

BeanPostProcessor (Before)

Initialization

BeanPostProcessor (After)

Ready for Use

Destruction