BestHub
Sign in
Tagged articles

Auto-Configuration

88 articles · Page 1 of 1
Java Tech Workshop
Java Tech Workshop
Jul 2, 2026 · Backend Development

Spring Boot Auto‑Configuration Unveiled: The @EnableAutoConfiguration SPI Mechanism

Spring Boot achieves zero‑XML, out‑of‑the‑box auto‑configuration by leveraging a custom SPI mechanism driven by @EnableAutoConfiguration, which replaces the legacy spring.factories with @AutoConfiguration imports, employs deferred import selectors, hierarchical ordering, and conditional annotations to dynamically load and prioritize beans.

Auto-ConfigurationConditional AnnotationsSPI
0 likes · 12 min read
Spring Boot Auto‑Configuration Unveiled: The @EnableAutoConfiguration SPI Mechanism
Java Architect Essentials
Java Architect Essentials
Jun 26, 2026 · Backend Development

7 Proven Techniques to Slash Spring Boot Startup Time by Up to 70%

This article walks through seven concrete Spring Boot startup optimizations—including lazy initialization, precise component scanning, JVM tuning, auto‑configuration slimming, class‑loading reduction, delayed database connections, and AOT/native compilation—showing real‑world benchmarks that cut launch times by around 70%.

AOTAuto-ConfigurationJVM Tuning
0 likes · 9 min read
7 Proven Techniques to Slash Spring Boot Startup Time by Up to 70%
Java Architect Essentials
Java Architect Essentials
May 23, 2026 · Interview Experience

20 Must‑Know Interview Questions Covering 95% of Microservice Scenarios

The article analyzes why candidates fail by relying on raw question banks, presents three deep‑dive topics—auto‑configuration, distributed transaction management, and microservice componentization—with concrete case studies, and offers a curated list of 20 essential interview questions and answer strategies to help candidates demonstrate real‑world risk‑aware thinking.

Auto-ConfigurationMicroservicescomponent design
0 likes · 10 min read
20 Must‑Know Interview Questions Covering 95% of Microservice Scenarios
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 6, 2026 · Backend Development

Spring Boot Auto-Configuration: In‑Depth Source Code Walkthrough

This article explores the complete execution flow of Spring Boot’s auto‑configuration, detailing the role of @EnableAutoConfiguration, the AutoConfigurationImportSelector hierarchy, how candidate configurations are loaded from spring.factories, filtered by conditions, and how to create custom starters, with interview‑style Q&A.

Auto-ConfigurationBackend DevelopmentConditional Annotations
0 likes · 12 min read
Spring Boot Auto-Configuration: In‑Depth Source Code Walkthrough
Coder Trainee
Coder Trainee
May 5, 2026 · Backend Development

What Does @SpringBootApplication Actually Do? A Deep Dive into Spring Boot’s Core Annotation

This article dissects the @SpringBootApplication annotation, explaining how it combines @SpringBootConfiguration, @EnableAutoConfiguration, and @ComponentScan, and walks through the auto‑configuration mechanism, conditional annotations, and common interview questions with concrete code examples.

@SpringBootApplicationAuto-ConfigurationBackend Development
0 likes · 10 min read
What Does @SpringBootApplication Actually Do? A Deep Dive into Spring Boot’s Core Annotation
Coder Trainee
Coder Trainee
May 4, 2026 · Backend Development

Spring Boot Startup Process: A Zero‑to‑One Source Code Walkthrough

This article dissects the Spring Boot startup sequence step by step, showing how a minimal @SpringBootApplication triggers listeners, type deduction, auto‑configuration loading, environment preparation, IOC container creation, bean refresh, and embedded Tomcat launch, with interview‑ready explanations.

Auto-ConfigurationJavaSpring Boot
0 likes · 9 min read
Spring Boot Startup Process: A Zero‑to‑One Source Code Walkthrough
Java Tech Workshop
Java Tech Workshop
Apr 14, 2026 · Backend Development

How to Exclude Specific Auto‑Configurations in SpringBoot: 5 Practical Methods

This article explains SpringBoot's auto‑configuration mechanism, why exclusions are needed, and walks through five concrete ways to exclude unwanted auto‑configurations—including annotation‑based, name‑based, YAML/property file, @EnableAutoConfiguration, and autoconfigure.exclude file approaches—while comparing their priorities, advantages, and suitable scenarios, and offering troubleshooting tips for common pitfalls.

Auto-ConfigurationConfigurationJava
0 likes · 8 min read
How to Exclude Specific Auto‑Configurations in SpringBoot: 5 Practical Methods
Java Tech Workshop
Java Tech Workshop
Apr 10, 2026 · Backend Development

Build a Private Spring Boot Starter from Scratch

This tutorial walks through the complete process of creating a custom Spring Boot starter—covering its core concepts, Maven setup, configuration properties, auto‑configuration class, conditional bean loading, packaging, testing, and best‑practice tips—so developers can encapsulate reusable components and plug them into other projects with zero configuration effort.

Auto-ConfigurationConditionalOnPropertyCustom Starter
0 likes · 20 min read
Build a Private Spring Boot Starter from Scratch
Java Tech Workshop
Java Tech Workshop
Apr 10, 2026 · Backend Development

Understanding SpringBoot @Conditional Annotations: A Deep Dive into Conditional Configuration

This article explains how SpringBoot uses the @Conditional family of annotations to control bean creation based on classpath presence, existing beans, configuration properties, resources, and application type, providing practical code examples, common pitfalls, custom condition creation, and interview questions.

@ConditionalAuto-ConfigurationJava
0 likes · 22 min read
Understanding SpringBoot @Conditional Annotations: A Deep Dive into Conditional Configuration
java1234
java1234
Jan 27, 2026 · Backend Development

7 Proven Spring Boot Startup Hacks to Slash Over 70% of Boot Time

This article presents seven concrete Spring Boot startup optimization techniques—including lazy bean initialization, precise component scanning, JVM flag tuning, auto‑configuration pruning, class‑loading shortcuts, lazy database connections, and GraalVM native compilation—backed by real‑world benchmarks that reduce launch times by up to 71% across e‑commerce, micro‑service, logistics and payment services.

