BestHub
Sign in
Tagged articles

Bean Lifecycle

73 articles · Page 1 of 1
Java Tech Workshop
Java Tech Workshop
Aug 30, 2026 · Backend Development

Why Spring Needs a Three‑Level Cache for Circular Dependencies (Two Levels Lose AOP Proxies)

Spring resolves singleton circular dependencies by using a three‑level cache—singletonObjects, earlySingletonObjects, and singletonFactories—to expose early bean references and generate AOP proxies on demand, avoiding the loss of proxies that occurs with a two‑level cache while preserving performance.

AOP ProxyBackendBean Lifecycle
0 likes · 19 min read
Why Spring Needs a Three‑Level Cache for Circular Dependencies (Two Levels Lose AOP Proxies)
Java Tech Workshop
Java Tech Workshop
Jun 28, 2026 · Backend Development

Inside Spring AOP: Full Lifecycle of Proxy Object Creation

The article provides a step‑by‑step analysis of Spring AOP’s proxy creation process, explaining why some beans are proxied, how @Order, @EnableAspectJAutoProxy, proxyTargetClass and exposeProxy affect proxying, the differences between JDK and CGLIB proxies, and why private, static or final methods cannot be intercepted.

AOPAspectJBean Lifecycle
0 likes · 15 min read
Inside Spring AOP: Full Lifecycle of Proxy Object Creation
Java Tech Workshop
Java Tech Workshop
Jun 17, 2026 · Backend Development

Step‑by‑Step Source Code Walkthrough of Spring’s Singleton Bean Creation

This article dissects Spring’s singleton bean creation process, explaining the three‑level cache system, the doGetBean and doCreateBean workflows, circular‑dependency handling, proxy generation timing, and common pitfalls such as multithreaded duplicate creation and hot‑deployment cache issues.

Bean LifecycleJavaSpring
0 likes · 11 min read
Step‑by‑Step Source Code Walkthrough of Spring’s Singleton Bean Creation
Java Tech Workshop
Java Tech Workshop
Jun 16, 2026 · Backend Development

How Spring’s Third‑Level Cache Resolves Circular Dependencies

The article explains Spring’s three kinds of circular dependencies, the role of the first, second, and third‑level caches in the DefaultSingletonBeanRegistry, how the third‑level cache works with AOP proxies, why constructor injection cannot be solved, the @Lazy workaround, and the hidden bugs and best‑practice recommendations.

AOPBean LifecycleConstructor Injection
0 likes · 12 min read
How Spring’s Third‑Level Cache Resolves Circular Dependencies
Java Tech Workshop
Java Tech Workshop
Jun 15, 2026 · Backend Development

Understanding the Full Spring Bean Lifecycle: From Instantiation to Destruction

This article walks through the complete Spring Bean lifecycle—covering scanning, instantiation, dependency injection, initialization, AOP proxy creation, and destruction—while highlighting common pitfalls, the differences for prototype and lazy‑loaded beans, and practical debugging tips.

AOPBean LifecycleDependency Injection
0 likes · 10 min read
Understanding the Full Spring Bean Lifecycle: From Instantiation to Destruction
Coder Trainee
Coder Trainee
May 10, 2026 · Backend Development

Spring Boot Source Code Deep Dive (Part 7): Full Recap and Ultimate Interview Guide

The final installment of the Spring Boot source‑code series consolidates the previous six episodes—covering startup flow, auto‑configuration, IoC container, bean lifecycle, circular dependencies, and SPI—while providing a complete knowledge map, 20 interview‑question templates, practical study tips, and a roadmap for further learning and contribution.

Auto-configurationBean LifecycleConfiguration
0 likes · 14 min read
Spring Boot Source Code Deep Dive (Part 7): Full Recap and Ultimate Interview Guide
Coder Trainee
Coder Trainee
May 8, 2026 · Backend Development

How Spring Boot Instantiates Beans and Resolves Circular Dependencies

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.

@BeanAOPBean Lifecycle
0 likes · 14 min read
How Spring Boot Instantiates Beans and Resolves Circular Dependencies
LuTiao Programming
LuTiao Programming
Mar 9, 2026 · Backend Development

Spring Boot’s Hidden Power: 10‑Step Bean Lifecycle Most Developers Miss

