Bean Lifecycle & Scopes — The Complete Interview Guide

// You can inspect BeanDefinitions at runtime
@Component
public class BeanDefinitionInspector implements ApplicationContextAware {

    @Override
    public void setApplicationContext(ApplicationContext ctx) {
        ConfigurableApplicationContext configCtx = (ConfigurableApplicationContext) ctx;
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) configCtx.getBeanFactory();

        BeanDefinition def = registry.getBeanDefinition("paymentService");
        System.out.println("Class: " + def.getBeanClassName());
        System.out.println("Scope: " + def.getScope());
        System.out.println("Lazy: " + def.isLazyInit());
    }
}

@Service
public class PaymentService {

    @Autowired  // Step 3: injected via reflection AFTER constructor
    private AuditService auditService;

    @Value("${payment.gateway.timeout:5000}")  // Step 3: resolved from properties
    private int gatewayTimeout;

    private NotificationService notifications;

    @Autowired  // Step 3: setter called AFTER constructor
    public void setNotificationService(NotificationService notifications) {
        this.notifications = notifications;
        // You can do validation here — deps are being injected
    }
}

@Component
public class PaymentService implements BeanNameAware, EnvironmentAware {

    private String beanName;
    private boolean sandboxMode;

    @Override
    public void setBeanName(String name) {
        this.beanName = name;
        // Real use: include bean name in MDC for distributed tracing
        // "paymentService" shows up in logs and metrics dashboards
    }

    @Override
    public void setEnvironment(Environment env) {
        // Real use: check if we're in sandbox mode before @PostConstruct runs
        this.sandboxMode = env.acceptsProfiles(Profiles.of("sandbox"));
    }
}

@Service
public class PaymentService implements InitializingBean {

    private final PaymentGateway gateway;
    private final PaymentConfig config;
    private volatile boolean ready = false;

    public PaymentService(PaymentGateway gateway, PaymentConfig config) {
        this.gateway = gateway;
        this.config = config;
        // DON'T do initialization here — deps might not all be ready
        // (especially if other beans have circular refs to us)
    }

    @PostConstruct  // Runs FIRST
    void validateConfiguration() {
        // Real production use: fail fast if config is wrong
        if (config.getApiKey() == null || config.getApiKey().isBlank()) {
            throw new IllegalStateException(
                "Payment API key not configured! Set PAYMENT_API_KEY env var.");
        }
        if (config.getTimeout().toMillis() > 30_000) {
            throw new IllegalStateException(
                "Payment timeout too high: " + config.getTimeout() + 
                ". Max allowed: 30s");
        }
        log.info("PaymentService config validated: endpoint={}, timeout={}ms",
                config.getEndpoint(), config.getTimeout().toMillis());
    }

    @Override  // Runs SECOND
    public void afterPropertiesSet() throws Exception {
        // Real production use: verify connectivity to external service
        gateway.healthCheck();
        log.info("Payment gateway connectivity verified");
    }

    // If declared as @Bean(initMethod = "warmUp") — runs THIRD
    public void warmUp() {
        // Real production use: pre-load exchange rates, supported currencies
        gateway.loadSupportedCurrencies();
        this.ready = true;
    }
}

@Service
public class OrderService {

    @Transactional
    public void placeOrder(Order order) {
        orderRepo.save(order);
        // BUG: this.sendConfirmation() bypasses the proxy!
        // @Transactional on sendConfirmation is IGNORED
        this.sendConfirmation(order);
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void sendConfirmation(Order order) {
        // This WON'T run in a new transaction when called from placeOrder()
        // because `this` is the raw bean, not the proxy
        notificationService.send(order);
    }
}

@Service
public class PaymentService implements DisposableBean {

    private final HttpClient httpClient;
    private final ScheduledExecutorService scheduler;
    private final MeterRegistry metrics;

    @PreDestroy  // Runs FIRST
    void deregister() {
        // 1. Remove from service registry so no new traffic arrives
        serviceRegistry.deregister(this);
        log.info("PaymentService deregistered from service discovery");

        // 2. Wait for in-flight requests to drain
        awaitInFlightRequests(Duration.ofSeconds(10));
    }