Auto-ConfigurationDatabase ConnectionGraalVM
0 likes · 9 min read
7 Proven Spring Boot Startup Hacks to Slash Over 70% of Boot Time
BirdNest Tech Talk
BirdNest Tech Talk
Jan 24, 2026 · Artificial Intelligence

How to Build an AI Comic‑Generating Agent with LangGraphGo and Skills

This article walks through constructing a multi‑step AI comic‑generation agent using the LangGraphGo framework and the GoSkills plugin system, covering architecture design, declarative tool definitions, automatic configuration discovery, parameter conversion, code implementation, common pitfalls, best practices, and performance optimizations.

AI AgentsAuto-ConfigurationGoSkills
0 likes · 22 min read
How to Build an AI Comic‑Generating Agent with LangGraphGo and Skills
Java Companion
Java Companion
Nov 18, 2025 · Backend Development

Why SpringBoot Replaced spring.factories with a Faster, GraalVM‑Friendly Imports Mechanism

SpringBoot 3.0 drops the long‑standing spring.factories file in favor of per‑extension imports files, eliminating full‑classpath scans, improving startup speed, aligning with Java modules, and enabling seamless GraalVM native‑image support, while providing a clear migration path for existing projects.

Auto-ConfigurationGraalVMimports
0 likes · 13 min read
Why SpringBoot Replaced spring.factories with a Faster, GraalVM‑Friendly Imports Mechanism
Architect's Tech Stack
Architect's Tech Stack
Nov 5, 2025 · Backend Development

How to Build a Conditional Multi‑DataSource Spring Boot Starter to Eliminate Dubbo Bottlenecks

This article walks through creating a custom Spring Boot starter that uses conditional auto‑configuration to provide primary and secondary data sources, DAOs, and services, enabling high‑frequency Dubbo calls to be replaced with direct database access and dramatically improving performance.

Auto-ConfigurationConditional BeansDubbo
0 likes · 13 min read
How to Build a Conditional Multi‑DataSource Spring Boot Starter to Eliminate Dubbo Bottlenecks
Ray's Galactic Tech
Ray's Galactic Tech
Nov 4, 2025 · Backend Development

Unlock Spring Boot’s 10+3 Must‑Know Features for Faster Java Development

This article explores Spring Boot’s ten core and three extra features—including auto‑configuration, starters, externalized configuration, Actuator, DevTools, logging, transaction management, testing, and custom banners—showing how they simplify Java backend development, improve productivity, and enable production‑ready applications.

Auto-ConfigurationBackend DevelopmentJava
0 likes · 10 min read
Unlock Spring Boot’s 10+3 Must‑Know Features for Faster Java Development
Java Companion
Java Companion
Nov 4, 2025 · Backend Development

Boosting Dubbo Performance with Spring Boot Auto‑Configuration and a Multi‑Data‑Source SDK

The article details how a high‑frequency Dubbo call bottleneck was resolved by creating a conditional Spring Boot auto‑configuration multi‑data‑source SDK that dynamically loads beans, avoids bean conflicts, and enables direct database access, dramatically reducing latency and system load.

Auto-ConfigurationConditional BeanDubbo
0 likes · 12 min read
Boosting Dubbo Performance with Spring Boot Auto‑Configuration and a Multi‑Data‑Source SDK
Su San Talks Tech
Su San Talks Tech
Oct 30, 2025 · Backend Development

7 Proven Techniques to Slash Spring Boot Startup Time by Over 70%

This article walks through seven practical Spring Boot startup‑time optimizations—lazy initialization, precise component scanning, JVM tuning, auto‑configuration pruning, class‑loading reduction, lazy database connections, and AOT/layered compilation—backed by real‑world case studies and measurable performance gains.

AOTAuto-ConfigurationJVM
0 likes · 10 min read
7 Proven Techniques to Slash Spring Boot Startup Time by Over 70%
Senior Xiao Ying
Senior Xiao Ying
Oct 24, 2025 · Backend Development

Mastering Spring Boot: 10 Advanced Techniques to Design, Optimize, and Operate Your Apps

This guide explores ten advanced Spring Boot features—including conditional auto‑configuration, configuration‑property precedence, asynchronous execution, task scheduling, startup and JVM tuning, test context caching, Actuator monitoring, security setup, multi‑datasource configuration, custom starter creation, and cloud‑native deployment—to help developers move from users to masters of the framework.

Auto-ConfigurationCustom StarterMulti-DataSource
0 likes · 10 min read
Mastering Spring Boot: 10 Advanced Techniques to Design, Optimize, and Operate Your Apps
Ray's Galactic Tech
Ray's Galactic Tech
Oct 19, 2025 · Backend Development

How @Configuration Embodies the Open/Closed Principle in Spring Boot

Spring Boot’s @Configuration annotation serves as a practical implementation of the Open/Closed Principle by providing declarative, type‑safe bean definitions, enabling closed‑for‑modification business logic while remaining open for extension through modular configuration, conditional beans, and auto‑configuration mechanisms.

Auto-ConfigurationConfigurationDependency Injection
0 likes · 7 min read
How @Configuration Embodies the Open/Closed Principle in Spring Boot
Ray's Galactic Tech
Ray's Galactic Tech
Sep 24, 2025 · Backend Development

Mastering Spring Boot Auto-Configuration: Full 3.x Mechanism Explained

This article provides a comprehensive, step‑by‑step breakdown of Spring Boot's auto‑configuration system, covering its core SPI‑based design, execution flow, conditional annotations, the evolution from spring.factories to the new .imports file in version 3.x, practical examples, custom configuration creation, and debugging techniques.

Auto-ConfigurationConditional AnnotationsJava
0 likes · 7 min read
Mastering Spring Boot Auto-Configuration: Full 3.x Mechanism Explained
Java Architect Essentials
Java Architect Essentials
Jul 16, 2025 · Backend Development

Master Spring Boot Auto‑Configuration: 4 Layers Every Developer Should Know

