Spring Boot Bean Lifecycle: Phases, Callbacks and Examples

import jakarta.annotation.PostConstruct;   // Spring Boot 3+ / Spring 6
import jakarta.annotation.PreDestroy;    // Spring Boot 2.x uses javax.annotation.*

@Component
@Slf4j
public class LifecycleDemoBean implements BeanNameAware, ApplicationContextAware,
        InitializingBean, DisposableBean {

    public LifecycleDemoBean() { log.info("1. Constructor"); }

    @Autowired
    public void setEnvironment(Environment env) { log.info("2. Dependency injection (setter)"); }

    @Override
    public void setBeanName(String name) { log.info("3. BeanNameAware -> {}", name); }

    @Override
    public void setApplicationContext(ApplicationContext ctx) { log.info("3. ApplicationContextAware"); }

    @PostConstruct
    public void postConstruct() { log.info("4. @PostConstruct"); }

    @Override
    public void afterPropertiesSet() { log.info("5. InitializingBean.afterPropertiesSet"); }

    @PreDestroy
    public void preDestroy() { log.info("6. @PreDestroy"); }

    @Override
    public void destroy() { log.info("7. DisposableBean.destroy"); }
}

// Console output at startup/shutdown:
// 1. Constructor
// 2. Dependency injection (setter)
// 3. BeanNameAware -> lifecycleDemoBean
// 3. ApplicationContextAware
// 4. @PostConstruct
// 5. InitializingBean.afterPropertiesSet
// ... application runs ...
// 6. @PreDestroy
// 7. DisposableBean.destroy

// WAY 1 — @PostConstruct (RECOMMENDED):
@Component
public class DatabaseConnectionPool {

    private final DataSourceProperties properties;
    private HikariDataSource pool;

    public DatabaseConnectionPool(DataSourceProperties properties) {
        this.properties = properties;
        // Don't initialize here — dependencies may not be fully ready
    }

    @PostConstruct
    public void initialize() {
        // Called AFTER constructor AND after all @Autowired injection
        // All dependencies are guaranteed to be set and ready
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl(properties.getUrl());
        config.setUsername(properties.getUsername());
        config.setPassword(properties.getPassword());
        config.setMaximumPoolSize(10);
        this.pool = new HikariDataSource(config);
        System.out.println("Connection pool initialized: " + pool.getPoolName());
    }
}

// WAY 2 — InitializingBean interface:
@Component
public class CacheWarmer implements InitializingBean {

    private final ProductRepository productRepository;
    private final CacheManager cacheManager;

    public CacheWarmer(ProductRepository productRepository, CacheManager cacheManager) {
        this.productRepository = productRepository;
        this.cacheManager = cacheManager;
    }

    @Override
    public void afterPropertiesSet() {
        // Same timing as @PostConstruct — called after all injection
        List<Product> topProducts = productRepository.findTop100ByOrderBySalesDesc();
        Cache cache = cacheManager.getCache("products");
        topProducts.forEach(p -> cache.put(p.getId(), p));
        System.out.println("Cache warmed with " + topProducts.size() + " products");
    }
}

// WAY 3 — Custom init-method declared on @Bean:
@Configuration
public class InfrastructureConfig {

    @Bean(initMethod = "start")
    public SchedulerService schedulerService() {
        return new SchedulerService();
    }
}

public class SchedulerService {
    public void start() {
        // Called by Spring after injection — equivalent to @PostConstruct
        System.out.println("Scheduler started");
    }
}

// ORDER when all three are present on the same bean:
// 1. @PostConstruct
// 2. InitializingBean.afterPropertiesSet()
// 3. Custom init-method

// WAY 1 — @PreDestroy (RECOMMENDED):
@Component
public class MessageQueueConsumer {

    private volatile boolean running = false;
    private ExecutorService executor;