    @Override  // Runs SECOND
    public void destroy() {
        // 3. Shut down background tasks
        scheduler.shutdown();
        try {
            if (!scheduler.awaitTermination(5, TimeUnit.SECONDS)) {
                scheduler.shutdownNow();
            }
        } catch (InterruptedException e) {
            scheduler.shutdownNow();
            Thread.currentThread().interrupt();
        }

        // 4. Close HTTP connection pool
        httpClient.close();
        log.info("PaymentService connections closed");
    }
}

@Service
public class PricingService {

    // BUG: mutable state in a singleton!
    private BigDecimal lastCalculatedPrice;  // Race condition!
    private String lastCustomerId;           // Race condition!

    public BigDecimal calculatePrice(String customerId, Order order) {
        this.lastCustomerId = customerId;  // Thread A writes
        BigDecimal price = doExpensiveCalculation(order);
        this.lastCalculatedPrice = price;  // Thread B writes, overwrites Thread A

        // Thread A reads — gets Thread B's price! WRONG!
        audit(this.lastCustomerId, this.lastCalculatedPrice);
        return price;
    }
}

@Service
public class PricingService {

    // No mutable fields! All state is local to the method.

    public BigDecimal calculatePrice(String customerId, Order order) {
        BigDecimal price = doExpensiveCalculation(order);  // local variable — thread-safe
        audit(customerId, price);  // method params — thread-safe
        return price;
    }

    // If you NEED shared mutable state:
    private final AtomicLong totalCalculations = new AtomicLong(0);  // Thread-safe
    private final ConcurrentHashMap<String, BigDecimal> priceCache = new ConcurrentHashMap<>();  // Thread-safe
}

@Component
@Scope("prototype")
public class CsvFileProcessor {

    private final List<String> errors = new ArrayList<>();
    private int rowCount = 0;
    private int successCount = 0;

    public ProcessingResult process(InputStream file) {
        // Safe! Each call gets its own instance with fresh state.
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(file))) {
            reader.lines().forEach(line -> {
                rowCount++;
                try {
                    parseLine(line);
                    successCount++;
                } catch (ParseException e) {
                    errors.add("Row " + rowCount + ": " + e.getMessage());
                }
            });
        }
        return new ProcessingResult(rowCount, successCount, errors);
    }
}

@Service  // Singleton!
public class FileUploadService {

    @Autowired
    private CsvFileProcessor processor;  // Prototype... but created ONCE with the singleton!

    public ProcessingResult handleUpload(InputStream file) {
        // BUG: same processor instance for every request!
        // Previous request's errors, rowCount etc. are still there!
        return processor.process(file);
    }
}

@Component
@Scope(value = WebApplicationContext.SCOPE_REQUEST, proxyMode = ScopedProxyMode.TARGET_CLASS)
public class TenantContext {

    private String tenantId;
    private String tenantDatabaseUrl;
    private Instant requestStartTime;
    private Map<String, String> tenantFeatureFlags;

    @PostConstruct
    void init() {
        this.requestStartTime = Instant.now();
    }

    public void setTenant(String tenantId, TenantConfig config) {
        this.tenantId = tenantId;
        this.tenantDatabaseUrl = config.getDatabaseUrl();
        this.tenantFeatureFlags = config.getFeatureFlags();
    }

    public String getTenantId() { return tenantId; }
    public String getDatabaseUrl() { return tenantDatabaseUrl; }
    public boolean isFeatureEnabled(String flag) {
        return "true".equals(tenantFeatureFlags.get(flag));
    }
    public Duration getRequestDuration() {
        return Duration.between(requestStartTime, Instant.now());
    }
}

// Singleton service — safely uses request-scoped bean
@Service
public class PaymentService {

    private final TenantContext tenantContext;  // Actually a proxy!
    private final DataSourceRouter dataSourceRouter;

    public PaymentService(TenantContext tenantContext, DataSourceRouter dataSourceRouter) {
        this.tenantContext = tenantContext;
        this.dataSourceRouter = dataSourceRouter;
    }

    @Transactional
    public PaymentResult processPayment(PaymentRequest request) {
        // Each HTTP request gets its own TenantContext instance
        String tenantDb = tenantContext.getDatabaseUrl();
        dataSourceRouter.routeTo(tenantDb);

        if (tenantContext.isFeatureEnabled("new_payment_flow")) {
            return processWithNewFlow(request);
        }
        return processWithLegacyFlow(request);
    }
}

public class TenantScope implements Scope {

