Tagged articles
extension points
29 articles · Page 1 of 1
The article analyzes the challenges of applying AI coding to AliExpress' high‑traffic, complex marketing system, introduces an SDD‑driven AAIC workflow, builds a business‑knowledge base for the dynamic‑Ticket feature, validates improvements with precision/recall metrics, and outlines architecture and testing upgrades to sustain AI‑assisted development.
AI codingSDDbusiness knowledge base
0 likes · 35 min read

This article explains the two core SpringBoot extension points—ApplicationContextInitializer for pre‑startup configuration and ApplicationListener for post‑event handling—detailing their purpose, execution timing, source code, registration methods, ordering control, common use cases, and a side‑by‑side comparison to help developers master SpringBoot's flexible extension mechanism.
ConfigurationJavaSpringBoot
0 likes · 31 min read

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.
BeanFactoryPostProcessorJavaSpring
0 likes · 6 min read

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.
Design Principlescomplexity managementcore model
0 likes · 6 min read

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.
JavaPlugin ArchitectureSpring
0 likes · 8 min read

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 Frameworkextension points
0 likes · 18 min read

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.
Bean LifecycleJavaSpring
0 likes · 23 min read

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 LifecycleJavaSpring
0 likes · 18 min read

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.
AutoConfigurationImportFilterSpringApplicationRunListenerapplicationcontextfactory
0 likes · 9 min read

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 LifecycleJava
0 likes · 20 min read


IT NiukeApr 15, 2024 · Backend Development
This article walks through the five core Spring Boot extension points—ApplicationContextInitializer, ApplicationListener, Runner, BeanFactoryPostProcessor, and BeanPostProcessor—showing how they are discovered via SPI, where they are invoked in the startup flow, and how to implement and register custom extensions.
BeanFactoryPostProcessorBeanPostProcessorRunner
0 likes · 8 min read

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.
BeanFactoryPostProcessorBeanPostProcessorRunner
0 likes · 9 min read

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.
BeanFactoryPostProcessorBeanPostProcessorRunner
0 likes · 9 min read

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.
BeanFactoryPostProcessorBeanPostProcessorRunner
0 likes · 7 min read

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 LifecycleSpring
0 likes · 19 min read

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

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.
EclipsePlugin ArchitectureSOA
0 likes · 19 min read

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.
JavaSpringbackend development
0 likes · 16 min read

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 LifecycleJavaSpring
0 likes · 17 min read

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.
IoCJavaSpring
0 likes · 16 min read

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.
@BeanBackendConfiguration
0 likes · 11 min read

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 Lifecyclebackend developmentextension points
0 likes · 19 min read

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.
BackendJavadependency-injection
0 likes · 40 min read

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.
architecturebusiness identityextension points
0 likes · 8 min read

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

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.
COLA frameworkOnion Architectureapplication design
0 likes · 16 min read

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.
COLA frameworkJavadomain-driven design
0 likes · 18 min read

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.
Component SecurityMaven FrameworkPlatform Development
0 likes · 11 min read

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.
BackendDDDSOLID
0 likes · 17 min read
