Bean Lifecycle

🔍 What Is It?

The Spring bean lifecycle is the sequence of events from when a bean is created to when it's destroyed.

Full lifecycle sequence:

1. Instantiation — constructor called
2. Dependency Injection — properties set, constructor/setter injection
3. BeanNameAware.setBeanName() — bean learns its name
4. BeanFactoryAware.setBeanFactory() — bean gets container reference
5. ApplicationContextAware.setApplicationContext() — bean gets context
6. BeanPostProcessor.postProcessBeforeInitialization() — pre-init processing
7. @PostConstruct method called
8. InitializingBean.afterPropertiesSet() — programmatic init
9. @Bean(initMethod="...") — custom init method
10. BeanPostProcessor.postProcessAfterInitialization() — post-init (AOP proxies created here)
11. Bean is ready — in use
12. @PreDestroy method called
13. DisposableBean.destroy() — programmatic cleanup
14. @Bean(destroyMethod="...") — custom destroy method

In practice, you only need:

• →@PostConstruct for initialization
• →@PreDestroy for cleanup

🎯 Why Do We Need It?

Lifecycle hooks let you:

• →Initialize resources after all dependencies are injected (cache warmup, connection validation)
• →Register listeners once the bean is fully set up
• →Clean up resources gracefully on shutdown (close connections, flush buffers)
• →Validate configuration at startup rather than at first use

Without lifecycle hooks, you'd have initialization logic in constructors (where dependencies might not be available) or scattered across the codebase.

🏗️ What Happens in Real Projects?

Common lifecycle patterns in enterprise apps:

• →@PostConstruct: warm up caches, validate external service connectivity, start background threads
• →@PreDestroy: close database connections, flush message queues, stop schedulers
• →BeanPostProcessor: AOP proxies are created here (every @Transactional bean goes through this)
• →ApplicationListener<ContextRefreshedEvent>: run code when ALL beans are initialized

⚙️ How It Works

@PostConstruct:

• →Runs after constructor AND after all @Autowired injections are complete
• →Safe to use dependencies here (unlike constructor, where DI may not be done)
• →Runs once per bean instance
• →If it throws, the application fails to start

@PreDestroy:

• →Runs when the ApplicationContext is closing
• →For web apps: triggered by JVM shutdown hook or explicit close()
• →Prototype-scoped beans: @PreDestroy is NOT called (Spring doesn't track them)
• →Runs in reverse order of initialization

BeanPostProcessor:

• →Runs for EVERY bean in the context
• →Used by Spring internally for AOP proxying, @Async, @Transactional
• →Implement BeanPostProcessor to add cross-cutting behavior to all beans

💻 Example

Bean Lifecycle in Practice — Real-world lifecycle hooks for initialization and cleanup.

@Service
@Slf4j
public class DatabaseHealthService {

    private final DataSource dataSource;
    private final AppProperties appProperties;
    private ScheduledExecutorService healthChecker;

    public DatabaseHealthService(DataSource dataSource, AppProperties appProperties) {
        this.dataSource = dataSource;
        this.appProperties = appProperties;
        // DON'T do initialization here — appProperties might not be fully bound yet
    }

    @PostConstruct  // All dependencies injected, safe to use them
    public void initialize() {
        log.info("Validating database connectivity...");
        try (Connection conn = dataSource.getConnection()) {
            boolean valid = conn.isValid(5); // 5 second timeout
            if (!valid) throw new IllegalStateException("Database connection invalid");
            log.info("Database connection validated successfully");
        } catch (SQLException e) {
            throw new IllegalStateException("Cannot connect to database at startup", e);
        }

        // Start background health checker
        healthChecker = Executors.newSingleThreadScheduledExecutor();
        healthChecker.scheduleAtFixedRate(
            this::checkHealth, 30, 30, TimeUnit.SECONDS
        );
        log.info("Database health checker started");
    }

    @PreDestroy  // Called when application shuts down
    public void cleanup() {
        log.info("Shutting down database health checker");
        if (healthChecker != null) {
            healthChecker.shutdown();
            try {
                healthChecker.awaitTermination(10, TimeUnit.SECONDS);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }

    private void checkHealth() {
        try (Connection conn = dataSource.getConnection()) {
            conn.isValid(2);
        } catch (SQLException e) {
            log.error("Database health check failed", e);
        }
    }
}

🤔 Common Confusions

🚨 Common Production Issues

✅ Best Practices

🏛️ Architect's Note

💬 Frequently Asked Questions

🎯 Key Takeaways

🔗 Related Topics

🎯 Practice this topic in interviews

↗ Where this topic fits