Most Spring Boot developers use @Service, @Component and @Autowired daily, yet few understand the ten‑step lifecycle a bean undergoes—from loading its definition to destruction—information that unlocks advanced features such as custom initialization, AOP, and dynamic proxy creation.

Bean LifecycleBeanPostProcessorDependency Injection
0 likes · 7 min read
Spring Boot’s Hidden Power: 10‑Step Bean Lifecycle Most Developers Miss
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Sep 28, 2025 · Backend Development

Master Spring Boot 3 Bean Lifecycle: @PostConstruct & @PreDestroy Alternatives

This article explains the purpose and usage of Spring Boot’s @PostConstruct and @PreDestroy annotations for bean initialization and cleanup, discusses their migration to Jakarta EE in Spring Boot 3+, and presents modern alternatives such as @EventListener with ApplicationReadyEvent, DisposableBean, and destroyMethod configurations, complete with code examples.

Bean LifecycleJavaPostConstruct
0 likes · 8 min read
Master Spring Boot 3 Bean Lifecycle: @PostConstruct & @PreDestroy Alternatives
Java Backend Technology
Java Backend Technology
Jul 10, 2025 · Backend Development

Unlock Spring’s Power: Global Exception Handling, Custom Interceptors, and Thread‑Local Scopes

Explore Spring’s extensibility by mastering global exception handling with @RestControllerAdvice, creating custom MVC interceptors, accessing the container via BeanFactoryAware, importing configurations, adding startup logic, modifying BeanDefinitions, using initialization callbacks, and defining a thread‑local custom scope for per‑thread bean instances.

ApplicationRunnerBean LifecycleCustom Scope
0 likes · 10 min read
Unlock Spring’s Power: Global Exception Handling, Custom Interceptors, and Thread‑Local Scopes
Architect's Guide
Architect's Guide
Jul 6, 2025 · Backend Development

Mastering Spring Bean Creation: From Simple Instantiation to 3‑Level Caching

This article explains Spring's bean lifecycle in depth, covering the minimal creation steps, the role of BeanFactoryPostProcessor and BeanPostProcessor, how Spring resolves references and circular dependencies, and why a three‑level cache is essential for reliable dependency injection.

Bean LifecycleDependency InjectionSpring
0 likes · 15 min read
Mastering Spring Bean Creation: From Simple Instantiation to 3‑Level Caching
Java Captain
Java Captain
Jul 4, 2025 · Backend Development

How Does Spring Detect and Resolve Circular Bean Dependencies?

This article explains what circular dependencies are in Spring, how the framework detects them using a three‑level cache during bean creation, and walks through a step‑by‑step example of resolving a setter‑injected circular reference between two beans.

Bean LifecycleDependency InjectionSpring
0 likes · 6 min read
How Does Spring Detect and Resolve Circular Bean Dependencies?
Tech Freedom Circle
Tech Freedom Circle
Jun 20, 2025 · Backend Development

Master Spring’s Core Design Patterns: The Interview‑Ready Answer That Stuns Recruiters

This article systematically breaks down the eight most common design patterns used inside the Spring framework, explains how the template pattern powers bean lifecycle, compares classic and Spring‑specific implementations, and provides concrete code examples and step‑by‑step walkthroughs to help you ace interview questions.

Bean LifecycleDesign PatternsJava
0 likes · 48 min read
Master Spring’s Core Design Patterns: The Interview‑Ready Answer That Stuns Recruiters
macrozheng
macrozheng
Jun 6, 2025 · Backend Development

Master 10 Essential Spring Boot Extension Points for Robust Backend Development

This guide walks through ten crucial Spring Boot extension points—including global exception handling, custom interceptors, container access, configuration imports, startup runners, bean definition tweaks, initialization hooks, bean post‑processing, graceful shutdown, and custom scopes—providing clear explanations and ready‑to‑use code samples for building resilient backend services.

Bean LifecycleCustom ScopeInterceptor
0 likes · 15 min read
Master 10 Essential Spring Boot Extension Points for Robust Backend Development
Huolala Tech
Huolala Tech
May 23, 2025 · Backend Development

Why Adding a New JAR Causes StackOverflowError? Uncovering Spring Bean Recursion