    private final ThreadLocal<Map<String, Object>> tenantBeans = 
        ThreadLocal.withInitial(HashMap::new);
    private final ThreadLocal<Map<String, Runnable>> destructionCallbacks = 
        ThreadLocal.withInitial(HashMap::new);

    @Override
    public Object get(String name, ObjectFactory<?> objectFactory) {
        Map<String, Object> scope = tenantBeans.get();
        return scope.computeIfAbsent(name, k -> objectFactory.getObject());
    }

    @Override
    public Object remove(String name) {
        destructionCallbacks.get().remove(name);
        return tenantBeans.get().remove(name);
    }

    @Override
    public void registerDestructionCallback(String name, Runnable callback) {
        destructionCallbacks.get().put(name, callback);
    }

    @Override
    public String getConversationId() {
        return TenantContextHolder.getCurrentTenantId();
    }

    // Call this when tenant context ends
    public void clear() {
        destructionCallbacks.get().values().forEach(Runnable::run);
        destructionCallbacks.get().clear();
        tenantBeans.get().clear();
    }

    @Override
    public Object resolveContextualObject(String key) { return null; }
}

// Register the custom scope
@Configuration
public class TenantScopeConfig {

    @Bean
    public static CustomScopeConfigurer tenantScopeConfigurer() {
        CustomScopeConfigurer configurer = new CustomScopeConfigurer();
        configurer.addScope("tenant", new TenantScope());
        return configurer;
    }
}

// Use it
@Component
@Scope(value = "tenant", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class TenantRateLimiter {
    private final AtomicInteger requestCount = new AtomicInteger(0);
    private final int maxRequestsPerMinute;
    // One rate limiter per tenant — shared across requests for same tenant
}

@Component
public class TimingBeanPostProcessor implements BeanPostProcessor, Ordered {

    private static final Logger log = LoggerFactory.getLogger(TimingBeanPostProcessor.class);
    private final Map<String, Long> startTimes = new ConcurrentHashMap<>();
    private final List<BeanTiming> slowBeans = new CopyOnWriteArrayList<>();

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        startTimes.put(beanName, System.nanoTime());
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        Long startTime = startTimes.remove(beanName);
        if (startTime != null) {
            long durationMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime);
            if (durationMs > 100) {
                slowBeans.add(new BeanTiming(beanName, bean.getClass().getSimpleName(), durationMs));
                log.warn("🐢 Slow bean initialization: {} ({}) took {}ms", 
                         beanName, bean.getClass().getSimpleName(), durationMs);
            }
        }
        return bean;
    }

    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE; // Run first so we measure all other BPPs too
    }

    @EventListener(ApplicationReadyEvent.class)
    public void reportSlowBeans() {
        if (!slowBeans.isEmpty()) {
            log.info("=== Slow Bean Report ({} beans > 100ms) ===", slowBeans.size());
            slowBeans.stream()
                .sorted(Comparator.comparingLong(BeanTiming::durationMs).reversed())
                .forEach(bt -> log.info("  {} ({}) — {}ms", bt.name(), bt.type(), bt.durationMs()));
            long total = slowBeans.stream().mapToLong(BeanTiming::durationMs).sum();
            log.info("  Total slow bean time: {}ms", total);
        }
    }

    private record BeanTiming(String name, String type, long durationMs) {}
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Encrypted {}

@Component
public class EncryptionBeanPostProcessor implements BeanPostProcessor {

    private final EncryptionService encryptionService;

    public EncryptionBeanPostProcessor(EncryptionService encryptionService) {
        this.encryptionService = encryptionService;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        for (Field field : bean.getClass().getDeclaredFields()) {
            if (field.isAnnotationPresent(Encrypted.class) && field.getType() == String.class) {
                field.setAccessible(true);
                try {
                    String encrypted = (String) field.get(bean);
                    if (encrypted != null) {
                        field.set(bean, encryptionService.decrypt(encrypted));
                    }
                } catch (IllegalAccessException e) {
                    throw new BeanInitializationException(
                        "Failed to decrypt @Encrypted field: " + field.getName(), e);
                }
            }
        }
        return bean;
    }
}

// Usage
@Component
public class PaymentConfig {
    @Value("${payment.api.key}")
    @Encrypted
    private String apiKey;  // Stored encrypted in properties, decrypted at startup
}