    @PostConstruct
    public void start() {
        running = true;
        executor = Executors.newFixedThreadPool(5);
        executor.submit(this::consumeMessages);
        System.out.println("Message queue consumer started");
    }

    @PreDestroy
    public void stop() {
        // Called when ApplicationContext is closing
        // Spring Boot graceful shutdown waits for this before JVM exits
        running = false;
        executor.shutdown();
        try {
            if (!executor.awaitTermination(30, TimeUnit.SECONDS)) {
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
        }
        System.out.println("Message queue consumer stopped — drained cleanly");
    }

    private void consumeMessages() {
        while (running) {
            // process messages...
        }
    }
}

// WAY 2 — DisposableBean interface:
@Component
public class SearchIndexManager implements DisposableBean {

    private final ElasticsearchClient client;

    public SearchIndexManager(ElasticsearchClient client) {
        this.client = client;
    }

    @Override
    public void destroy() {
        // Called after @PreDestroy — flush pending index operations
        client.indices().flush();
        client.close();
        System.out.println("Search index flushed and client closed");
    }
}

// WAY 3 — Custom destroyMethod declared on @Bean:
@Configuration
public class InfrastructureConfig {

    @Bean(destroyMethod = "shutdown")
    public ThreadPoolTaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(20);
        executor.initialize();
        return executor;
    }
    // Spring calls executor.shutdown() on context close automatically
}

// ORDER when all three are present on the same bean:
// 1. @PreDestroy
// 2. DisposableBean.destroy()
// 3. Custom destroyMethod

// IMPORTANT: @PreDestroy is only called for singleton-scoped beans.
// Prototype-scoped beans are NOT destroyed by Spring —
// you are responsible for releasing their resources.

// BeanPostProcessor interface — intercepts every bean:
public interface BeanPostProcessor {
    // Called BEFORE @PostConstruct:
    Object postProcessBeforeInitialization(Object bean, String beanName);

    // Called AFTER @PostConstruct (where AOP proxies are created):
    Object postProcessAfterInitialization(Object bean, String beanName);
}

// Custom BeanPostProcessor — example: measure initialization time of every bean:
@Component
public class InitializationTimingPostProcessor implements BeanPostProcessor {

    private final Map<String, Long> startTimes = new ConcurrentHashMap<>();

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        startTimes.put(beanName, System.currentTimeMillis());
        return bean;   // return the bean unchanged (or return a modified version)
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        Long startTime = startTimes.remove(beanName);
        if (startTime != null) {
            long elapsed = System.currentTimeMillis() - startTime;
            if (elapsed > 100) {   // only log slow initializations
                System.out.printf("Slow bean init: %s took %dms%n", beanName, elapsed);
            }
        }
        return bean;
    }
}

// Built-in BeanPostProcessors Spring uses internally:
// AutowiredAnnotationBeanPostProcessor   — processes @Autowired, @Value, @Inject
// CommonAnnotationBeanPostProcessor      — processes @PostConstruct, @PreDestroy, @Resource
// PersistenceAnnotationBeanPostProcessor — processes @PersistenceContext, @PersistenceUnit
// AbstractAdvisorAutoProxyCreator        — creates AOP proxies for @Transactional, @Cacheable

// BeanFactoryPostProcessor — runs against BeanDefinitions BEFORE instantiation:
@Component
public class CustomBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // Modify BeanDefinitions before any beans are created
        BeanDefinition userServiceDef = beanFactory.getBeanDefinition("userService");
        userServiceDef.setScope(BeanDefinition.SCOPE_PROTOTYPE);   // change scope
        System.out.println("Modified userService scope to prototype");
    }
}

// SINGLETON (default) — one instance for the entire ApplicationContext:
@Component
// or @Scope("singleton") — explicit but redundant
public class UserService {
    // Created once at startup (or first use if @Lazy)
    // @PostConstruct called once
    // @PreDestroy called once on shutdown
    // Shared by every bean that injects UserService
}

