Tagged articles
BeanPostProcessor
44 articles · Page 1 of 1
This article explains Spring Boot's @ConfigurationProperties binding mechanism, covering when binding occurs via BeanPostProcessor, how Binder handles relaxed binding and type conversion, differences between setter and constructor binding, validation triggering with @Validated, and common troubleshooting pitfalls.
BeanPostProcessorBinderConfigurationProperties
0 likes · 18 min read

This article demonstrates how to intercept and log SQL statements, parameters, and execution times in Spring Boot 3.5 by wrapping the DataSource with a proxy using the datasource-proxy library, without modifying any business code.
BeanPostProcessorDataSource ProxyMethod Tracing
0 likes · 8 min read

This tutorial demonstrates how to create a custom @ConvertJson annotation in Spring Boot 3.5.0 that automatically fetches JSON from a URL parameter and converts it into a typed Java object, using HandlerMethodArgumentResolver and BeanPostProcessor for both method-parameter and field-level injection with SpEL support.
BeanPostProcessorCustom AnnotationHandlerMethodArgumentResolver
0 likes · 12 min read

Spring’s BeanPostProcessor is a global container hook that intercepts every bean’s lifecycle, enabling custom initialization, dynamic proxying, annotation processing, and resource cleanup; the article explains its three-tier hierarchy, execution order, priority rules, practical use‑cases like auto‑injection, logging, data masking, and common pitfalls.
AOPBeanPostProcessorSpring
0 likes · 18 min read

The article explains how Spring Boot 3.5 provides the ConcurrencyThrottleInterceptor for limiting concurrent method calls, demonstrates basic configuration and execution, reveals that all intercepted methods share a single limit, and proposes two fixes—per‑pointcut advisors or a BeanPostProcessor with a custom @ConcurrencyLimit annotation—before recommending dedicated libraries such as Bucket4j or Resilience4j for business‑level throttling.
AOPBeanPostProcessorBucket4j
0 likes · 8 min read

This article demonstrates how to add a single @Monitor annotation to Spring Boot 3.5.0 services and automatically obtain call‑trace and execution‑time metrics by leveraging Spring AOP, SimpleTraceInterceptor, PerformanceMonitorInterceptor, custom advisors, and a BeanPostProcessor, with full code examples and a test controller.
AOPBeanPostProcessorCustom Annotation
0 likes · 6 min read

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

This article walks through the ten most useful Spring extension points—including global exception handling, custom interceptors, bean access, @Import usage, startup runners, BeanDefinition modification, initialization callbacks, BeanPostProcessor hooks, destroy callbacks, and custom scopes—providing clear explanations and ready‑to‑use code examples for each.
BackendBeanFactoryBeanPostProcessor
0 likes · 17 min read

This article explains why a SpringBoot service took 6‑7 minutes to start, shows how to pinpoint the bottlenecks using SpringApplicationRunListener and BeanPostProcessor, and presents concrete optimizations—reducing scan paths, manually registering beans, and fixing cache auto‑configuration—to shrink the local startup time to about 40 seconds.
Auto-configurationBeanPostProcessorCache
0 likes · 18 min read

This article explains why Spring cannot resolve circular dependencies when a bean method is annotated with @Async, detailing the underlying bean post‑processor mechanisms, the order of proxy creation, and practical solutions such as removing @Async, using @Lazy, or adjusting bean factory settings.
AOPBeanPostProcessorCircular Dependency
0 likes · 15 min read

This article provides a comprehensive analysis of Spring's @Autowired annotation, explaining its purpose, usage in constructor, field, and method injection, and detailing the underlying bean post‑processor logic, dependency resolution, and candidate selection that enable automatic dependency injection.
@AutowiredBeanPostProcessorJava
0 likes · 10 min read


JD TechDec 11, 2024 · Backend Development
This article details how a SpringBoot advertising platform service with startup times of 400‑500 seconds was analyzed and optimized through Actuator monitoring, log inspection, Tomcat TLD scan disabling, asynchronous HBase warm‑up, custom BeanPostProcessors, async JSF consumer initialization, Tomcat version tuning, and hardware upgrades, achieving roughly a 60% reduction in launch time.
BackendBeanPostProcessorJava
0 likes · 20 min read

This article details a comprehensive set of optimizations that reduced a SpringBoot application's startup time from 400‑500 seconds to about 130‑150 seconds, covering Actuator monitoring, Tomcat TLD scan disabling, HBase asynchronous warm‑up, custom BeanPostProcessor timing, JSF consumer proxy refactoring, Tomcat version impacts, and hardware upgrades.
BeanPostProcessorJavaSpringBoot
0 likes · 22 min read