@Component
public class ScopeOverrideBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    private final Environment environment;

    public ScopeOverrideBeanFactoryPostProcessor(Environment environment) {
        this.environment = environment;
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        if (environment.acceptsProfiles(Profiles.of("test", "dev"))) {
            for (String beanName : beanFactory.getBeanDefinitionNames()) {
                BeanDefinition def = beanFactory.getBeanDefinition(beanName);
                if ("request".equals(def.getScope()) || "session".equals(def.getScope())) {
                    log.info("Overriding scope for '{}': {} → singleton (test mode)", 
                             beanName, def.getScope());
                    def.setScope("singleton");
                }
            }
        }
    }
}

@Component
public class FeatureFlagBeanRegistrar implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
        // Read feature flags from config
        if (isFeatureEnabled("new-payment-engine")) {
            RootBeanDefinition def = new RootBeanDefinition(StripePaymentGateway.class);
            def.setPrimary(true);
            registry.registerBeanDefinition("paymentGateway", def);
        } else {
            RootBeanDefinition def = new RootBeanDefinition(LegacyPaymentGateway.class);
            def.setPrimary(true);
            registry.registerBeanDefinition("paymentGateway", def);
        }
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // Can also modify existing definitions here
    }
}

@Service
public class ServiceA {
    private final ServiceB serviceB;
    public ServiceA(ServiceB serviceB) { this.serviceB = serviceB; }
}

@Service
public class ServiceB {
    private final ServiceA serviceA;
    public ServiceB(ServiceA serviceA) { this.serviceA = serviceA; }
}

@Service
public class ServiceA {
    private final ServiceB serviceB;

    public ServiceA(ServiceB serviceB) {  // Need B to exist BEFORE A's constructor returns!
        this.serviceB = serviceB;
    }
}

@Component
public class KafkaConsumerLifecycle implements SmartLifecycle {

    private final KafkaConsumer<String, String> consumer;
    private final ExecutorService executor;
    private volatile boolean running = false;

    @Override
    public int getPhase() {
        // Lower phase = starts first, stops last
        // Higher phase = starts last, stops first
        // Consumers should stop BEFORE producers (higher phase)
        return Integer.MAX_VALUE - 100;
    }

    @Override
    public void start() {
        running = true;
        executor.submit(() -> {
            while (running) {
                ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
                processRecords(records);
            }
        });
        log.info("Kafka consumer started");
    }

    @Override
    public void stop(Runnable callback) {
        // Async shutdown — call callback when done
        log.info("Kafka consumer stopping...");
        running = false;

        executor.submit(() -> {
            try {
                // Commit final offsets
                consumer.commitSync(Duration.ofSeconds(5));
                consumer.close(Duration.ofSeconds(10));
                log.info("Kafka consumer stopped gracefully");
            } finally {
                callback.run();  // Signal Spring that we're done
            }
        });
    }

    @Override
    public boolean isRunning() {
        return running;
    }

    @Override
    public boolean isAutoStartup() {
        return true;  // Start automatically with context
    }
}

@Service
public class PaymentService implements SmartLifecycle {

    private final ServiceRegistry serviceRegistry;
    private final ConnectionPool connectionPool;
    private final MetricsPublisher metricsPublisher;
    private final AtomicInteger inFlightRequests = new AtomicInteger(0);
    private volatile boolean accepting = false;

    @Override
    public int getPhase() {
        return 0; // Default phase
    }

    @Override
    public void start() {
        accepting = true;
        serviceRegistry.register(this);
        log.info("PaymentService registered and accepting requests");
    }

    @Override
    public void stop(Runnable callback) {
        log.info("PaymentService shutdown initiated...");

        // Step 1: Deregister from service discovery
        serviceRegistry.deregister(this);
        accepting = false;
        log.info("Deregistered from service registry");

        // Step 2: Wait for in-flight requests (max 25s)
        CompletableFuture.runAsync(() -> {
            Instant deadline = Instant.now().plusSeconds(25);
            while (inFlightRequests.get() > 0 && Instant.now().isBefore(deadline)) {
                log.info("Waiting for {} in-flight requests...", inFlightRequests.get());
                try { Thread.sleep(500); } catch (InterruptedException e) { break; }
            }

            if (inFlightRequests.get() > 0) {
                log.warn("Shutdown timeout! {} requests still in-flight", inFlightRequests.get());
            }

            // Step 3: Flush metrics
            metricsPublisher.flush();

            // Step 4: Close connections
            connectionPool.close();
            log.info("PaymentService shutdown complete");

            callback.run();
        });
    }