This article walks through a real‑world case where adding a new JAR triggers a java.lang.StackOverflowError during Spring application startup, explains how hidden recursive calls in bean initialization cause the overflow, and offers debugging steps and a design‑level fix to prevent the issue.

Bean LifecycleStackOverflowErrordebugging
0 likes · 29 min read
Why Adding a New JAR Causes StackOverflowError? Uncovering Spring Bean Recursion
Cognitive Technology Team
Cognitive Technology Team
Mar 31, 2025 · Backend Development

Understanding Spring's Three-Level Cache Mechanism

The article explains Spring's three-level cache design—including singletonObjects, earlySingletonObjects, and singletonFactories—how it resolves circular bean dependencies, enables lazy initialization and proxy creation, outlines the workflow, and discusses its limitations and practical solutions.

Bean LifecycleSpringThree-Level Cache
0 likes · 7 min read
Understanding Spring's Three-Level Cache Mechanism
macrozheng
macrozheng
Jan 23, 2025 · Backend Development

Unlock Spring Boot’s Hidden Extension Points: A Complete Guide to Bean Lifecycle Hooks

This article walks through every extensible hook in Spring and Spring Boot—from container refresh and ApplicationContextInitializer to BeanFactoryPostProcessor, InstantiationAwareBeanPostProcessor, SmartInitializingSingleton, and more—showing when each runs, how to implement it, and practical code examples for Java developers.

Bean LifecycleSpring BootSpring Framework
0 likes · 18 min read
Unlock Spring Boot’s Hidden Extension Points: A Complete Guide to Bean Lifecycle Hooks
Architecture Digest
Architecture Digest
Dec 19, 2024 · Backend Development

Comprehensive Overview of Spring Bean Lifecycle Extension Points

This article explains the Spring container's refresh process, details every extensible hook in a bean's lifecycle—from ApplicationContextInitializer to DisposableBean—provides usage scenarios, and includes complete Java code snippets illustrating how to implement each extension point for custom middleware and application development.

Bean LifecycleDependency InjectionJava
0 likes · 18 min read
Comprehensive Overview of Spring Bean Lifecycle Extension Points
Programmer1970
Programmer1970
Dec 8, 2024 · Backend Development

Advanced Spring Interview Questions: Bean Lifecycle, AOP, Transactions, ApplicationContext vs BeanFactory, Type Conversion

This article compiles twelve advanced Spring interview questions covering bean initialization and lifecycle, AOP implementation, transaction management, the differences between ApplicationContext and BeanFactory, type conversion mechanisms, dependency injection, circular dependency resolution with three‑level caches, the event system, @Transactional and @Async annotations, and the inner workings of DispatcherServlet.

AOPBean LifecycleDependency Injection
0 likes · 21 min read
Advanced Spring Interview Questions: Bean Lifecycle, AOP, Transactions, ApplicationContext vs BeanFactory, Type Conversion
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Sep 23, 2024 · Backend Development

Mastering Spring Bean Lifecycle: 8 Essential Stages Explained

This article walks through the eight critical phases of a Spring bean's lifecycle—from instantiation and property population to initialization, post‑processor hooks, usage, and destruction—detailing how Spring creates, configures, enhances, and finally disposes of beans, with code snippets and diagrams for clarity.

Bean LifecycleDependency InjectionJava
0 likes · 5 min read
Mastering Spring Bean Lifecycle: 8 Essential Stages Explained
Architect
Architect
Sep 4, 2024 · Backend Development

Unlocking Spring Bean Lifecycle: 17 Extension Points Every Developer Should Master

This article systematically catalogs every Spring and Spring Boot extension interface—from ApplicationContextInitializer to DisposableBean—illustrates their invocation order with a diagram, explains practical use‑cases, and provides concrete code samples for each hook, enabling developers to tap into the bean lifecycle for custom initialization, monitoring, and cleanup.

BackendBean LifecycleDependency Injection
0 likes · 20 min read
Unlocking Spring Bean Lifecycle: 17 Extension Points Every Developer Should Master
Architect
Architect
Jun 11, 2024 · Backend Development

Mastering Spring Boot Startup: 11 Critical Questions & Execution Order

This article provides a deep technical analysis of Spring Boot's startup process, explains every relevant extension point, demonstrates how to log and verify execution order with sample code, answers eleven common questions about bean initialization, and offers practical guidance on when to safely open RPC, MQ, and HTTP traffic.

