The article demonstrates that @Configuration classes are CGLIB‑proxied, ensuring @Bean methods are intercepted so internal calls respect container singleton semantics, whereas @Component classes lack this proxy, causing each @Bean call to create a new instance, and explains when to use each approach.
Spring Boot’s auto‑configuration can become a bug hotspot; this article explains why overrides sometimes succeed, why they fail, the role of conditional annotations, and provides step‑by‑step strategies—including manual @Bean overrides, @Primary, and exclude mechanisms—to reliably diagnose and fix auto‑configuration issues.
The article explains why Spring's three‑level cache solves simple circular dependencies but fails for AOP‑enhanced beans, describes the timeline mismatch that causes BeanCurrentlyInCreationException, and presents tiered solutions including @Lazy injection, setter refactoring, early proxy processing, and architectural redesign.
The article explains the fundamental differences between @Component and @Bean in Spring Boot 3.5.0, demonstrates how @Bean provides finer control, solves five common configuration problems, and reveals a subtle proxy‑related bug that causes multiple bean instances when @Component is misused on configuration classes.
The article breaks down Bean thread‑safety into container‑level creation safety and business‑level usage safety, explains Spring's four concurrency strategies, details the implementation of Singleton, Prototype, Request and Session scopes, compares them with other DI frameworks, and argues why Spring's division of responsibilities is appropriate.
This article walks through Spring Boot's bean creation pipeline—from the initial getBean call through doGetBean, the three‑level singleton cache, and the detailed steps of createBean, populateBean, and initializeBean—explaining how circular dependencies are safely resolved and where AOP proxies are generated.
This tutorial explains how to register and inject a third‑party implementation like SwimCoach into a Spring Boot application using a @Configuration class and @Bean methods, covering bean creation, custom IDs, qualifier usage, and practical scenarios such as integrating AWS S3 clients.
This article dissects the SpringBoot class‑loading mechanism, explaining how the JVM parent‑delegation model is selectively overridden with custom class loaders like LaunchedURLClassLoader and RestartClassLoader, and how these changes integrate with Spring's bean lifecycle, auto‑configuration, and practical troubleshooting techniques.
This article explains Spring's default eager bean creation, demonstrates how to add @Lazy annotations or a global property to defer bean instantiation until needed, and discusses the benefits and drawbacks of lazy loading with code examples and runtime observations.
This tutorial explains multiple ways to register Spring beans dynamically at runtime, covering BeanDefinitionRegistryPostProcessor implementation, programmatic bean creation with BeanDefinitionBuilder, ApplicationContextInitializer usage, BeanFactory registration, and direct BeanDefinitionRegistry manipulation, complete with code examples and configuration details.
This article explains Spring's three‑level cache mechanism for resolving bean circular dependencies, dives into why the cache alone is insufficient, and presents three practical scenarios with concrete solutions such as redesigning constructors, using @Lazy, and handling AOP proxy consistency.
This article explains Spring configuration files, comparing XML and Java (annotation‑based) approaches, details bean creation, scopes, initialization and destruction, and demonstrates advanced techniques such as conditional beans and profile‑specific configurations with clear code examples.
This article explains Java Bean introspection, its core APIs, practical code examples, common usage scenarios in Spring, advantages and drawbacks, and how it differs from reflection, providing developers with a comprehensive guide to dynamic bean manipulation.
This article demonstrates several techniques—including @Bean methods, @Component inheritance, BeanFactoryPostProcessor, and custom FactoryBean implementations—to instantiate multiple beans of the same class in a Spring Boot 3 application, comparing their advantages and limitations.
This article explains the Spring Boot startup process, enumerates the key extension points and their execution order, demonstrates the sequence with practical code examples, and answers common questions about bean initialization, lifecycle callbacks, and the proper timing for opening RPC, MQ, and HTTP traffic.
This article explains the new @Fallback annotation introduced in Spring 6.2, compares it with @Primary, shows code examples of bean configuration, and details the bean selection order changes before and after the 6.2 release.
This article explains how Spring's @Resource injection resolves beans by name first and then by type, why mismatched field names or bean registration order cause NoSuchBeanDefinitionException, and how to correctly configure DAO and CommonDAO beans to avoid injection failures.
This article explains the core concepts of Spring's @Autowired dependency injection, illustrates common mistakes such as unresolved circular dependencies and bean name collisions, and provides detailed solutions including constructor injection, qualifier usage, and bean priority annotations.
This article explains how Spring handles common circular dependencies between singleton Beans by employing a three‑level cache (singletonObjects, earlySingletonObjects, singletonFactories), detailing the prerequisites, cache structures, workflow, and key source code snippets that illustrate the underlying mechanism.
This article explains five ways to add a bean to the Spring IoC container—including @Configuration + @Bean, @Component + @ComponentScan, various @Import techniques, FactoryBean, and BeanDefinitionRegistryPostProcessor—provides complete code examples for each, and concludes with a summary and related promotional notes.
This guide explains how to use Spring's @Bean annotation to declare beans, configure dependencies, control lifecycle callbacks, set custom scopes, assign names, aliases, and descriptions, providing Java code examples that parallel equivalent XML configurations.
This article explains six common techniques for adding beans to the Spring IoC container, including @Configuration with @Bean, @Component with @ComponentScan, various @Import approaches, FactoryBean, and BeanDefinitionRegistryPostProcessor, providing code examples and usage details for each method.
Explore the 11 most commonly used Spring extension points—from custom interceptors and bean factories to global exception handling, type converters, import mechanisms, startup runners, bean lifecycle processors, and custom scopes—complete with clear code examples and practical guidance for enhancing Java backend applications.
This article explains five different techniques for adding beans to the Spring IoC container—including @Configuration + @Bean, @ComponentScan, @Import with various selectors, FactoryBean, and BeanDefinitionRegistryPostProcessor—providing complete code examples and practical usage notes for developers.
Converting Java beans to maps often leads to type loss and incorrect property names due to JSON frameworks and BeanUtils behavior, and this article examines those pitfalls, demonstrates them with code examples, analyzes underlying Java introspection mechanisms, and presents a Dubbo‑based solution to reliably preserve types and property names.
This article explains the concepts of coupling, Inversion of Control, and Dependency Injection in the Spring framework, demonstrates various bean instantiation methods—including no‑arg constructors, static and instance factory methods—and provides a complete example of configuring and using Spring beans in a Java application.
This comprehensive guide explores every way to define Spring beans—from classic XML configurations and constructor or setter injection to modern @Component annotations, JavaConfig @Bean methods, and advanced @Import, ImportSelector, and post‑processor techniques—empowering developers to choose the most suitable approach for any project.
This article explains how Spring's IoC container creates and manages beans, covering the container startup phase, bean definition loading, BeanFactoryPostProcessor and BeanPostProcessor extensions, object creation strategies, property injection, Aware interfaces, and bean lifecycle callbacks.
The guide explains how Spring’s annotation-driven configuration—using @Configuration and @Bean to define beans, @ComponentScan for automatic detection, and additional annotations such as @Scope, @Lazy, @Conditional, @Import and FactoryBean—replaces verbose XML, streamlining bean registration and lifecycle management.
This tutorial explains the concept of Inversion of Control in Spring, demonstrates how to configure beans with XML, compares BeanFactory and ApplicationContext, explores bean scopes and lifecycle, and provides detailed examples of constructor, static‑factory, instance‑factory, and collection injection techniques.
This article explains the two‑phase lifecycle of Spring beans, covering container startup tasks, metadata loading, bean definition registration, and the detailed instantiation process including object creation strategies, BeanWrapper, property injection, Aware interfaces, post‑processors, and custom init/destroy logic.
This article explains how the Spring IoC container prepares and creates Bean instances, detailing the two main phases—container startup and Bean instantiation—along with the roles of BeanDefinition, BeanFactoryPostProcessor, BeanWrapper, Aware interfaces, BeanPostProcessor, and custom initialization and destruction logic.
This article explains why Spring beans are not inherently thread‑safe, compares the singleton and prototype scopes, shows how stateless beans can be safe, demonstrates the impact of static fields and injected beans, and provides practical code examples and recommendations for achieving thread safety in Spring applications.
This article explains the concept of circular dependencies in Spring, reviews related fundamentals, demonstrates how Spring's three-level cache resolves singleton circular references, discusses limitations with prototype and constructor injection, and provides code examples and detailed source analysis for developers.
The article explains why Spring MVC controllers are singleton by default, demonstrates the resulting thread‑unsafe behavior with example code, shows how applying @Scope("prototype") makes them prototype scoped, and provides best‑practice recommendations and a summary of Spring bean scopes.
This article explains how Spring resolves circular dependencies for singleton beans using a three‑level cache, demonstrates a simple prototype implementation that mimics Spring's behavior, and relates the problem to the classic two‑sum algorithm to reveal its fundamental nature.
This guide explains the purpose and mechanics of Spring Boot's @Conditional annotation, shows its source definition, outlines usage forms, provides a complete example with custom Condition implementations for MySQL and Oracle beans, and lists the related derived conditional annotations available in Spring Boot.
This article explains the complete Spring Bean lifecycle—including definition via XML, various initialization methods, three ways to obtain and use a bean, and bean destruction techniques—illustrated with Java code snippets and a diagram for clear understanding.
Spring’s shift from XML to annotation‑based configuration is explained, covering @Configuration and @Bean requirements, example Java classes, equivalent XML, annotation definitions, bean scopes, component scanning, unit‑testing, and practical tips for wiring beans without field injection, providing a complete guide for modern Spring development.
This article provides a comprehensive guide to Spring's core annotations—including @Autowired, @Bean, @Qualifier, @Required, @Value, @DependsOn, @Lazy, @Lookup, @Primary, @Scope, @Profile, @Import, @ImportResource, @PropertySource and @PropertySources—explaining their purpose, usage patterns, and code examples for constructor, setter, and field injection in Java applications.
This article shares practical SpringBoot techniques for locally mocking external service dependencies and encrypting configuration properties, detailing step-by-step bean replacement using PowerMockito, configuration encryption with Jasypt, and accompanying code examples for seamless development without starting full distributed services.
This article introduces the lightweight Spring framework, explains the concepts of IoC and AOP, demonstrates how to configure beans using XML and annotations, and provides detailed code examples for object creation, property injection, complex type injection, and annotation‑driven bean management in Java.
This article provides a comprehensive overview of the Spring framework, covering its low‑invasion design, IoC container, dependency injection types, bean scopes, autowiring options, bean creation methods, post‑processors, zero‑configuration annotations, and AOP support with AspectJ, supplemented by practical code examples.
This article explains how to structure Spring XML configuration files, define bean metadata, use id/name/alias for bean naming, and instantiate beans via constructors, static factory methods, or instance factories, providing detailed code examples and JUnit tests for each approach.
This article explains the concepts of Spring's IoC container and beans, guides through setting up a development environment, details the required JARs, demonstrates creating a simple Hello World application with interface and implementation, and shows how to configure and retrieve beans using XML configuration.