This article documents the systematic analysis and multi‑step optimization of a SpringBoot application's slow startup, covering profiling with Actuator, Tomcat TLD scan disabling, HBase async warm‑up, custom BeanPostProcessor timing, and asynchronous JSF consumer initialization to cut launch time by over 60 percent.
BeanPostProcessorJavaSpringBoot
0 likes · 21 min read

This article documents the diagnosis of slow SpringBoot startup in a large‑scale advertising platform and presents a series of optimizations—including actuator monitoring, Tomcat TLD scan disabling, HBase async warm‑up, custom BeanPostProcessor timing, asynchronous JSF consumer refer, Tomcat version tuning, and hardware migration—that together reduce launch time by about 60%.
BackendBeanPostProcessorJava
0 likes · 20 min read

This article explains eight ways to execute custom initialization logic during Spring Boot startup, covering CommandLineRunner, ApplicationRunner, ApplicationListener, @EventListener, @PostConstruct, BeanPostProcessor, InitializingBean, SmartInitializingSingleton, and the main method, with code examples and suitable use‑case guidance.
BeanPostProcessorCommandLineRunnerPostConstruct
0 likes · 10 min read

This article explains how Spring's @Async annotation interacts with circular dependencies, why it triggers BeanCurrentlyInCreationException, and provides multiple strategies—including adjusting dependencies, using @Lazy, or tweaking bean factory settings—to solve the problem.
AOPAsyncBeanPostProcessor
0 likes · 14 min read

This article explains why @Configuration classes can cause circular dependency and custom BeanPostProcessor issues in Spring Boot, and provides practical solutions such as enabling circular references, using static @Bean methods, and preferring constructor injection for reliable bean injection.
BeanPostProcessorJavacircular-dependency
0 likes · 6 min read

This article explains Spring's bean creation process, focusing on the populateBean method and the AutowiredAnnotationBeanPostProcessor, and shows why static fields are ignored during field injection while also offering a way to inject them via a non‑static @Autowired method.
@AutowiredBackendBeanPostProcessor
0 likes · 10 min read

This article introduces the key SpringBoot extension interfaces—including BeanPostProcessor, BeanFactoryPostProcessor, BeanDefinitionRegistryPostProcessor, SmartInstantiationAwareBeanPostProcessor, SmartInitializingSingleton, ApplicationContextInitializer, EnvironmentPostProcessor, and the *Runner interfaces—explaining their purposes, usage patterns, and providing concrete code examples to help developers customize and extend SpringBoot applications effectively.
BeanPostProcessorExtension InterfacesJava
0 likes · 10 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 Spring and SpringBoot’s key extension points—including BeanPostProcessor, BeanFactoryPostProcessor, ApplicationContextInitializer, EnvironmentPostProcessor, and PropertySourceLocator—provides detailed code examples, registration steps, and trigger timing to help developers customize and extend Spring applications effectively.
BeanPostProcessorEnvironmentPostProcessorExtensionPoints
0 likes · 13 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 demonstrates how to create a simple custom annotation that mimics Spring's @Autowired functionality by defining a new annotation, a BeanPostProcessor, configuring beans in XML, and wiring everything together in a test class to show the injection working at runtime.
BackendBeanPostProcessorCustom Annotation
0 likes · 8 min read

This article walks through every stage of a Spring Bean's lifecycle—including instantiation, property population, initialization callbacks, usage, and destruction—while providing concrete code examples, execution traces, and an analysis of the underlying Spring source methods.
Bean LifecycleBeanPostProcessorIoC
0 likes · 13 min read

This article explains how Spring's @Async annotation interacts with circular dependencies, why it leads to BeanCurrentlyInCreationException, and provides detailed insights into AsyncAnnotationBeanPostProcessor, AOP proxy creation, the three‑level cache mechanism, and practical solutions to avoid the issue.
BeanPostProcessorasynccircular-dependency
0 likes · 12 min read

This article provides a comprehensive guide to Spring’s extension mechanisms, covering FactoryBean, @Import, bean lifecycle callbacks, BeanPostProcessor, BeanFactoryPostProcessor, the SPI system, Spring Boot startup hooks, event publishing, and custom XML namespaces, complete with runnable code examples and diagrams.
BeanPostProcessorEventFactoryBean
0 likes · 37 min read