Bean LifecycleCommandLineRunnerInitMethod
0 likes · 17 min read
Mastering Spring Boot Startup: 11 Critical Questions & Execution Order
Java Tech Enthusiast
Java Tech Enthusiast
Feb 7, 2024 · Backend Development

How Does Spring’s @Autowired Really Work? A Deep Dive into Its Implementation

This article provides a comprehensive analysis of Spring's @Autowired annotation, covering its usage, the bean lifecycle stages where it operates, the core classes and methods that implement it, and a comparison with other injection annotations such as @Resource, all illustrated with runnable code examples.

Annotation ProcessingBean LifecycleDependency Injection
0 likes · 27 min read
How Does Spring’s @Autowired Really Work? A Deep Dive into Its Implementation
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jan 30, 2024 · Backend Development

Master Spring Boot Bean Lifecycle: Init, Destroy, Scopes & Advanced Tricks

This article explains how to control Spring bean initialization and destruction using interfaces and annotations, inject prototype beans into singleton controllers, implement various BeanPostProcessor extensions, dynamically register beans, use @Import, Runner interfaces, global exception handling, custom type conversion, BeanFactoryAware, web interceptors, and default AOP proxy creation.

Bean LifecycleDependency InjectionJava
0 likes · 9 min read
Master Spring Boot Bean Lifecycle: Init, Destroy, Scopes & Advanced Tricks
Shepherd Advanced Notes
Shepherd Advanced Notes
Oct 10, 2023 · Backend Development

Master 16 SpringBoot Extension Interfaces for Cleaner, More Elegant Code

This article enumerates and explains sixteen Spring and SpringBoot extension interfaces, illustrates their positions in the bean lifecycle with a call‑order diagram, and provides concrete usage scenarios and code samples so developers can harness these hooks to write more elegant and maintainable applications.

BackendBean LifecycleDependency Injection
0 likes · 19 min read
Master 16 SpringBoot Extension Interfaces for Cleaner, More Elegant Code
Architecture Digest
Architecture Digest
Aug 30, 2023 · Backend Development

Comprehensive Overview of Spring and Spring Boot Extension Points and Bean Lifecycle

This article provides a detailed exploration of Spring and Spring Boot's extensible interfaces, illustrating the complete bean lifecycle, presenting an invocation order diagram, and offering practical code examples for each extension point such as ApplicationContextInitializer, BeanFactoryPostProcessor, SmartInstantiationAwareBeanPostProcessor, and more, enabling developers to customize container behavior effectively.

Bean LifecycleJavaSpring
0 likes · 17 min read
Comprehensive Overview of Spring and Spring Boot Extension Points and Bean Lifecycle
Shepherd Advanced Notes
Shepherd Advanced Notes
Jun 12, 2023 · Backend Development

How Spring Solves Circular Bean Dependencies with a Three‑Level Cache

The article explains Spring's three‑level cache mechanism for resolving singleton circular bean dependencies, walks through bean lifecycle stages, compares field, setter and constructor injection, shows configuration to enable circular references, and details the internal code paths that expose early bean references.

Bean LifecycleDependency InjectionSpring
0 likes · 17 min read
How Spring Solves Circular Bean Dependencies with a Three‑Level Cache
Top Architect
Top Architect
Apr 24, 2023 · Backend Development

Understanding the Spring Bean Lifecycle and Its Core Stages

This article explains the complete lifecycle of a Spring bean—including creation, merged BeanDefinition processing, factory exposure, property population, initialization, and destruction—while illustrating the underlying source‑code mechanisms and how Spring resolves constructors, handles circular dependencies, and integrates AOP and post‑processors.

BackendBean LifecycleDependency Injection
0 likes · 16 min read
Understanding the Spring Bean Lifecycle and Its Core Stages
Shepherd Advanced Notes
Shepherd Advanced Notes
Apr 19, 2023 · Backend Development

Spring Extension Point (Part 1): Understanding PostProcessor Mechanisms

This article explains Spring's core post‑processor extension points—BeanDefinitionRegistryPostProcessor, BeanFactoryPostProcessor, and BeanPostProcessor—detailing their purpose, execution order, concrete code examples, and how they fit into the bean lifecycle, including advanced interfaces like InstantiationAwareBeanPostProcessor.