// PROTOTYPE — new instance every time it's requested:
@Component
@Scope("prototype")
public class ReportGenerator {
    // New instance created every time @Autowired or context.getBean() is called
    // @PostConstruct called on each new instance
    // @PreDestroy NOT called — you are responsible for cleanup
    // Never shared — each caller gets their own instance
}

// REQUEST — one instance per HTTP request (web apps only):
@Component
@Scope(value = WebApplicationContext.SCOPE_REQUEST,
       proxyMode = ScopedProxyMode.TARGET_CLASS)
public class RequestContext {
    private String requestId = UUID.randomUUID().toString();
    private long startTime = System.currentTimeMillis();
    // Created at request start, destroyed at request end
    // proxyMode required when injecting into singleton beans
}

// SESSION — one instance per HTTP session:
@Component
@Scope(value = WebApplicationContext.SCOPE_SESSION,
       proxyMode = ScopedProxyMode.TARGET_CLASS)
public class UserSessionData {
    private String userId;
    private List<String> recentSearches = new ArrayList<>();
    // Created when session starts, destroyed when session expires/invalidates
}

// Injecting a prototype into a singleton — the problem:
@Service  // singleton
public class OrderProcessor {

    @Autowired
    private ReportGenerator reportGenerator;  // prototype — but only injected ONCE
    // Every call to orderProcessor.process() uses the SAME ReportGenerator instance
    // The singleton holds it — the prototype behavior is effectively lost

    // FIX — look up a new prototype instance each time:
    @Autowired
    private ApplicationContext context;

    public void process(Order order) {
        ReportGenerator generator = context.getBean(ReportGenerator.class); // fresh instance
        generator.generate(order);
    }
}

@Component
@Slf4j
public class ApplicationLifecycleListener {

    @EventListener(ContextRefreshedEvent.class)
    public void onContextRefreshed(ContextRefreshedEvent event) {
        log.info("Context refreshed - all singleton beans created");
    }

    // Published AFTER all runners have finished:
    @EventListener(ApplicationReadyEvent.class)
    public void onApplicationReady(ApplicationReadyEvent event) {
        log.info("Application ready - safe to accept traffic, start schedulers");
    }

    // Published BEFORE @PreDestroy methods:
    @EventListener(ContextClosedEvent.class)
    public void onContextClosing(ContextClosedEvent event) {
        log.info("Context closing - flush pending operations");
    }
}

// ApplicationRunner - runs after context refresh, BEFORE ApplicationReadyEvent:
@Component
@Order(1)   // control execution order when multiple runners exist
public class DataMigrationRunner implements ApplicationRunner {

    private final MigrationService migrationService;

    public DataMigrationRunner(MigrationService migrationService) {
        this.migrationService = migrationService;
    }

    @Override
    public void run(ApplicationArguments args) {
        migrationService.migrate();
    }
}

// CommandLineRunner - same timing, receives raw String[] args:
@Component
@Order(2)   // runs after DataMigrationRunner
public class CacheWarmupRunner implements CommandLineRunner {

    private final CacheService cacheService;

    public CacheWarmupRunner(CacheService cacheService) {
        this.cacheService = cacheService;
    }

    @Override
    public void run(String... args) {
        cacheService.warmAll();
    }
}

// SmartLifecycle - fine-grained control over start/stop order:
@Component
public class BackgroundJobScheduler implements SmartLifecycle {

    private volatile boolean running = false;

    @Override public void start() { running = true; /* start threads */ }
    @Override public void stop()  { running = false; /* stop gracefully */ }
    @Override public boolean isRunning() { return running; }
    @Override public int getPhase() { return 0; } // lower phase starts first, stops last
}

// @Lazy on a single bean — created on first use:
@Service
@Lazy
public class ReportingService {
    // NOT created at startup
    // Created the first time something requests or injects ReportingService
    // Startup is faster — first request that needs ReportingService is slower
}