This article demystifies Spring Boot's auto‑configuration by breaking it into four layers—annotation composition, loading engine, conditional assembly, and property binding—providing clear explanations, code examples, and common pitfalls to help developers ace interview questions and master backend development.

@ConditionalAuto-ConfigurationBackend Development
0 likes · 6 min read
Master Spring Boot Auto‑Configuration: 4 Layers Every Developer Should Know
Architect
Architect
Jul 10, 2025 · Backend Development

7 Proven Techniques to Slash Spring Boot Startup Time by 70%

Learn seven practical strategies—including lazy initialization, precise component scanning, JVM tuning, auto‑configuration pruning, dependency slimming, delayed datasource connections, and AOT/layered compilation—to dramatically reduce Spring Boot application startup time, memory usage, and class loading, with real‑world performance comparisons.

AOT compilationAuto-ConfigurationJVM Tuning
0 likes · 9 min read
7 Proven Techniques to Slash Spring Boot Startup Time by 70%
Java Captain
Java Captain
Apr 26, 2025 · Backend Development

Creating and Customizing a Spring Boot Starter with Auto‑Configuration Explained

This article explains the problems of traditional Spring MVC setup, introduces Spring Boot starters as a solution, details naming conventions and project structure for custom starters, and walks through the implementation of auto‑configuration classes, properties binding, and the spring.factories registration process.

Auto-ConfigurationJavaSpring Boot
0 likes · 9 min read
Creating and Customizing a Spring Boot Starter with Auto‑Configuration Explained
Cognitive Technology Team
Cognitive Technology Team
Mar 31, 2025 · Backend Development

Understanding Spring Boot Annotations and Auto‑Configuration

This article explains how Spring Boot replaces extensive XML configuration with annotation‑driven setup, detailing the purpose and usage of core annotations such as @SpringBootApplication and @EnableAutoConfiguration, as well as conditional annotations like @ConditionalOnClass, @ConditionalOnBean, @ConditionalOnProperty, @Profile, and provides best‑practice recommendations.

Auto-ConfigurationJavaSpring Boot
0 likes · 7 min read
Understanding Spring Boot Annotations and Auto‑Configuration
macrozheng
macrozheng
Feb 5, 2025 · Backend Development

How to Cut Spring Boot Startup Time from 7 Minutes to 40 Seconds

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
How to Cut Spring Boot Startup Time from 7 Minutes to 40 Seconds
Architect
Architect
Jan 24, 2025 · Backend Development

Unveiling Spring Boot’s Magic: How @SpringBootApplication Drives Auto‑Configuration

This article deep‑dives into Spring Boot’s inner workings, explaining why dependency versions are omitted, how the spring‑boot‑starter‑parent and spring‑boot‑dependencies manage libraries, and how the composite @SpringBootApplication annotation orchestrates @SpringBootConfiguration, @EnableAutoConfiguration, and @ComponentScan to achieve seamless auto‑configuration and rapid application startup.

Auto-ConfigurationBackend DevelopmentJava
0 likes · 29 min read
Unveiling Spring Boot’s Magic: How @SpringBootApplication Drives Auto‑Configuration
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jul 30, 2024 · Backend Development

Master Spring Boot 3.2: Auto‑Configuration, Custom Environments, and Advanced Tomcat Tweaks

This guide walks through Spring Boot 3.2.5 troubleshooting with ConditionEvaluationReport, customizing the application context and environment via listeners and EnvironmentPostProcessor, building parent‑child containers, managing embedded Tomcat MBeans, returning XML responses, customizing the whitelabel error page, and adding multiple Tomcat connectors, all illustrated with code snippets and images.

Auto-ConfigurationEmbedded TomcatEnvironmentPostProcessor
0 likes · 10 min read
Master Spring Boot 3.2: Auto‑Configuration, Custom Environments, and Advanced Tomcat Tweaks
Code Ape Tech Column
Code Ape Tech Column
Jun 13, 2024 · Backend Development

Dynamic Switching Between Spring @Scheduled and XXL‑JOB with Automatic Task Registration

This article explains how to flexibly switch between Spring's built‑in @Scheduled tasks and XXL‑JOB implementations without changing existing code, by using conditional auto‑configuration, annotation scanning, task registration, log redirection, and a ready‑to‑use starter, complete with configuration examples and runtime verification.

Auto-ConfigurationJavaSpring Boot
0 likes · 22 min read
Dynamic Switching Between Spring @Scheduled and XXL‑JOB with Automatic Task Registration
Programmer DD
Programmer DD
Mar 16, 2024 · Backend Development

How to Build Your Own Spring Boot Starter: Step‑by‑Step Guide

This article walks you through creating a custom Spring Boot Starter, covering project setup, Maven dependencies, auto‑configuration classes, registration via spring.factories (or the new imports file), and comprehensive unit testing strategies to ensure reliable conditional behavior.

Auto-ConfigurationJavaSpring Boot
0 likes · 7 min read
How to Build Your Own Spring Boot Starter: Step‑by‑Step Guide
Programmer DD
Programmer DD
Feb 29, 2024 · Backend Development

How to Build Your Own Spring Boot Starter: A Step‑by‑Step Guide

This tutorial walks you through creating a custom Spring Boot Starter, from Maven project setup and dependency configuration to defining auto‑configuration classes, registering them, and writing comprehensive unit tests to verify conditional behavior.

Auto-ConfigurationJavaSpring Boot
0 likes · 6 min read
How to Build Your Own Spring Boot Starter: A Step‑by‑Step Guide
Programmer DD
Programmer DD
Feb 27, 2024 · Backend Development

Build Your Own Spring Boot Starter: A Step‑by‑Step Guide

This tutorial explains how to create a custom Spring Boot Starter, covering project setup, Maven dependencies, auto‑configuration class creation, registration via spring.factories, and comprehensive unit testing to ensure correct conditional behavior.

Auto-ConfigurationJavaSpring Boot
0 likes · 7 min read
Build Your Own Spring Boot Starter: A Step‑by‑Step Guide
Java Architecture Diary
Java Architecture Diary
Dec 19, 2023 · Backend Development