Bean LifecycleDependency InjectionJava
0 likes · 14 min read
Spring Extension Point (Part 1): Understanding PostProcessor Mechanisms
Selected Java Interview Questions
Selected Java Interview Questions
Apr 18, 2023 · Backend Development

Understanding the Spring Bean Lifecycle: Creation, Initialization, Usage, and Destruction

This article explains the complete Spring bean lifecycle—including creation, property filling, initialization, usage, and destruction—detailing how Spring manages object creation, dependency injection, AOP proxy generation, and lifecycle callbacks through various internal phases and extension points.

AOPBean LifecycleDependency Injection
0 likes · 15 min read
Understanding the Spring Bean Lifecycle: Creation, Initialization, Usage, and Destruction
Top Architect
Top Architect
Dec 29, 2022 · Backend Development

Understanding Spring Bean Lifecycle and Circular Dependency Resolution

This article explains the core concepts of the Spring framework—including its container, bean definition readers, bean factories, and three‑level cache mechanism—while detailing how Spring resolves circular dependencies and integrates AOP during bean creation.

AOPBean LifecycleDependency Injection
0 likes · 8 min read
Understanding Spring Bean Lifecycle and Circular Dependency Resolution
Top Architect
Top Architect
Oct 24, 2022 · Backend Development

Comprehensive Overview of Spring and Spring Boot Extension Points and Bean Lifecycle

This article provides a detailed walkthrough of Spring and Spring Boot's bean lifecycle, explaining each extension point—from ApplicationContextInitializer to CommandLineRunner—illustrating their usage with code examples and describing practical scenarios for customizing bean creation, initialization, and destruction.

Bean LifecycleDependency InjectionJava
0 likes · 17 min read
Comprehensive Overview of Spring and Spring Boot Extension Points and Bean Lifecycle
IT Services Circle
IT Services Circle
Sep 20, 2022 · Backend Development

Understanding the Spring Bean Lifecycle: From Instantiation to Destruction

This article explains the complete Spring Bean lifecycle—including IoC fundamentals, bean creation, property injection, initialization callbacks, custom init/destroy methods, and post‑processor hooks—by walking through detailed source‑code examples and step‑by‑step execution traces for a sample bean.

Bean LifecycleDependency InjectionIOC
0 likes · 10 min read
Understanding the Spring Bean Lifecycle: From Instantiation to Destruction
Programmer DD
Programmer DD
Sep 11, 2022 · Backend Development

Mastering Spring & Spring Boot: All Extension Points Explained

This article provides a comprehensive overview of Spring and Spring Boot's extension points, detailing each lifecycle hook, its purpose, typical use cases, and sample implementations, enabling developers to customize bean initialization, configuration, and shutdown processes with concrete code examples.

Bean LifecycleSpring Bootbackend development
0 likes · 19 min read
Mastering Spring & Spring Boot: All Extension Points Explained
Su San Talks Tech
Su San Talks Tech
Sep 7, 2022 · Backend Development

Demystifying Spring Bean Lifecycle: From Creation to Destruction

This article explains the Spring Bean lifecycle in depth, covering IoC fundamentals, each lifecycle stage, extension points such as Aware interfaces and BeanPostProcessor, and provides a step‑by‑step code walkthrough that maps the execution flow from bean creation to destruction.

BackendBean LifecycleDependency Injection
0 likes · 12 min read
Demystifying Spring Bean Lifecycle: From Creation to Destruction
Sanyou's Java Diary
Sanyou's Java Diary
May 22, 2022 · Backend Development

How Spring’s Three‑Level Cache Solves Circular Dependencies

This article explains what circular dependencies are in Spring, describes the three‑level cache mechanism (singletonObjects, earlySingletonObjects, singletonFactories), shows how it resolves singleton bean cycles, and outlines scenarios where the cache cannot break the dependency, such as constructor injection and prototype beans.

Bean LifecycleSpringThree-Level Cache
0 likes · 14 min read
How Spring’s Three‑Level Cache Solves Circular Dependencies
Top Architect
Top Architect
Mar 21, 2022 · Backend Development

How Spring Resolves Bean Circular Dependencies with a Three‑Level Cache