// @Lazy on an injection point — lazy proxy injected:
@Service
public class UserService {

    @Autowired
    @Lazy
    private ReportingService reportingService;
    // UserService is created eagerly at startup
    // A proxy is injected for reportingService
    // ReportingService itself is created on the first call to reportingService.xxx()
}

// Global lazy initialization — ALL beans lazy (Spring Boot 2.2+):
// application.properties:
// spring.main.lazy-initialization=true

// When to use lazy initialization:
// - Large applications with many beans where startup time matters
// - Beans that are rarely used (admin tools, reporting services)
// - Development environments where you want faster restarts

// When NOT to use lazy initialization:
// - Production critical path beans (startup errors surface at first request, not startup)
// - Beans with @PostConstruct that must run before the app accepts traffic
// - Database migration (Flyway) — must run before any DB access

// @Lazy in @Configuration:
@Configuration
public class AppConfig {

    @Bean
    @Lazy
    public ExpensiveService expensiveService() {
        // Created only when first requested — not at startup
        return new ExpensiveService();
    }
}

// Smart strategy — lazy globally, eager for critical beans:
// spring.main.lazy-initialization=true (in application.properties)

@Component
@Lazy(false)   // override global lazy — always eager:
public class DatabaseHealthChecker {
    @PostConstruct
    public void checkDatabase() {
        // This MUST run at startup — mark as eager
    }
}

@Service
@Slf4j
public class KafkaConsumerService {

    private final KafkaProperties kafkaProperties;
    private final OrderService orderService;
    private volatile KafkaConsumer<String, String> consumer;
    private ExecutorService executorService;
    private volatile boolean consuming = false;

    // Constructor-injected dependencies are available here
    public KafkaConsumerService(KafkaProperties kafkaProperties, OrderService orderService) {
        this.kafkaProperties = kafkaProperties;
        this.orderService = orderService;
    }

    // Lightweight validation only - fail fast at startup
    @PostConstruct
    public void validate() {
        if (kafkaProperties.getBootstrapServers() == null) {
            throw new IllegalStateException("Kafka bootstrap servers not configured");
        }
    }

    // Called by KafkaStartupRunner after the context is ready
    public void startConsuming() {
        consuming = true;
        executorService = Executors.newSingleThreadExecutor();
        executorService.submit(() -> {
            // Create, poll and close the consumer in the SAME thread
            Properties props = new Properties();
            props.put("bootstrap.servers", kafkaProperties.getBootstrapServers());
            props.put("group.id", kafkaProperties.getGroupId());
            props.put("key.deserializer", StringDeserializer.class.getName());
            props.put("value.deserializer", StringDeserializer.class.getName());
            props.put("enable.auto.commit", "false");

            consumer = new KafkaConsumer<>(props);
            try (consumer) {
                consumer.subscribe(List.of("orders"));
                while (consuming) {
                    ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
                    records.forEach(r -> orderService.processOrderEvent(r.value()));
                    if (!records.isEmpty()) consumer.commitSync();
                }
            } catch (WakeupException e) {
                // expected on shutdown
            }
            log.info("Kafka consumer loop exited");
        });
    }

    @PreDestroy
    public void shutdown() throws InterruptedException {
        consuming = false;
        if (consumer != null) consumer.wakeup();   // only thread-safe consumer method
        if (executorService != null) {
            executorService.shutdown();
            executorService.awaitTermination(10, TimeUnit.SECONDS);
        }
        log.info("Kafka consumer cleanly shut down");
    }
}

@Component
@Order(Ordered.LOWEST_PRECEDENCE)   // run last, after all other runners
public class KafkaStartupRunner implements ApplicationRunner {
    private final KafkaConsumerService service;

    public KafkaStartupRunner(KafkaConsumerService service) { this.service = service; }

    @Override
    public void run(ApplicationArguments args) { service.startConsuming(); }
}