Boost Spring Boot 3.x Compatibility with mica-auto Auto-Generated Starter Configs

This article introduces mica-auto, an annotation‑processor‑based tool that automatically generates Spring Boot starter configuration files—including spring.factories, AutoConfiguration.imports, and java SPI settings—enabling seamless compatibility with Spring Boot 3.x without maintaining separate branches.

Annotation ProcessorAuto-ConfigurationSpring Boot
0 likes · 4 min read
Boost Spring Boot 3.x Compatibility with mica-auto Auto-Generated Starter Configs
政采云技术
政采云技术
Nov 1, 2023 · Backend Development

How Spring Boot Auto-Configuration Works: From @EnableAutoConfiguration to Bean Loading

This article explains Spring Boot's auto‑configuration mechanism, covering how @EnableAutoConfiguration loads configuration classes, the role of @AutoConfigurationPackage and @Import, the processing of spring.factories and metadata files, and how the main application class is registered in the IoC container.

Auto-ConfigurationDependency InjectionJava
0 likes · 12 min read
How Spring Boot Auto-Configuration Works: From @EnableAutoConfiguration to Bean Loading
JD Cloud Developers
JD Cloud Developers
Oct 31, 2023 · Backend Development

How SpringBoot Auto‑Configuration Works and Build Your Own Logging Starter

This article explains SpringBoot’s auto‑configuration mechanism, walks through the DispatcherServlet example, and demonstrates how to build a custom logging starter—including annotation, properties class, AOP aspect, auto‑configuration class, Maven packaging, and usage—showcasing the efficiency and reusability benefits for backend developers.

Auto-ConfigurationBackend DevelopmentCustom Starter
0 likes · 9 min read
How SpringBoot Auto‑Configuration Works and Build Your Own Logging Starter
Top Architect
Top Architect
Oct 9, 2023 · Backend Development

Key Features of Spring Boot: Auto-Configuration, Starters, Embedded Server, Externalized Config, Actuator, DevTools, Testing, Ecosystem, Performance Optimization, and Continuous Learning

This article introduces Spring Boot’s core “magic” features—including auto‑configuration, starter dependencies, embedded servers, externalized configuration, Actuator, DevTools, testing support, ecosystem components, performance tips, and continuous learning—providing a comprehensive guide for building efficient Java backend applications.

Auto-ConfigurationJavaPerformance Optimization
0 likes · 10 min read
Key Features of Spring Boot: Auto-Configuration, Starters, Embedded Server, Externalized Config, Actuator, DevTools, Testing, Ecosystem, Performance Optimization, and Continuous Learning
Selected Java Interview Questions
Selected Java Interview Questions
May 4, 2023 · Backend Development

Understanding Spring Boot Starters with MyBatis: mybatis‑spring vs mybatis‑spring‑boot‑starter

This article explains the concept and purpose of Spring Boot starters, compares mybatis‑spring with mybatis‑spring‑boot‑starter through code examples, and details how the starter simplifies MyBatis integration by handling dependencies, configuration files, auto‑configuration, and mapper scanning for Java backend projects.

Auto-ConfigurationJavaMyBatis
0 likes · 7 min read
Understanding Spring Boot Starters with MyBatis: mybatis‑spring vs mybatis‑spring‑boot‑starter
Top Architect
Top Architect
Mar 15, 2023 · Backend Development

Creating a Custom Spring Boot Auto‑Configuration and Starter

This article demonstrates how to build a custom Spring Boot auto‑configuration and starter, including a conditional annotation, a WriterTemplate utility that writes to a database or file, Maven setup, property binding, and a usage example that shows the bean being auto‑configured and invoked.

Auto-ConfigurationBackend DevelopmentCustom Starter
0 likes · 17 min read
Creating a Custom Spring Boot Auto‑Configuration and Starter
macrozheng
macrozheng
Mar 15, 2023 · Backend Development

Master Java SPI: From Service Provider Interface to Spring Boot Auto‑Configuration

This article explains Java’s Service Provider Interface (SPI) mechanism, compares it with traditional APIs, demonstrates how to define interfaces, implement services, and discover them using ServiceLoader, and shows real‑world applications such as Spring Boot auto‑configuration and logging frameworks like SLF4J.

Auto-ConfigurationDependency InjectionJava
0 likes · 13 min read
Master Java SPI: From Service Provider Interface to Spring Boot Auto‑Configuration
Sanyou's Java Diary
Sanyou's Java Diary
Feb 23, 2023 · Backend Development

Unlocking Java’s SPI: How Service Provider Interface Powers Spring Boot Auto‑Configuration

This article explains Java's Service Provider Interface (SPI) mechanism, demonstrates how to define, implement, and discover services with code examples—including a smart‑home air‑conditioner scenario—and shows its practical use in Spring Boot auto‑configuration and logging frameworks like SLF4J.

Auto-ConfigurationDependency InjectionSPI
0 likes · 14 min read
Unlocking Java’s SPI: How Service Provider Interface Powers Spring Boot Auto‑Configuration
Java Architecture Diary
Java Architecture Diary
Dec 7, 2022 · Backend Development

Boost Spring Boot Development with mica-auto: Auto-Generate Config Files

The mica-auto Spring Boot starter tool leverages Java Annotation Processors to automatically generate essential configuration files such as spring.factories, AutoConfiguration.imports, aot.factories, and spring‑devtools.properties, supporting Spring Boot 2.7+ and 3.0, and simplifying native image builds with GraalVM.

Annotation ProcessorAuto-ConfigurationGraalVM
0 likes · 3 min read
Boost Spring Boot Development with mica-auto: Auto-Generate Config Files
Java Architect Essentials
Java Architect Essentials
Nov 14, 2022 · Backend Development

How Spring Boot Auto‑Configuration Works: A Deep Dive into @EnableAutoConfiguration

This article explains the inner workings of Spring Boot's auto‑configuration mechanism, covering the role of @SpringBootApplication, @EnableAutoConfiguration, spring.factories scanning, conditional annotations, and how configuration properties are bound to beans, with code examples and diagrams for clear understanding.

