This guide explains Spring and Spring Boot's highly extensible architecture by detailing nine core extension points, their injection timing, practical uses, and best‑practice recommendations, enabling developers to customize the container lifecycle from startup to runtime.
This article explores the fundamental nature of software architecture by examining core models, the role of immutable and mutable elements, extension points, and how embracing simplicity can transform complex systems into elegant, adaptable solutions.
The article explains how to avoid tangled if‑else code in a Java backend by using a process engine and a plugin‑based extension point framework, detailing interface definitions, annotations, loading mechanisms, and usage examples drawn from the open‑source MemberClub project.
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.
This article provides a comprehensive overview of Spring and Spring Boot's extensible interfaces, detailing each extension point, its lifecycle stage, usage scenarios, and sample code, enabling developers to better understand and customize bean initialization within the backend framework.
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.
This article walks through Spring Boot 3's powerful extension points—including AutoConfigurationImportFilter, ApplicationContextFactory, SpringApplicationRunListener, and ApplicationContextInitializer—showing how to implement, register, and test custom behavior with complete code examples and configuration steps.
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.
This article explains the five major Spring Boot extension points—ApplicationContextInitializer, ApplicationListener, Runner, BeanFactoryPostProcessor, and BeanPostProcessor—showing how to register custom implementations via SPI, where they are invoked in the startup flow, and providing code examples for each.
This article explains the five major extension points in Spring Boot—ApplicationContextInitializer, ApplicationListener, Runner, BeanFactoryPostProcessor, and BeanPostProcessor—showing how they are discovered via SPI, where they are invoked during the startup lifecycle, and how to implement custom ones with code examples.
This article explains the core extension points of Spring Boot—including ApplicationContextInitializer, ApplicationListener, Runner, BeanFactoryPostProcessor, and BeanPostProcessor—showing how they are discovered via SPI, registered in spring.factories, and invoked during the application startup 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.
This article analyzes the concept of extension points, explains why traditional if‑else or naive strategy patterns break the Open‑Closed Principle, and demonstrates how plugin‑based micro‑kernel architectures, adapter patterns, and nature‑based modeling (as in Eclipse) enable flexible, self‑service platform development while reducing code coupling and maintenance overhead.
This article explores Spring's eleven most commonly used extension points—including custom interceptors, bean factory access, global exception handling, type converters, configuration imports, startup runners, bean definition tweaks, bean post‑processing, initialization methods, shutdown hooks, and custom scopes—providing code examples and practical guidance for Java backend developers.
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.
This article walks through the eleven most commonly used Spring extension points—including custom interceptors, bean retrieval methods, global exception handling, type converters, import configurations, startup runners, bean definition tweaks, post‑processing, initialization and destruction callbacks, and custom scopes—providing clear explanations and code samples for each.
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 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.
Explore the core extension mechanisms of Spring, including FactoryBean, @Import, BeanPostProcessor, BeanFactoryPostProcessor, SPI, SpringBoot startup hooks, event handling, and custom XML namespaces, with detailed code demos and practical examples that reveal how to integrate and extend Spring in real-world applications.
The article explains mid‑platform architecture as an organizational and technical strategy that abstracts reusable components, defines business identities for isolated yet flexible capabilities, and offers three extension patterns—local JAR integration, remote SPI calls, and shared JARs—to balance performance, isolation, and version management while enabling rapid business line onboarding and scalable growth.
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.
This article explains the concept of software architecture, why it is essential, the responsibilities of architects, various architecture classifications, and introduces practical application architectures such as layered, CQRS, hexagonal, onion, and the open‑source COLA framework, highlighting how separating business logic from technical details improves maintainability and scalability.
This article explains how the COLA 2.0 framework restructures Java backend applications by introducing a cleaner layered architecture, redefining components and modules, adding flexible extension points, and providing practical guidance for generating and using COLA‑based services.
The article describes YouZan’s E‑commerce Cloud application framework, which offers merchants extensible custom‑coupon, installment and UI features through three types of extension points—business, message and frontend—organized into code deployment, Maven‑based development modules and an Aladdin‑driven runtime that ensure component openness, transparent upgrades, security, and future multi‑language and hot‑loading enhancements.
Frank, a senior technical expert at Alibaba International, shares how his team tackled the growing complexity of their legacy CRM system by redesigning the architecture with extensible extension points, metadata, CQRS, DDD, SOLID principles, and disciplined layering to achieve better scalability, maintainability, and code readability.
