Tagged articles
AutoConfiguration
32 articles · Page 1 of 1
This article presents a comprehensive interview self‑test checklist for Spring Boot Starters, offering detailed reference answers that explain the distinction between Starters and AutoConfiguration, Maven transitive dependencies, registration files for Spring Boot 3.x, the inner workings of @ConfigurationProperties and Binder, changes to relaxed binding, essential annotations, naming conventions, exclusion techniques, the impact of excessive Starters, the design rationale behind separating dependency description from auto‑configuration, conditional property semantics, and the differences between ApplicationContextRunner and @SpringBootTest for testing auto‑configuration.
AutoConfigurationConfigurationPropertiesMaven
0 likes · 23 min read

A comprehensive guide to building production-ready Spring Boot Starters covering auto-configuration registration via AutoConfiguration.imports, conditional annotations (@ConditionalOnClass, @ConditionalOnMissingBean, @ConditionalOnProperty), type-safe configuration binding with @ConfigurationProperties and validation, IDE metadata generation, lightweight health indicators, version alignment with Spring Boot, testing with ApplicationContextRunner, and dependency hygiene using optional/exclusions.
ApplicationContextRunnerAutoConfigurationConditional Assembly
0 likes · 16 min read

The article compares Java’s native SPI with Spring’s custom SPI, explains the fundamental flaws of ServiceLoader, details SpringFactoriesLoader’s lazy loading and conditional filtering, and shows why SpringBoot auto‑configuration relies entirely on its own SPI mechanism.
AutoConfigurationJavaSPI
0 likes · 13 min read

The article explains how SpringBoot’s @Conditional meta‑annotation enables dynamic, zero‑intrusion bean creation by replacing hard‑coded if‑logic, details the underlying Condition and ConditionContext APIs, execution order, performance benefits, built‑in derived annotations across six categories, and shows practical code examples and custom condition implementations.
AutoConfigurationBackendBeanLoading
0 likes · 16 min read

The article explains how to eliminate boilerplate when using Spring Boot 3.5.0 RestClient by introducing two custom annotations, @ClientEnhance and @ClientConfig, together with an auto‑configuration class that injects logging interceptors and configurable timeouts into selected RestClient.Builder beans, enabling a non‑intrusive, declarative enhancement.
AutoConfigurationCustom AnnotationJava
0 likes · 8 min read

Understanding the loading order and priority of SpringBoot auto‑configuration classes is crucial because it determines conditional bean registration, prevents conflicts, and enables custom configurations to override defaults; the article explains the default hierarchy, key annotations for ordering, the new @AutoConfiguration mechanism in 2.7+, and practical debugging techniques.
AnnotationsAutoConfigurationBeanLoading
0 likes · 23 min read

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.
@BeanAutoConfigurationClassLoader
0 likes · 37 min read

This article walks through Spring Boot’s most useful built‑in features—including request logging, content‑caching wrappers, OncePerRequestFilter, AOP utilities, starter auto‑configuration, flexible property binding, async scheduling, Actuator monitoring, and SpEL expressions—showing how to apply them with concise code examples to boost productivity and reliability.
AOPActuatorAutoConfiguration
0 likes · 14 min read

This article investigates why a SpringBoot service takes 6‑7 minutes to start, identifies the costly bean‑scanning and bean‑initialization phases, and demonstrates how to speed up startup to around 40 seconds using custom SpringApplicationRunListener, BeanPostProcessor monitoring, JavaConfig selective bean registration, and cache auto‑configuration adjustments.
AutoConfigurationCacheSpringBoot
0 likes · 20 min read

This article explains how to diagnose and dramatically reduce SpringBoot startup latency by analyzing SpringApplicationRunListener and BeanPostProcessor phases, limiting component scanning paths, using JavaConfig for explicit bean registration, monitoring bean initialization times, and handling auto-configuration pitfalls such as cache manager duplication.
AutoConfigurationBeanScanningJavaConfig
0 likes · 19 min read

This article explains the Spring Boot startup mechanism, covering the @SpringBootApplication entry annotation, its constituent annotations, the role of SpringApplication.run, and the step‑by‑step initialization flow that powers Java backend applications.
AutoConfigurationBackendJava
0 likes · 3 min read

This article explains how to identify and resolve the severe startup latency of a SpringBoot service by analyzing the SpringApplicationRunListener and BeanPostProcessor stages, narrowing scan packages, manually registering beans with JavaConfig, and handling cache auto‑configuration to reduce launch time from minutes to seconds.
AutoConfigurationCachebean-scan
0 likes · 18 min read

This article explains how to implement a configuration‑driven mechanism that dynamically switches between Spring's native @Scheduled tasks and XXL‑JOB execution, automatically registers jobs, disables Spring's scheduler when needed, and forwards logs to the XXL‑JOB console, providing a complete starter solution for backend developers.
AutoConfigurationBackendJava
0 likes · 25 min read

This article explains what custom Spring Boot starters are, why they are useful, outlines the annotation and configuration file changes across Spring Boot 2.6, 2.7 and 3.x, and provides a complete AOP‑based starter implementation with code samples.
AutoConfigurationCustom StarterSpring Boot
0 likes · 8 min read


JavaEdgeMay 21, 2024 · Backend Development
This guide explains the two integration mechanisms ShardingSphere provides for Spring—namespace‑based XML schema extension and custom starter for Spring Boot—detailing the required classes, configuration files, bean definitions, and annotations to enable sharding, read‑write splitting, and encryption in a Java backend.
AutoConfigurationJava backendShardingSphere
0 likes · 14 min read