政采云技术Oct 25, 2022 · Backend Development
This article explains how to analyze and accelerate SpringBoot startup by profiling with tools like Async Profiler, refactoring heavy business code, leveraging BeanPostProcessor for bean initialization metrics, using Spring's context indexer, and applying lazy initialization to reduce launch time in large Java backend services.
BeanPostProcessorSpringBootStartup Optimization
0 likes · 11 min read

The article explains Spring's three‑level cache mechanism—singletonObjects, earlySingletonObjects, and singletonFactories—and how early exposure combined with BeanPostProcessor hooks enables the framework to break circular dependencies while still applying AOP proxies before full bean initialization.
AOPBeanPostProcessorCircular Dependency
0 likes · 13 min read

This article explains how Spring resolves circular dependencies by using a three‑level cache and early bean exposure, detailing the roles of singletonObjects, earlySingletonObjects, and singletonFactories, and showing how Spring AOP proxies are applied during the process.
AOPBeanPostProcessorCircular Dependency
0 likes · 12 min read

This article explains Spring's circular‑dependency solution, detailing the early‑exposure mechanism, the three‑level cache (singletonObjects, earlySingletonObjects, singletonFactories), how BeanPostProcessors and AOP proxies interact during bean creation, and why the third‑level cache is essential for correct bean wiring.
AOPBeanPostProcessorCircular Dependency
0 likes · 14 min read

The article explains that adding Spring Cloud's @RefreshScope annotation to beans annotated with @Service or @Component makes the bean definition synthetic, causing Spring's BeanPostProcessor to skip those beans and leading to processing failures.
@RefreshScopeBeanPostProcessorJava
0 likes · 3 min read

This article explains the inner workings of Spring's @Enable annotations, detailing how @Import processes configuration classes, the roles of ImportSelector and ImportBeanDefinitionRegistrar, and using @EnableAsync as a concrete example to illustrate module activation.
BeanPostProcessorEnableAnnotationImportSelector
0 likes · 7 min read

This article explains how to extend the Spring IoC container using custom BeanPostProcessor, BeanFactoryPostProcessor, and FactoryBean implementations, covering registration methods, ordering, interaction with AOP proxies, and practical code examples for tracing bean creation and externalizing configuration properties.
BeanPostProcessorJavaSpring
0 likes · 13 min read

This tutorial explains how implementing Spring’s *Aware interfaces lets beans obtain ApplicationContext, Environment, and BeanFactory objects, walks through the underlying processing mechanism, and provides concrete code examples with the relevant Spring classes and lifecycle hooks.
Aware InterfaceBeanPostProcessorJava
0 likes · 3 min read

This article explains the role of Spring's MergedBeanDefinitionPostProcessor, showing how it merges bean definitions, invokes post‑processors during bean creation, and enables @Autowired‑related dependency injection with code examples and detailed workflow steps.
BeanPostProcessorJavaSpring Framework
0 likes · 7 min read

This article explains how Spring 5.0 reads configuration and annotations, manages bean lifecycles, utilizes BeanPostProcessor extensions, addresses key issues such as FactoryBean vs BeanFactory and circular dependencies, and provides sample code to demonstrate these concepts.
Bean LifecycleBeanPostProcessorJava
0 likes · 12 min read

This article explains how Spring processes the @Autowired annotation by detailing the related classes, bean post‑processor interfaces, bean creation lifecycle, metadata collection, and property injection steps, complete with code examples and diagrams for deeper insight.
@AutowiredBackendBeanPostProcessor
0 likes · 12 min read

This article explains how Spring's bean lifecycle can be customized using BeanPostProcessor, @PostConstruct, InitializingBean, and initMethod, providing code examples, execution logs, and best‑practice scenarios for extending bean creation and initialization in backend Java applications.
Bean LifecycleBeanPostProcessorInitializingBean
0 likes · 8 min read

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

This article explains the essential principles of Spring transaction management, covering transaction propagation, the impact of proxy-based AOP, multithreading safety with ThreadLocal, BeanPostProcessor roles, and common misconceptions illustrated through practical code examples.
AOPBeanPostProcessorJava
0 likes · 11 min read

This article introduces Spring's BeanPostProcessor, explains its two callback methods, and demonstrates through a real‑world A/B testing scenario how custom annotations and a post‑processor can inject dynamic proxies to simplify routing logic and improve code maintainability.
A/B testingBeanPostProcessorJava
0 likes · 5 min read