This article explains Spring's bean lifecycle, the three‑level cache mechanism (singletonObjects, earlySingletonObjects, singletonFactories) used to break circular dependencies, the role of Aware interfaces and BeanPostProcessor, and why a second‑level cache is essential when AOP proxies are involved.

AOPBean LifecycleSpring
0 likes · 9 min read
How Spring Resolves Bean Circular Dependencies with a Three‑Level Cache
Top Architect
Top Architect
Mar 9, 2022 · Backend Development

Deep Dive into Spring Bean Lifecycle and Initialization Process

This article provides a comprehensive analysis of Spring's bean lifecycle, detailing the refresh method steps, post‑processor ordering, bean creation, dependency injection via @Autowired and @Resource, Aware callbacks, and initialization hooks such as @PostConstruct and init‑method.

Bean LifecycleDependency InjectionJava
0 likes · 24 min read
Deep Dive into Spring Bean Lifecycle and Initialization Process
Java Captain
Java Captain
Feb 24, 2022 · Backend Development

How Spring Solves Bean Circular Dependencies Using a Three-Level Cache

This article explains how Spring's bean lifecycle and its three-level caching mechanism—singletonObjects, earlySingletonObjects, and singletonFactories—work together to resolve circular dependencies, especially when AOP proxies are involved, highlighting why a three‑cache approach is necessary.

AOPBean LifecycleSpring
0 likes · 9 min read
How Spring Solves Bean Circular Dependencies Using a Three-Level Cache
Java Architect Essentials
Java Architect Essentials
Sep 22, 2021 · Backend Development

Spring Framework Overview: Concepts, Modules, Configuration, and Annotations

This article provides a comprehensive overview of the Spring Framework, covering its definition, advantages, core features such as IoC, AOP, MVC, transaction management, the various modules and their purposes, configuration methods (XML, annotations, Java API), bean scopes, lifecycle, autowiring, and key annotations used in modern Java backend development.

Bean LifecycleDependency InjectionIOC
0 likes · 14 min read
Spring Framework Overview: Concepts, Modules, Configuration, and Annotations
Programmer DD
Programmer DD
Jun 14, 2021 · Backend Development

Mastering Spring: Core Concepts, IoC, AOP, and Bean Management Explained

This comprehensive guide explores the Spring framework’s fundamentals, including its lightweight architecture, core IoC container, dependency injection mechanisms, bean scopes and lifecycle, annotation‑based configuration, data‑access support, and aspect‑oriented programming features, providing developers with a solid foundation for building robust Java applications.

AOPBean LifecycleDependency Injection
0 likes · 45 min read
Mastering Spring: Core Concepts, IoC, AOP, and Bean Management Explained
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 11, 2021 · Backend Development

Understanding Spring Bean Instantiation: From Factory to AOP Proxy

This article walks through the Spring 5.3.3 bean creation process, detailing how the DefaultListableBeanFactory and AnnotationConfigApplicationContext initialize singleton beans, resolve bean definitions, apply post‑processors, handle AOP proxy generation, and complete bean initialization with aware interfaces and custom init methods.

Bean Lifecycle
0 likes · 15 min read
Understanding Spring Bean Instantiation: From Factory to AOP Proxy
IT Xianyu
IT Xianyu
Dec 28, 2020 · Backend Development

Comprehensive Overview of Spring & Spring Boot Extension Points and Bean Lifecycle

This article provides a detailed summary of Spring and Spring Boot's bean lifecycle, enumerating all major extension interfaces—including ApplicationContextInitializer, BeanDefinitionRegistryPostProcessor, BeanFactoryPostProcessor, InstantiationAwareBeanPostProcessor, SmartInstantiationAwareBeanPostProcessor, various Aware interfaces, FactoryBean, CommandLineRunner, and ApplicationListener—along with usage scenarios and code examples, enabling developers to customize bean initialization and container behavior.

Bean LifecycleSpringBootapplication-context
0 likes · 19 min read
Comprehensive Overview of Spring & Spring Boot Extension Points and Bean Lifecycle
IT Xianyu
IT Xianyu
Nov 26, 2020 · Backend Development

Spring Interview Questions and Answers: IoC, AOP, Bean Lifecycle, Circular Dependency, Transactions, Annotations, MVC Flow and Thread Concurrency