Auto-ConfigurationBackend DevelopmentJava
0 likes · 9 min read
How Spring Boot Auto‑Configuration Works: A Deep Dive into @EnableAutoConfiguration
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Oct 17, 2022 · Backend Development

Spring Boot Session Auto‑Configuration: How Filters and Repositories Work

This article walks through Spring Boot 2.3's session auto‑configuration process, detailing how core SessionConfiguration classes are registered, how the appropriate SessionRepository is selected based on store type, and how the SessionRepositoryFilter wraps requests and responses to manage session data with implementations such as Redis.

Auto-ConfigurationJavaRedis
0 likes · 13 min read
Spring Boot Session Auto‑Configuration: How Filters and Repositories Work
Top Architect
Top Architect
Sep 20, 2022 · Backend Development

Understanding Spring Boot Auto‑Configuration Mechanism

This article explains how Spring Boot's auto‑configuration works, detailing the role of @SpringBootApplication, @EnableAutoConfiguration, the spring.factories mechanism, conditional annotations, and how configuration properties are bound to beans such as ServerProperties, providing a clear understanding for developers and interview preparation.

Auto-ConfigurationBackend DevelopmentJava
0 likes · 9 min read
Understanding Spring Boot Auto‑Configuration Mechanism
Selected Java Interview Questions
Selected Java Interview Questions
Sep 8, 2022 · Backend Development

Understanding Spring Boot Auto‑Configuration Mechanism

This article explains how Spring Boot’s auto‑configuration works, covering the role of application properties, the @EnableAutoConfiguration annotation, condition annotations, the spring.factories mechanism, and how configuration properties are bound to beans such as ServerProperties to make settings like server.port effective.

Auto-ConfigurationJavabackend
0 likes · 7 min read
Understanding Spring Boot Auto‑Configuration Mechanism
Java High-Performance Architecture
Java High-Performance Architecture
Jul 5, 2022 · Backend Development

How Spring Boot Auto‑Configures Embedded Tomcat: A Deep Dive

This article explains Spring Boot’s auto‑configuration mechanism, focusing on how the spring‑boot‑autoconfigure module automatically sets up the embedded Tomcat server, detailing the relevant Maven dependencies, configuration classes, conditional annotations, and the lifecycle steps that create and start the Tomcat container.

Auto-ConfigurationEmbedded TomcatJava
0 likes · 15 min read
How Spring Boot Auto‑Configures Embedded Tomcat: A Deep Dive
Java High-Performance Architecture
Java High-Performance Architecture
Jun 13, 2022 · Backend Development

Understanding Spring Boot Auto-Configuration: From Basics to Custom Starter

This article explains why Spring Boot was created, outlines its key features such as convention over configuration and automatic wiring, dives into the inner workings of annotations like @EnableAutoConfiguration, demonstrates how SpringFactoriesLoader implements SPI, and guides you through building a simple starter component step by step.

Auto-ConfigurationDependency InjectionJava
0 likes · 13 min read
Understanding Spring Boot Auto-Configuration: From Basics to Custom Starter
Code Ape Tech Column
Code Ape Tech Column
May 28, 2022 · Backend Development

New Features in Spring Boot 2.7.0

Spring Boot 2.7.0 introduces major enhancements such as a new @AutoConfiguration annotation, upgraded Flyway modules, H2 2.1 support, GraphQL starter, Podman integration, Cache2k auto‑configuration, and several deprecations and test annotation improvements, providing a comprehensive update for Java backend developers.

Auto-ConfigurationCache2kGraphQL
0 likes · 6 min read
New Features in Spring Boot 2.7.0
Java Captain
Java Captain
Apr 6, 2022 · Backend Development

Understanding Spring Boot Auto‑Configuration and Bean Definition Mechanisms

This article provides a comprehensive tutorial on Spring Boot's auto‑configuration process, covering bean injection styles, XML and JavaConfig configurations, BeanDefinition internals, autowire modes, constructor argument handling, custom BeanFactoryPostProcessor usage, @Import mechanisms, and the inner workings of Spring Boot's EnableAutoConfiguration and its loading of META‑INF/spring.factories.

Auto-ConfigurationBean DefinitionDependency Injection
0 likes · 28 min read
Understanding Spring Boot Auto‑Configuration and Bean Definition Mechanisms
Java High-Performance Architecture
Java High-Performance Architecture
Mar 31, 2022 · Backend Development

How SpringBoot Auto‑Configuration Works: From @SpringBootApplication to Conditional Annotations

This article explains how SpringBoot simplifies Spring’s XML configuration by providing convention‑over‑configuration and automatic setup, walks through the key annotations such as @SpringBootApplication, @EnableAutoConfiguration, and @ComponentScan, and details the internal loading mechanism using META‑INF/spring.factories and conditional annotations.

Auto-ConfigurationJavaSpring Framework
0 likes · 13 min read
How SpringBoot Auto‑Configuration Works: From @SpringBootApplication to Conditional Annotations
Programmer DD
Programmer DD
Dec 31, 2021 · Backend Development

Unlock Spring Boot Starters: How Auto‑Configuration Simplifies Your Projects

This article explains the concept of Spring Boot starters, how they replace cumbersome Spring MVC setup with automatic dependency import and configuration, details the inner workings of Spring Boot's auto‑configuration mechanism, and guides you through creating custom starters and publishing them as reusable modules.

Auto-ConfigurationBackend DevelopmentJava
0 likes · 16 min read
Unlock Spring Boot Starters: How Auto‑Configuration Simplifies Your Projects
政采云技术
政采云技术
Dec 21, 2021 · Backend Development

Understanding the Spring Boot Startup Process and Auto‑Configuration Mechanism

This article walks through the complete Spring Boot startup sequence, illustrating the entry point, the internal run method, environment preparation, context creation, bean factory processing, and final refresh steps, while highlighting the role of auto‑configuration and providing annotated code examples.

ApplicationContextAuto-ConfigurationJava
0 likes · 8 min read
Understanding the Spring Boot Startup Process and Auto‑Configuration Mechanism
Java Architect Essentials
Java Architect Essentials
Nov 16, 2021 · Backend Development