This article investigates why a SpringBoot service takes 6‑7 minutes to start, identifies the heavy cost of component scanning and bean post‑processing, demonstrates how to monitor each phase with custom SpringApplicationRunListener and BeanPostProcessor implementations, and presents practical JavaConfig and starter‑based solutions that cut startup time from minutes to seconds.
AutoConfigurationBeanScanningCache
0 likes · 18 min read

This article explains the concept and inner workings of Spring Boot Starters, demonstrates how they simplify dependency management and auto‑configuration, and provides a step‑by‑step guide to creating and using a custom Starter with full code examples.
AutoConfigurationDependency ManagementJava
0 likes · 10 min read

This article investigates why a SpringBoot service takes 6‑7 minutes to start, identifies the bean‑scanning and bean‑initialization phases as the main performance culprits, and presents concrete JavaConfig and starter‑based solutions to reduce startup time to around 40 seconds while handling cache auto‑configuration pitfalls.
AutoConfigurationBeanScanningCache
0 likes · 19 min read

This article explains how to identify and reduce the excessive startup latency of a SpringBoot service by profiling the run method, customizing SpringApplicationRunListener and BeanPostProcessor, trimming component‑scan paths, and leveraging JavaConfig and starter mechanisms to avoid unnecessary bean loading and auto‑configuration overhead.
AutoConfigurationBeanScanningCache
0 likes · 18 min read

This article analyzes why a SpringBoot service takes minutes to start, identifies the bean‑scanning and bean‑initialization phases as the main performance culprits, and presents practical solutions such as narrowing scan packages, using JavaConfig for explicit bean registration, customizing SpringApplicationRunListener and BeanPostProcessor for timing, and leveraging SpringBoot starter mechanisms to streamline cache configuration.
AutoConfigurationBeanScanningCache
0 likes · 18 min read

This article explains how to diagnose and dramatically reduce the long startup time of a SpringBoot service by profiling the SpringApplicationRunListener and BeanPostProcessor phases, trimming excessive component scanning, manually configuring beans with JavaConfig, and understanding the impact of SpringBoot's auto‑configuration mechanisms.
AutoConfigurationBeanScanningJavaConfig
0 likes · 18 min read

This article introduces the mica-auto open‑source tool that uses Java annotation processing to automatically generate Spring Boot configuration files like spring.factories and AutoConfiguration.imports, and provides step‑by‑step instructions for integrating it into a Maven project.
Annotation ProcessorAutoConfigurationJava
0 likes · 4 min read

This guide explains why Spring Boot deprecates the META-INF/spring.factories file, how the change affects custom starters, and provides step‑by‑step code examples for migrating to the new AutoConfiguration.imports mechanism.
AutoConfigurationJavaSpring Boot
0 likes · 4 min read

This article provides an in‑depth analysis of SpringBoot’s startup process, automatic configuration mechanism, event‑driven architecture, and conditional annotation handling, illustrating key source code snippets and explaining how the framework loads and initializes beans, listeners, and embedded Tomcat server.
AutoConfigurationJavaSpringBoot
0 likes · 25 min read

This article explains step‑by‑step how Spring Boot’s RabbitAutoConfiguration sets up connection factories, RabbitTemplate, listener containers, and lifecycle management to enable @RabbitListener‑driven message processing, complete with code examples and the underlying bean registration flow.
AutoConfigurationJavaMessage Listener
0 likes · 22 min read

This article explains how Spring Boot’s auto‑configuration works by describing the role of @SpringBootApplication, the conditional annotations that drive bean creation, the use of META‑INF/spring.factories, and provides a step‑by‑step example of building a custom auto‑configuration module with full code samples.
AnnotationsAutoConfigurationBackend
0 likes · 9 min read

The article dissects Spring Boot’s @SpringBootApplication annotation, revealing it as a composite of seven meta‑annotations—including @SpringBootConfiguration, @EnableAutoConfiguration and @ComponentScan—and explains the underlying registrar, import selector, metadata loading, and exclusion mechanisms that together drive Spring Boot’s automatic configuration process.
AutoConfigurationBackendComponentScan
0 likes · 12 min read

This article explains the composition of the @SpringBootApplication annotation, details the roles of @Configuration, @ComponentScan and @EnableAutoConfiguration, and walks through the SpringApplication.run execution flow and the underlying auto‑configuration mechanism that powers Spring Boot applications.
AnnotationsAutoConfigurationBackend
0 likes · 16 min read

This article examines Spring Boot's auto‑configuration process by analyzing the source code of @SpringBootApplication, @EnableAutoConfiguration, and related classes, explaining how the framework loads configuration classes via SpringFactoriesLoader, processes deferred import selectors, and integrates with the application context during startup.
AutoConfigurationJavaSpring
0 likes · 26 min read

This article explains the role of Spring's DispatcherServlet, details its traditional web.xml configuration, walks through its request‑handling workflow, and shows how Spring Boot automatically configures and registers the servlet using concise code examples and annotations.
AutoConfigurationDispatcherServletSpring
0 likes · 12 min read

This article explains the inner workings of a Spring Boot application startup class, detailing the composite @SpringBootApplication annotation, the roles of @Configuration, @ComponentScan, and @EnableAutoConfiguration, and walks through the SpringApplication execution flow and the auto‑configuration mechanism powered by SpringFactoriesLoader.
AnnotationsAutoConfigurationJava
0 likes · 46 min read

This article explains how Spring Boot’s automatically generated Application class serves as the entry point, details the @SpringBootApplication annotation and its composed annotations, and shows how to customize component scanning and disable unwanted auto‑configurations using @ComponentScan and @EnableAutoConfiguration with practical code examples.
AnnotationsAutoConfigurationBackend
0 likes · 6 min read