This article provides comprehensive explanations of Spring framework concepts—including IoC/AOP principles, bean lifecycle, circular dependency resolution, transaction pitfalls, annotation configuration, MVC processing flow, advice types, and thread‑safety mechanisms—along with illustrative code snippets for interview preparation.

AOPBean Lifecycledependency-injection
0 likes · 12 min read
Spring Interview Questions and Answers: IoC, AOP, Bean Lifecycle, Circular Dependency, Transactions, Annotations, MVC Flow and Thread Concurrency
Selected Java Interview Questions
Selected Java Interview Questions
Sep 21, 2020 · Backend Development

Understanding Spring Framework Core Interfaces and Bean Lifecycle from Source Code

This article explains the core interfaces of the Spring Framework, such as BeanDefinition, BeanFactory, ApplicationContext, and BeanPostProcessor, and walks through the bean creation process—including refresh, preInstantiateSingletons, getBean, and the three‑level singleton caches—providing detailed code examples and insights into how Spring resolves circular dependencies.

Bean LifecycleDependency InjectionJava
0 likes · 28 min read
Understanding Spring Framework Core Interfaces and Bean Lifecycle from Source Code
macrozheng
macrozheng
Jul 16, 2020 · Backend Development

Master Spring’s Circular Dependency: How the Three‑Level Cache Resolves It

This article explains what circular dependency means in Spring, the conditions under which it can be resolved, and walks through the three‑level cache mechanism—including simple cases and AOP‑enhanced scenarios—providing code examples, diagrams, and a clear summary for interview preparation.

AOPBean LifecycleThree-Level Cache
0 likes · 19 min read
Master Spring’s Circular Dependency: How the Three‑Level Cache Resolves It
Selected Java Interview Questions
Selected Java Interview Questions
May 1, 2020 · Backend Development

Understanding the Bean Lifecycle in Spring ApplicationContext

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.

ApplicationContextBackendBean Lifecycle
0 likes · 9 min read
Understanding the Bean Lifecycle in Spring ApplicationContext
Architecture Digest
Architecture Digest
Feb 27, 2020 · Backend Development

Spring Bean Lifecycle: Detailed Process Flow and Code Explanation

This article provides a comprehensive walkthrough of the Spring Bean lifecycle, covering bean retrieval, creation, property population, initialization, and destruction, illustrated with flowcharts and extensive Java code snippets from the AbstractBeanFactory and AbstractAutowireCapableBeanFactory classes.

Bean LifecycleDependency InjectionJava
0 likes · 12 min read
Spring Bean Lifecycle: Detailed Process Flow and Code Explanation
Programmer DD
Programmer DD
Feb 24, 2020 · Backend Development

Unveiling Spring's Bean Lifecycle: From Retrieval to Destruction

This article provides a comprehensive, step‑by‑step walkthrough of Spring's Bean lifecycle—including bean retrieval, creation, property population, initialization, and destruction—illustrated with flowcharts and complete Java code snippets to help developers understand the inner workings of the framework.

Bean LifecycleDependency InjectionJava
0 likes · 14 min read
Unveiling Spring's Bean Lifecycle: From Retrieval to Destruction
Programmer DD
Programmer DD
Jul 24, 2019 · Backend Development

Unlock the Power of Spring: 30 Core Concepts Every Java Developer Must Master

This comprehensive guide explores the fundamentals of the Spring framework—including its core modules, dependency injection, IoC, bean scopes, configuration styles, annotation-driven setup, event handling, and common design patterns—providing Java developers with practical examples and code snippets to master Spring's capabilities.

Bean LifecycleConfigurationDependency Injection
0 likes · 25 min read
Unlock the Power of Spring: 30 Core Concepts Every Java Developer Must Master
Programmer DD
Programmer DD
Jul 20, 2019 · Backend Development

Unlocking Spring Bean Lifecycle: Mastering Aware Interfaces

This article completes the Spring Bean lifecycle overview by illuminating the remaining phases, explains how various XxxxAware interfaces are invoked during bean initialization, demonstrates common pitfalls with constructor injection, and provides code examples for implementing and using Aware interfaces such as BeanNameAware and BeanFactoryAware.

Aware InterfaceBean LifecycleJava
0 likes · 7 min read
Unlocking Spring Bean Lifecycle: Mastering Aware Interfaces