Deep Dive into Spring Boot: IoC Container, SpringFactoriesLoader, Event Publishing, and Auto‑Configuration

This extensive tutorial explains Spring Boot’s core mechanisms—including the IoC container, class loading, SpringFactoriesLoader, event publishing, and automatic configuration—through detailed explanations and code examples, helping developers understand and extend Spring Boot’s startup process.

Auto-ConfigurationEvent PublishingIOC Container
0 likes · 38 min read
Deep Dive into Spring Boot: IoC Container, SpringFactoriesLoader, Event Publishing, and Auto‑Configuration
Architect's Tech Stack
Architect's Tech Stack
Nov 8, 2021 · Backend Development

Understanding the Spring Boot Auto‑Configuration Mechanism

This article explains how Spring Boot’s auto‑configuration works, detailing the role of @SpringBootApplication, @EnableAutoConfiguration, the spring.factories file, conditional annotations, and how configuration properties are bound to beans such as ServerProperties to make settings like server.port effective at runtime.

Auto-ConfigurationBackend DevelopmentJava
0 likes · 7 min read
Understanding the Spring Boot Auto‑Configuration Mechanism
Selected Java Interview Questions
Selected Java Interview Questions
Oct 21, 2021 · Backend Development

Deep Dive into SpringBoot Auto‑Configuration and Startup Process

This article provides a comprehensive walkthrough of SpringBoot’s auto‑configuration mechanism, covering common annotations, configuration property binding, import strategies, conditional beans, the application startup flow, and the role of META‑INF/spring.factories in loading auto‑configuration classes.

Auto-ConfigurationDependency InjectionJava
0 likes · 16 min read
Deep Dive into SpringBoot Auto‑Configuration and Startup Process
Top Architect
Top Architect
Aug 19, 2021 · Backend Development

Understanding Spring Boot Auto‑Configuration Mechanism

This article explains how Spring Boot's auto‑configuration works by loading configuration classes from spring.factories, using @EnableAutoConfiguration and conditional annotations to bind properties from application.properties or application.yml to beans such as ServerProperties, enabling rapid backend development without extensive manual setup.

Auto-ConfigurationBackend DevelopmentJava
0 likes · 8 min read
Understanding Spring Boot Auto‑Configuration Mechanism
Code Ape Tech Column
Code Ape Tech Column
Aug 10, 2021 · Backend Development

Understanding the Spring Boot Auto‑Configuration Mechanism

This article explains how Spring Boot’s auto‑configuration works, covering configuration files, key annotations like @EnableAutoConfiguration, conditionals, and the role of XxxxProperties and XxxxAutoConfiguration classes in binding properties and loading beans into the Spring container.

Auto-ConfigurationJavaSpring Boot
0 likes · 9 min read
Understanding the Spring Boot Auto‑Configuration Mechanism
Top Architect
Top Architect
Aug 2, 2021 · Backend Development

Understanding Spring Boot @SpringBootApplication and Its Auto‑Configuration Mechanism

This article explains how Spring Boot’s @SpringBootApplication annotation combines several meta‑annotations, how auto‑configuration classes are loaded from META‑INF/spring.factories, and demonstrates building a custom starter that configures a Tomcat web server, with full code examples and Maven setup.

Auto-ConfigurationJavaSpring Boot
0 likes · 14 min read
Understanding Spring Boot @SpringBootApplication and Its Auto‑Configuration Mechanism
Top Architect
Top Architect
Jun 18, 2021 · Backend Development

Understanding Spring Boot @SpringBootApplication and Its Auto‑Configuration Mechanism

This article explains how Spring Boot's @SpringBootApplication annotation combines several meta‑annotations, how auto‑configuration classes are discovered from META‑INF/spring.factories, and how the framework creates and refreshes the application context, including the embedded Tomcat web server, with illustrative code snippets.

Auto-ConfigurationBackend DevelopmentJava
0 likes · 12 min read
Understanding Spring Boot @SpringBootApplication and Its Auto‑Configuration Mechanism
Architecture Digest
Architecture Digest
Jun 11, 2021 · Backend Development

Understanding Spring Boot’s @SpringBootApplication and Auto‑Configuration Mechanism

This article explains how Spring Boot’s @SpringBootApplication annotation combines several meta‑annotations, how auto‑configuration is loaded from META‑INF/spring.factories, and how the framework creates and refreshes the application context, including the embedded Tomcat server and custom starter creation.

Auto-ConfigurationStarterdependency-injection
0 likes · 13 min read
Understanding Spring Boot’s @SpringBootApplication and Auto‑Configuration Mechanism
Java Interview Crash Guide
Java Interview Crash Guide
Apr 27, 2021 · Backend Development

Unveiling Spring Boot’s @SpringBootApplication: How It Powers Your App Startup

This article explains how the @SpringBootApplication annotation combines @Configuration, @EnableAutoConfiguration, and @ComponentScan, walks through the SpringApplication.run execution flow, and reveals the inner workings of Spring Boot’s auto‑configuration mechanism using SpringFactoriesLoader and META‑INF/spring.factories.

Auto-ConfigurationBackend DevelopmentJava
0 likes · 16 min read
Unveiling Spring Boot’s @SpringBootApplication: How It Powers Your App Startup
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Feb 20, 2021 · Backend Development

Understanding Spring Boot Auto‑Configuration and Common Annotations

This article explains how Spring Boot’s auto‑configuration works, introduces the most frequently used annotations such as @Value, @ConfigurationProperties, @Import and @Conditional, and provides practical code examples to illustrate the underlying mechanisms and startup process of a Spring Boot application.

Auto-ConfigurationBackend DevelopmentJava
0 likes · 22 min read
Understanding Spring Boot Auto‑Configuration and Common Annotations
Tuhu Marketing Technology Team
Tuhu Marketing Technology Team
Dec 26, 2020 · Backend Development

Unveiling Spring Boot Auto‑Configuration: How It Works Under the Hood