    @Override
    public boolean isRunning() { return accepting; }

    @Override
    public boolean isAutoStartup() { return true; }

    public PaymentResult processPayment(PaymentRequest request) {
        if (!accepting) {
            throw new ServiceUnavailableException("Service shutting down");
        }
        inFlightRequests.incrementAndGet();
        try {
            return doProcess(request);
        } finally {
            inFlightRequests.decrementAndGet();
        }
    }
}

@Service
public class PaymentService implements BeanNameAware, ApplicationContextAware,
        InitializingBean, DisposableBean, SmartLifecycle {

    // === Dependencies (Step 2: Constructor Injection) ===
    private final PaymentGateway gateway;
    private final TransactionRepository repository;
    private final MeterRegistry metrics;

    // === State ===
    private String beanName;
    private ApplicationContext applicationContext;
    private volatile boolean running = false;
    private Timer paymentTimer;

    // Step 2: Instantiation — constructor called
    public PaymentService(PaymentGateway gateway, 
                          TransactionRepository repository,
                          MeterRegistry metrics) {
        this.gateway = gateway;
        this.repository = repository;
        this.metrics = metrics;
        // Note: @Autowired fields would be NULL here (if any existed)
        log.debug("PaymentService constructor called");
    }

    // Step 4: Aware Interfaces
    @Override
    public void setBeanName(String name) {
        this.beanName = name;
        MDC.put("bean", name);  // For structured logging
        log.debug("Bean name set: {}", name);
    }

    @Override
    public void setApplicationContext(ApplicationContext ctx) {
        this.applicationContext = ctx;
        log.debug("ApplicationContext injected");
    }

    // Step 6a: @PostConstruct (runs FIRST in initialization)
    @PostConstruct
    void validateConfig() {
        Objects.requireNonNull(gateway, "PaymentGateway must not be null");
        if (!gateway.isConfigured()) {
            throw new IllegalStateException(
                "Payment gateway not configured! Check PAYMENT_API_KEY env var.");
        }
        this.paymentTimer = Timer.builder("payment.duration")
                .tag("service", beanName)
                .register(metrics);
        log.info("PaymentService config validated");
    }

    // Step 6b: InitializingBean.afterPropertiesSet (runs SECOND)
    @Override
    public void afterPropertiesSet() throws Exception {
        // Verify connectivity to payment provider
        HealthStatus status = gateway.healthCheck();
        if (status != HealthStatus.UP) {
            throw new IllegalStateException("Payment gateway unreachable: " + status);
        }
        log.info("Payment gateway health check passed");
    }

    // SmartLifecycle: controlled startup
    @Override
    public void start() {
        running = true;
        log.info("PaymentService is now accepting payments");
    }

    @Override
    public int getPhase() { return 0; }

    @Override
    public boolean isRunning() { return running; }

    @Override
    public boolean isAutoStartup() { return true; }

    // SmartLifecycle: graceful shutdown (before @PreDestroy)
    @Override
    public void stop(Runnable callback) {
        running = false;
        log.info("PaymentService stopping — draining in-flight...");
        // Allow 10s for in-flight requests to complete
        try { Thread.sleep(2000); } catch (InterruptedException ignored) {}
        callback.run();
    }

    // Step 9a: @PreDestroy (runs FIRST in destruction)
    @PreDestroy
    void shutdown() {
        log.info("PaymentService @PreDestroy — flushing metrics");
        metrics.close();
    }

    // Step 9b: DisposableBean.destroy (runs SECOND in destruction)
    @Override
    public void destroy() {
        log.info("PaymentService destroy — closing gateway connection");
        gateway.close();
    }

    // === Business Method ===
    @Transactional  // Proxy wraps this (Step 7: BPP After Init)
    public PaymentResult processPayment(PaymentRequest request) {
        if (!running) throw new ServiceUnavailableException("Shutting down");

        return paymentTimer.record(() -> {
            Transaction tx = gateway.charge(request);
            repository.save(tx);
            applicationContext.publishEvent(new PaymentProcessedEvent(this, tx));
            return new PaymentResult(tx.getId(), tx.getStatus());
        });
    }
}