The article explains how BeanFactory is a minimal, lazy‑loading container that only creates and caches beans, while ApplicationContext extends it with eager pre‑loading, full annotation, AOP, transaction, environment and event support, and outlines their respective use cases and pitfalls.
The article demonstrates four practical techniques—@Qualifier, manual ApplicationContext lookup, Map injection, and a FactoryBean with dynamic proxy—to dynamically select among multiple Spring Boot beans, eliminating static if‑else wiring and improving code flexibility and maintainability.
This article compares Spring's BeanFactory and ApplicationContext, detailing their roles, loading strategies, feature sets, code examples, and recommended usage scenarios, helping developers choose the appropriate container for their projects.
The article explains the concept of parent‑child containers in Spring, outlines three key benefits—modularization, scoped bean visibility, and configuration reuse—provides step‑by‑step XML and Java code examples, and shows how the containers integrate with Spring MVC to create a cleaner, more maintainable application architecture.
This article demonstrates a Spring Boot 3 multi‑module architecture where each module runs its own DispatcherServlet and ApplicationContext while sharing a common parent container, providing complete code examples, configuration steps, and testing insights for building loosely‑coupled backend services.
This article explains why force‑killing a Spring Boot process is unsafe and walks through four practical ways—using Actuator, ApplicationContext.close(), PID‑based kill commands, and SpringApplication.exit()—to achieve a graceful shutdown while preserving in‑flight tasks and releasing resources.
This article walks through the Spring Boot startup sequence, detailing how the @SpringBootApplication entry point creates a SpringApplication instance, prepares the environment, builds and refreshes the IoC container, runs ApplicationRunner/CommandLineRunner callbacks, and finally publishes the ApplicationReadyEvent.
This article provides a comprehensive guide to Spring’s essential infrastructure, covering Java and Spring resource management, environment property handling, type conversion APIs, data binding mechanisms, generic type inspection with ResolvableType, internationalization support, the BeanFactory and ApplicationContext architecture, and the built‑in event system, all illustrated with code examples and diagrams.
Explore a comprehensive guide to Spring’s core mechanisms—including resource handling, environment configuration, type conversion, data binding, generic processing, internationalization, BeanFactory, ApplicationContext, and event publishing—complete with detailed explanations, code demos, diagrams, and practical insights for mastering backend development with Spring.
This article explains how Spring 5.3.23 uses web.xml to configure a ContextLoaderListener that creates and refreshes the parent WebApplicationContext, and how DispatcherServlet initializes the child container, detailing the configuration parameters, default locations, and the refresh process.
This article walks through the twelve essential steps Spring performs during application startup, explaining each method—from prepareRefresh to finishRefresh—including bean factory preparation, post‑processor registration, and the final context refresh, all illustrated with diagrams and code snippets.
Spring Event provides a decoupled, extensible mechanism for publishing and handling application events in Spring, covering its definition, benefits, drawbacks, practical usage with code examples, core internal classes, reserved events, asynchronous processing options, and detailed source‑code analysis of the event multicaster and listener registration.
This article explains the Observer pattern, its core roles and typical use cases, then dives into Spring's event mechanism—including ApplicationEvent, ApplicationListener, and ApplicationEventPublisher—showing how to configure synchronous and asynchronous event processing with code examples.
This article walks through the complete Spring Boot startup sequence, illustrating the entry point, the internal run method, environment preparation, context creation, bean factory processing, and final refresh steps, while highlighting the role of auto‑configuration and providing annotated code examples.
This article demonstrates three practical techniques for retrieving Spring-managed beans inside static methods—using @PostConstruct initialization, a static ApplicationContext from the main class, and a manual ApplicationContextAware component—complete with code examples and usage guidelines.
This article explains three techniques for obtaining Spring beans inside static methods—using @PostConstruct initialization, a static ApplicationContext stored in the main class, and implementing ApplicationContextAware—complete with code examples and detailed guidelines for the @PostConstruct annotation.
This article explains three practical ways to retrieve Spring beans from static methods—using @PostConstruct annotation, a static ApplicationContext defined in the main class, and a manually injected ApplicationContext via ApplicationContextAware—complete with code examples and usage notes.
This article explains the core differences between Spring's BeanFactory and ApplicationContext, why ApplicationContext is generally preferred, and how to manually register BeanPostProcessors when using a plain DefaultListableBeanFactory.
Spring provides two IoC containers—BeanFactory and ApplicationContext—each with distinct loading strategies, features, and registration behaviors; this article demonstrates their differences through practical code examples, highlighting lazy versus eager loading, automatic post‑processor registration, and why ApplicationContext is generally preferred for enterprise applications.
This article explains the Spring bean lifecycle within an ApplicationContext, detailing container‑level, factory‑level, and bean‑level post‑processors, showing how to implement and register custom processors, and providing code examples and XML configuration to illustrate the execution order and practical usage.
This article explains how Spring Boot launches an application by creating an AnnotationConfigApplicationContext, registering annotation processors, loading the primary source class, and invoking ConfigurationClassPostProcessor during the refresh phase, with detailed code examples illustrating each step.
This article compares Spring's BeanFactory and ApplicationContext, explaining their roles in retrieving beans, detailing lazy versus eager loading, providing Java and XML code examples, and offering guidance on when to choose each interface for efficient backend development.
This article guides Java backend developers through the fundamentals of Spring IoC and DI, illustrating three practical learning routes—from simple BeanFactory containers to advanced ApplicationContext and WebApplicationContext implementations—using diagrams, code examples, and concise explanations to demystify the core container.