This article walks through the inner workings of Spring Boot’s auto‑configuration mechanism, starting from a simple Hello World project, dissecting key annotations like @SpringBootApplication and @EnableAutoConfiguration, and tracing the source code of selectors, import groups, and the SpringApplication run process to reveal how beans are discovered, loaded, and registered at startup.

Auto-ConfigurationDependency InjectionJava
0 likes · 27 min read
Unveiling Spring Boot Auto‑Configuration: How It Works Under the Hood
Code Ape Tech Column
Code Ape Tech Column
Nov 20, 2020 · Backend Development

How Spring Boot Auto‑Configuration Works: Inside @SpringBootApplication and @EnableAutoConfiguration

This article dissects Spring Boot's auto‑configuration mechanism by examining the source code of @SpringBootApplication, @EnableAutoConfiguration, @AutoConfigurationPackage, and the ImportSelector, explaining how starter packages, component scanning, and spring.factories drive the framework's zero‑configuration experience.

Auto-ConfigurationBackend DevelopmentJava
0 likes · 7 min read
How Spring Boot Auto‑Configuration Works: Inside @SpringBootApplication and @EnableAutoConfiguration
macrozheng
macrozheng
Nov 5, 2020 · Backend Development

Build Your Own Spring Boot Starter for SMS Integration – Step‑by‑Step Guide

This article walks you through creating a custom Spring Boot starter for SMS services, covering naming conventions, Maven dependencies, configuration properties, auto‑configuration, sender implementations, activation methods, packaging, and usage with practical code examples and diagrams.

Auto-ConfigurationJavaSpring Boot
0 likes · 12 min read
Build Your Own Spring Boot Starter for SMS Integration – Step‑by‑Step Guide
Code Ape Tech Column
Code Ape Tech Column
Oct 15, 2020 · Backend Development

Master Spring Boot Auto-Configuration: 6 Essential Annotation Patterns

This article explains six key patterns for customizing Spring Boot auto‑configuration, covering how to locate auto‑configuration classes, the role of @Conditionalxxx, @EnableConfigurationProperties, @Import, @AutoConfigurexxx annotations, and the significance of internal static configuration classes, with concrete code examples.

Auto-ConfigurationJavaSpring Boot
0 likes · 10 min read
Master Spring Boot Auto-Configuration: 6 Essential Annotation Patterns
Architecture Digest
Architecture Digest
Sep 9, 2020 · Backend Development

Spring Boot Best Practices for Building Robust Microservices

This article presents a comprehensive collection of Spring Boot best practices—ranging from custom BOM dependency management and auto‑configuration to project initialization, code organization, controller and service design, database isolation, concurrency handling, externalized configuration, logging, and testing—to help developers create maintainable, high‑quality microservice applications.

Auto-Configurationbest-practicesdependency management
0 likes · 12 min read
Spring Boot Best Practices for Building Robust Microservices
Selected Java Interview Questions
Selected Java Interview Questions
Aug 3, 2020 · Backend Development

Understanding Spring Boot’s Auto‑Configuration and “Convention over Configuration” Principles

This article explains how Spring Boot simplifies Java application development by providing out‑of‑the‑box starters, automatic configuration via spring.factories, and convention‑over‑configuration rules, covering the underlying annotations, Maven structure, starter dependencies, main class, and the use of @ConfigurationProperties to bind YAML settings.

Auto-ConfigurationBackend DevelopmentConvention over Configuration
0 likes · 25 min read
Understanding Spring Boot’s Auto‑Configuration and “Convention over Configuration” Principles
Senior Brother's Insights
Senior Brother's Insights
Jul 26, 2020 · Backend Development

How Spring Boot Auto‑Configuration Works: Deep Dive into @EnableAutoConfiguration

This article explains Spring Boot's auto‑configuration mechanism, detailing the roles of starters, spring.factories, @EnableAutoConfiguration, related annotations, and the AutoConfigurationImportSelector, while showing source code examples and how to customize or disable specific auto‑configurations.

Auto-ConfigurationBackend DevelopmentJava
0 likes · 12 min read
How Spring Boot Auto‑Configuration Works: Deep Dive into @EnableAutoConfiguration
vivo Internet Technology
vivo Internet Technology
Jun 10, 2020 · Backend Development

Understanding Spring Boot Configuration Class Parsing and Core Annotations

Spring Boot parses @SpringBootApplication by combining @SpringBootConfiguration, @EnableAutoConfiguration, and @ComponentScan, then processes @Import, @Conditional, and bean post‑processors, uses SpringFactoriesLoader for auto‑configuration, and follows an eight‑step configuration‑class parsing flow to register beans during startup.

Auto-ConfigurationBean ProcessingConfiguration
0 likes · 35 min read
Understanding Spring Boot Configuration Class Parsing and Core Annotations
Java Backend Technology
Java Backend Technology
Apr 30, 2020 · Backend Development

How Spring Boot’s Conditional Annotations Dynamically Control Bean Registration

Spring Boot provides a set of conditional annotations such as @ConditionalOnBean, @ConditionalOnClass, and @ConditionalOnMissingBean that evaluate classpath presence, bean existence, and other criteria at runtime, allowing auto‑configuration classes to be registered only when their required conditions are satisfied, with detailed implementation details and activation mechanisms explained.

Auto-ConfigurationConditional AnnotationJava
0 likes · 16 min read
How Spring Boot’s Conditional Annotations Dynamically Control Bean Registration
Programmer DD
Programmer DD
Apr 13, 2020 · Backend Development

How Spring Boot’s Conditional Annotations Dynamically Control Bean Registration

This article explains Spring Boot’s conditional annotations, such as @ConditionalOnClass and @ConditionalOnBean, detailing their definitions, underlying Condition interfaces, evaluation process, and activation mechanism, with code examples and diagrams illustrating how beans are conditionally loaded at runtime.

Auto-ConfigurationConditional AnnotationJava
0 likes · 15 min read
How Spring Boot’s Conditional Annotations Dynamically Control Bean Registration
Java Architecture Diary
Java Architecture Diary
Apr 10, 2020 · Backend Development

Automate Spring Boot Starter Setup with mica-auto

The mica-auto component of the Mica Spring Cloud framework provides a set of tools that automatically generate essential Spring Boot starter files such as spring.factories, spring‑devtools.properties, and Java SPI configurations, simplifying multi‑module backend projects and supporting annotations like @AutoService for seamless integration.

Auto-ConfigurationJava SPISpring Boot
0 likes · 4 min read
Automate Spring Boot Starter Setup with mica-auto
Wukong Talks Architecture
Wukong Talks Architecture
Mar 3, 2020 · Databases

Using JDBC in Spring Boot: Dependency Setup, DataSource Configuration, Auto‑Configuration, JdbcTemplate, Swagger Integration, and Common Troubleshooting

This tutorial explains how to integrate JDBC into a Spring Boot project, covering Maven dependencies, MySQL driver setup, application.yml datasource configuration, Spring Boot's auto‑configuration mechanism, JdbcTemplate usage, Swagger documentation, CRUD endpoint implementation, and solutions to typical connection errors.

Auto-ConfigurationJDBCJdbcTemplate
0 likes · 12 min read
Using JDBC in Spring Boot: Dependency Setup, DataSource Configuration, Auto‑Configuration, JdbcTemplate, Swagger Integration, and Common Troubleshooting
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Feb 25, 2020 · Backend Development

Top 10 High‑Frequency Spring Boot Interview Questions and Answers

This article presents ten commonly asked Spring Boot interview questions covering its core advantages, auto‑configuration, embedded servers, distributed transactions, security integrations, REST vs RPC choices, stateless service design, caching annotations, CORS setup, JPA vs Hibernate differences, and the relationship among Spring, Spring Boot, and Spring Cloud.

Auto-ConfigurationCORSInterview Questions
0 likes · 12 min read
Top 10 High‑Frequency Spring Boot Interview Questions and Answers
Architect's Tech Stack
Architect's Tech Stack
Dec 15, 2019 · Backend Development

Understanding Spring Boot, Spring MVC, and Spring: Differences and Auto‑Configuration Mechanism

This article explains the distinctions between Spring, Spring MVC, and Spring Boot, illustrates how Spring Boot achieves automatic configuration through annotations like @SpringBootApplication, @EnableAutoConfiguration, and @ComponentScan, and provides detailed code examples of the underlying mechanisms and related configuration classes.

Auto-ConfigurationBackend DevelopmentJava Annotations
0 likes · 11 min read
Understanding Spring Boot, Spring MVC, and Spring: Differences and Auto‑Configuration Mechanism
Programmer DD
Programmer DD
Nov 19, 2019 · Backend Development

Unlocking Spring Security Auto‑Configuration in Spring Boot: A Deep Dive

This article explores how Spring Security is automatically configured in Spring Boot, detailing key auto‑configuration classes such as SecurityAutoConfiguration, SpringBootWebSecurityConfiguration, WebSecurityEnablerConfiguration, and the @EnableWebSecurity annotation, while providing code snippets and explanations of their roles in the security filter chain.

Auto-ConfigurationBackend DevelopmentJava
0 likes · 15 min read
Unlocking Spring Security Auto‑Configuration in Spring Boot: A Deep Dive
Java Captain
Java Captain
Sep 21, 2019 · Backend Development

SpringBoot Auto-Configuration Principles and Startup Process

This article explains the core concepts of SpringBoot, covering commonly used annotations, the application startup sequence, and the detailed mechanism of auto-configuration, including @SpringBootApplication, @EnableAutoConfiguration, @ConfigurationProperties, and how META-INF/spring.factories files drive automatic bean registration.

Auto-ConfigurationJavaannotations
0 likes · 16 min read
SpringBoot Auto-Configuration Principles and Startup Process
Programmer DD
Programmer DD
Jun 30, 2019 · Backend Development

Master Spring Boot Auto-Configuration Tests with ApplicationContextRunner

This tutorial explains how to use Spring Boot's ApplicationContextRunner to simplify testing of auto‑configuration classes, covering class, bean, and property conditions with concrete code examples and assertions for both present and missing scenarios.

ApplicationContextRunnerAuto-ConfigurationJUnit
0 likes · 8 min read
Master Spring Boot Auto-Configuration Tests with ApplicationContextRunner
Java Backend Technology
Java Backend Technology
Sep 17, 2018 · Backend Development

Master Spring Boot: 35 Essential Q&A for Java Backend Development

This article provides a comprehensive, question‑driven guide to Spring Boot, covering its differences from Spring and Spring MVC, auto‑configuration, starter projects, embedded servers, Maven plugins, DevTools, static resources, Spring Data, REST support, request mapping nuances, and profile‑based configuration for building production‑ready Java backend applications.

Auto-ConfigurationBackend DevelopmentJava
0 likes · 17 min read
Master Spring Boot: 35 Essential Q&A for Java Backend Development
Java Captain
Java Captain
Jun 26, 2018 · Backend Development

Understanding Spring Boot Auto‑Configuration and the @Conditional Mechanism

This article explains Spring Boot's core features, the role of @Conditional in automatic configuration, demonstrates custom condition classes and annotations, and walks through the source code of Spring Boot's auto‑configuration infrastructure, including @SpringBootApplication, EnableAutoConfigurationImportSelector, and class‑path condition evaluation.

@ConditionalAuto-ConfigurationBackend Development
0 likes · 17 min read
Understanding Spring Boot Auto‑Configuration and the @Conditional Mechanism
Programmer DD
Programmer DD
Aug 20, 2017 · Backend Development

Quickly Add Swagger2 to Spring Boot with Auto-Configuration Starter

This guide shows how to quickly integrate Swagger2 into a Spring Boot 1.5.x application using the spring-boot-starter-swagger, covering Maven dependency setup, annotation usage, detailed property configuration for titles, versions, licenses, path rules, and advanced grouping features introduced in version 1.2.0.RELEASE.

API documentationAuto-ConfigurationBackend Development
0 likes · 6 min read
Quickly Add Swagger2 to Spring Boot with Auto-Configuration Starter